1  from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 2  
 3  from django.template.base import FilterExpression, Parser, Origin, Token
 4  from django.template.context import Context
 5  from django.utils.safestring import SafeText
 6  
 7  from .base import Node, Template
 8  
 9  class InvalidTemplateLibrary(Exception): ...
10  
11  class Library:
12      filters: Dict[str, Callable] = ...
13      tags: Dict[str, Callable] = ...
14      def __init__(self) -> None: ...
15      def tag(
16          self, name: Optional[Union[Callable, str]] = ..., compile_function: Optional[Union[Callable, str]] = ...
17      ) -> Callable: ...
18      def tag_function(self, func: Callable) -> Callable: ...
19      def filter(
20          self,
21          name: Optional[Union[Callable, str]] = ...,
22          filter_func: Optional[Union[Callable, str]] = ...,
23          **flags: Any
24      ) -> Callable: ...
25      def filter_function(self, func: Callable, **flags: Any) -> Callable: ...
26      def simple_tag(
27          self, func: Optional[Union[Callable, str]] = ..., takes_context: Optional[bool] = ..., name: Optional[str] = ...
28      ) -> Callable: ...
29      def inclusion_tag(
30          self,
31          filename: Union[Template, str],
32          func: None = ...,
33          takes_context: Optional[bool] = ...,
34          name: Optional[str] = ...,
35      ) -> Callable: ...
36  
37  class TagHelperNode(Node):
38      func: Any = ...
39      takes_context: Any = ...
40      args: Any = ...
41      kwargs: Any = ...
42      def __init__(
43          self,
44          func: Callable,
45          takes_context: Optional[bool],
46          args: List[FilterExpression],
47          kwargs: Dict[str, FilterExpression],
48      ) -> None: ...
49      def get_resolved_arguments(self, context: Context) -> Tuple[List[int], Dict[str, Union[SafeText, int]]]: ...
50  
51  class SimpleNode(TagHelperNode):
52      args: List[FilterExpression]
53      func: Callable
54      kwargs: Dict[str, FilterExpression]
55      origin: Origin
56      takes_context: Optional[bool]
57      token: Token
58      target_var: Optional[str] = ...
59      def __init__(
60          self,
61          func: Callable,
62          takes_context: Optional[bool],
63          args: List[FilterExpression],
64          kwargs: Dict[str, FilterExpression],
65          target_var: Optional[str],
66      ) -> None: ...
67  
68  class InclusionNode(TagHelperNode):
69      args: List[FilterExpression]
70      func: Callable
71      kwargs: Dict[str, FilterExpression]
72      origin: Origin
73      takes_context: Optional[bool]
74      token: Token
75      filename: Union[Template, str] = ...
76      def __init__(
77          self,
78          func: Callable,
79          takes_context: Optional[bool],
80          args: List[FilterExpression],
81          kwargs: Dict[str, FilterExpression],
82          filename: Optional[Union[Template, str]],
83      ) -> None: ...
84  
85  def parse_bits(
86      parser: Parser,
87      bits: List[str],
88      params: List[str],
89      varargs: Optional[str],
90      varkw: Optional[str],
91      defaults: Optional[Tuple[Union[bool, str]]],
92      kwonly: List[str],
93      kwonly_defaults: Optional[Dict[str, int]],
94      takes_context: Optional[bool],
95      name: str,
96  ) -> Tuple[List[FilterExpression], Dict[str, FilterExpression]]: ...
97  def import_library(name: str) -> Library: ...