.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/third_party/2/gflags.pyi

   1 from typing import Any, Callable, Dict, Iterable, IO, List, Optional, Union\r
   2 from types import ModuleType\r
   3 \r
   4 class FlagsError(Exception): ...\r
   5 \r
   6 class DuplicateFlag(FlagsError): ...\r
   7 \r
   8 class CantOpenFlagFileError(FlagsError): ...\r
   9 \r
  10 class DuplicateFlagCannotPropagateNoneToSwig(DuplicateFlag): ...\r
  11 \r
  12 class DuplicateFlagError(DuplicateFlag):\r
  13     def __init__(self, flagname: str, flag_values: FlagValues, other_flag_values: FlagValues = ...) -> None: ...\r
  14 \r
  15 class IllegalFlagValue(FlagsError): ...\r
  16 \r
  17 class UnrecognizedFlag(FlagsError): ...\r
  18 \r
  19 class UnrecognizedFlagError(UnrecognizedFlag):\r
  20     def __init__(self, flagname: str, flagvalue: str = ...) -> None: ...\r
  21 \r
  22 def GetHelpWidth() -> int: ...\r
  23 def CutCommonSpacePrefix(text) -> str: ...\r
  24 def TextWrap(text: str, length: int = ..., indent: str = ..., firstline_indent: str = ..., tabs: str = ...) -> str: ...\r
  25 def DocToHelp(doc: str) -> str: ...\r
  26 \r
  27 class FlagValues:\r
  28     def __init__(self) -> None: ...\r
  29     def UseGnuGetOpt(self, use_gnu_getopt: bool = ...) -> None: ...\r
  30     def IsGnuGetOpt(self) -> bool: ...\r
  31 # TODO dict type\r
  32     def FlagDict(self) -> dict: ...\r
  33     def FlagsByModuleDict(self) -> Dict[str, List[Flag]]: ...\r
  34     def FlagsByModuleIdDict(self) -> Dict[int, List[Flag]]: ...\r
  35     def KeyFlagsByModuleDict(self) -> Dict[str, List[Flag]]: ...\r
  36     def FindModuleDefiningFlag(self, flagname: str, default: str = ...) -> str: ...\r
  37     def FindModuleIdDefiningFlag(self, flagname: str, default: int = ...) -> int: ...\r
  38     def AppendFlagValues(self, flag_values: FlagValues) -> None: ...\r
  39     def RemoveFlagValues(self, flag_values: FlagValues) -> None: ...\r
  40     def __setitem__(self, name: str, flag: Flag) -> None: ...\r
  41     def __getitem__(self, name: str) -> Flag: ...\r
  42     def __getattr__(self, name: str) -> Any: ...\r
  43     def __setattr__(self, name: str, value: Any): ...\r
  44     def __delattr__(self, flag_name: str) -> None: ...\r
  45     def SetDefault(self, name: str, value: Any) -> None: ...\r
  46     def __contains__(self, name: str) -> bool: ...\r
  47     has_key = __contains__\r
  48     def __iter__(self) -> Iterable[str]: ...\r
  49     def __call__(self, argv: List[str]) -> List[str]: ...\r
  50     def Reset(self) -> None: ...\r
  51     def RegisteredFlags(self) -> List[str]: ...\r
  52     def FlagValuesDict(self) -> Dict[str, Any]: ...\r
  53     def __str__(self) -> str: ...\r
  54     def GetHelp(self, prefix: str = ...) -> str: ...\r
  55     def ModuleHelp(self, module: Union[ModuleType, str]) -> str: ...\r
  56     def MainModuleHelp(self) -> str: ...\r
  57     def get(self, name: str, default: Any) -> Any: ...\r
  58     def ShortestUniquePrefixes(self, fl: Dict[str, Flag]) -> Dict[str, str]: ...\r
  59     def ExtractFilename(self, flagfile_str: str) -> str: ...\r
  60     def ReadFlagsFromFiles(self, argv: List[str], force_gnu: bool = ...) -> List[str]: ...\r
  61     def FlagsIntoString(self) -> str: ...\r
  62     def AppendFlagsIntoFile(self, filename: str) -> None: ...\r
  63     def WriteHelpInXMLFormat(self, outfile: IO[str] = ...) -> None: ...\r
  64 # TODO validator: gflags_validators.Validator\r
  65     def AddValidator(self, validator: Any) -> None: ...\r
  66 \r
  67 FLAGS = ...  # type: FlagValues\r
  68 \r
  69 class Flag:\r
  70     name = ...  # type: str\r
  71     default = ...  # type: Any\r
  72     default_as_str = ...  # type: str\r
  73     value = ...  # type: Any\r
  74     help = ...  # type: str\r
  75     short_name = ...  # type: str\r
  76     boolean = False\r
  77     present = False\r
  78     parser = ...  # type: ArgumentParser\r
  79     serializer = ...  # type: ArgumentSerializer\r
  80     allow_override = False\r
  81 \r
  82     def __init__(self, parser: ArgumentParser, serializer: ArgumentSerializer, name: str,\r
  83                default: Optional[str], help_string: str, short_name: str = ..., boolean: bool = ...,\r
  84                allow_override: bool = ...) -> None: ...\r
  85     def Parse(self, argument: Any) -> Any: ...\r
  86     def Unparse(self) -> None: ...\r
  87     def Serialize(self) -> str: ...\r
  88     def SetDefault(self, value: Any) -> None: ...\r
  89     def Type(self) -> str: ...\r
  90     def WriteInfoInXMLFormat(self, outfile: IO[str], module_name: str, is_key: bool = ..., indent: str = ...) -> None: ...\r
  91 \r
  92 class ArgumentParser(object):\r
  93     syntactic_help = ...  # type: str\r
  94 # TODO what is this\r
  95     def Parse(self, argument: Any) -> Any: ...\r
  96     def Type(self) -> str: ...\r
  97     def WriteCustomInfoInXMLFormat(self, outfile: IO[str], indent: str) -> None: ...\r
  98 \r
  99 class ArgumentSerializer:\r
 100     def Serialize(self, value: Any) -> unicode: ...\r
 101 \r
 102 class ListSerializer(ArgumentSerializer):\r
 103     def __init__(self, list_sep: str) -> None: ...\r
 104     def Serialize(self, value: List[Any]) -> str: ...\r
 105 \r
 106 def RegisterValidator(flag_name: str,\r
 107                       checker: Callable[[Any], bool],\r
 108                       message: str = ...,\r
 109                       flag_values: FlagValues = ...) -> None: ...\r
 110 def MarkFlagAsRequired(flag_name: str, flag_values: FlagValues = ...) -> None: ...\r
 111 \r
 112 def DEFINE(parser: ArgumentParser, name: str, default: Any, help: str,\r
 113            flag_values: FlagValues = ..., serializer: ArgumentSerializer = ..., **args: Any) -> None: ...\r
 114 def DEFINE_flag(flag: Flag, flag_values: FlagValues = ...) -> None: ...\r
 115 def DECLARE_key_flag(flag_name: str, flag_values: FlagValues = ...) -> None: ...\r
 116 def ADOPT_module_key_flags(module: ModuleType, flag_values: FlagValues = ...) -> None: ...\r
 117 def DEFINE_string(name: str, default: Optional[str], help: str, flag_values: FlagValues = ..., **args: Any): ...\r
 118 \r
 119 class BooleanParser(ArgumentParser):\r
 120     def Convert(self, argument: Any) -> bool: ...\r
 121     def Parse(self, argument: Any) -> bool: ...\r
 122     def Type(self) -> str: ...\r
 123 \r
 124 class BooleanFlag(Flag):\r
 125     def __init__(self, name: str, default: Optional[bool], help: str, short_name=..., **args: Any) -> None: ...\r
 126 \r
 127 def DEFINE_boolean(name: str, default: Optional[bool], help: str, flag_values: FlagValues = ..., **args: Any) -> None: ...\r
 128 \r
 129 DEFINE_bool = DEFINE_boolean\r
 130 \r
 131 class HelpFlag(BooleanFlag):\r
 132     def __init__(self) -> None: ...\r
 133     def Parse(self, arg: Any) -> None: ...\r
 134 \r
 135 class HelpXMLFlag(BooleanFlag):\r
 136     def __init__(self) -> None: ...\r
 137     def Parse(self, arg: Any) -> None: ...\r
 138 \r
 139 class HelpshortFlag(BooleanFlag):\r
 140     def __init__(self) -> None: ...\r
 141     def Parse(self, arg: Any) -> None: ...\r
 142 \r
 143 class NumericParser(ArgumentParser):\r
 144     def IsOutsideBounds(self, val: float) -> bool: ...\r
 145     def Parse(self, argument: Any) -> float: ...\r
 146     def WriteCustomInfoInXMLFormat(self, outfile: IO[str], indent: str) -> None: ...\r
 147     def Convert(self, argument: Any) -> Any: ...\r
 148 \r
 149 class FloatParser(NumericParser):\r
 150     number_article = ...  # type: str\r
 151     number_name = ...  # type: str\r
 152     syntactic_help = ...  # type: str\r
 153     def __init__(self, lower_bound: float = ..., upper_bound: float = ...) -> None: ...\r
 154     def Convert(self, argument: Any) -> float: ...\r
 155     def Type(self) -> str: ...\r
 156 \r
 157 def DEFINE_float(name: str, default: Optional[float], help: str, lower_bound: float = ...,\r
 158                  upper_bound: float = ..., flag_values: FlagValues = ..., **args: Any) -> None: ...\r
 159 \r
 160 class IntegerParser(NumericParser):\r
 161     number_article = ...  # type: str\r
 162     number_name = ...  # type: str\r
 163     syntactic_help = ...  # type: str\r
 164     def __init__(self, lower_bound: int = ..., upper_bound: int = ...) -> None: ...\r
 165     def Convert(self, argument: Any) -> int: ...\r
 166     def Type(self) -> str: ...\r
 167 \r
 168 def DEFINE_integer(name: str, default: Optional[int], help: str, lower_bound: int = ...,\r
 169                    upper_bound: int = ..., flag_values: FlagValues = ..., **args: Any) -> None: ...\r
 170 \r
 171 class EnumParser(ArgumentParser):\r
 172     def __init__(self, enum_values: List[str]) -> None: ...\r
 173     def Parse(self, argument: Any) -> Any: ...\r
 174     def Type(self) -> str: ...\r
 175 \r
 176 class EnumFlag(Flag):\r
 177     def __init__(self, name: str, default: Optional[str], help: str, enum_values: List[str],\r
 178                short_name: str, **args: Any) -> None: ...\r
 179 \r
 180 def DEFINE_enum(name: str, default: Optional[str], enum_values: List[str], help: str,\r
 181                 flag_values: FlagValues = ..., **args: Any) -> None: ...\r
 182 \r
 183 class BaseListParser(ArgumentParser):\r
 184     def __init__(self, token: str = ..., name: str = ...) -> None: ...\r
 185     def Parse(self, argument: Any) -> list: ...\r
 186     def Type(self) -> str: ...\r
 187 \r
 188 class ListParser(BaseListParser):\r
 189     def __init__(self) -> None: ...\r
 190     def WriteCustomInfoInXMLFormat(self, outfile: IO[str], indent: str): ...\r
 191 \r
 192 class WhitespaceSeparatedListParser(BaseListParser):\r
 193     def __init__(self) -> None: ...\r
 194     def WriteCustomInfoInXMLFormat(self, outfile: IO[str], indent: str): ...\r
 195 \r
 196 def DEFINE_list(name: str, default: Optional[List[str]], help: str, flag_values: FlagValues = ..., **args: Any) -> None: ...\r
 197 def DEFINE_spaceseplist(name: str, default: Optional[List[str]], help: str, flag_values: FlagValues = ..., **args: Any) -> None: ...\r
 198 \r
 199 class MultiFlag(Flag):\r
 200     def __init__(self, *args: Any, **kwargs: Any) -> None: ...\r
 201     def Parse(self, arguments: Any) -> None: ...\r
 202     def Serialize(self) -> str: ...\r
 203     def Type(self) -> str: ...\r
 204 \r
 205 def DEFINE_multistring(name: str, default: Optional[Union[str, List[str]]], help: str,\r
 206                        flag_values: FlagValues = ..., **args: Any) -> None: ...\r
 207 \r
 208 def DEFINE_multi_int(name: str, default: Optional[Union[int, List[int]]], help: str, lower_bound: int = ...,\r
 209                      upper_bound: int = ..., flag_values: FlagValues = ..., **args: Any) -> None: ...\r
 210 \r
 211 \r
 212 def DEFINE_multi_float(name: str, default: Optional[Union[float, List[float]]], help: str,\r
 213                        lower_bound: float = ..., upper_bound: float = ...,\r
 214                        flag_values: FlagValues = ..., **args: Any) -> None: ...\r