Datasets:
Razvan27
/
ML4SE-Python

Dataset card Data Studio Files
xet
Community
1
id
int64
0
458k
file_name
stringlengths
4
119
file_path
stringlengths
14
227
content
stringlengths
24
9.96M
size
int64
24
9.96M
language
stringclasses
1 value
extension
stringclasses
14 values
total_lines
int64
1
219k
avg_line_length
float64
2.52
4.63M
max_line_length
int64
5
9.91M
alphanum_fraction
float64
0
1
repo_name
stringlengths
7
101
repo_stars
int64
100
139k
repo_forks
int64
0
26.4k
repo_open_issues
int64
0
2.27k
repo_license
stringclasses
12 values
repo_extraction_date
stringclasses
433 values
29,000
archive_util.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/archive_util.pyi
from typing import Optional def make_archive( base_name: str, format: str, root_dir: Optional[str] = ..., base_dir: Optional[str] = ..., verbose: int = ..., dry_run: int = ..., ) -> str: ... def make_tarball(base_name: str, base_dir: str, compress: Optional[str] = ..., verbose: int = ..., dry_run: int = ...) -> str: ... def make_zipfile(base_name: str, base_dir: str, verbose: int = ..., dry_run: int = ...) -> str: ...
447
Python
.py
11
37.363636
130
0.572414
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,001
dist.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/dist.pyi
from distutils.cmd import Command from typing import Any, Dict, Iterable, Mapping, Optional, Text, Tuple, Type class Distribution: cmdclass: Dict[str, Type[Command]] def __init__(self, attrs: Optional[Mapping[str, Any]] = ...) -> None: ... def get_option_dict(self, command: str) -> Dict[str, Tuple[str, Text]]: ... def parse_config_files(self, filenames: Optional[Iterable[Text]] = ...) -> None: ... def get_command_obj(self, command: str, create: bool = ...) -> Optional[Command]: ...
508
Python
.py
8
59.875
89
0.665331
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,002
core.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/core.pyi
from distutils.cmd import Command as Command from distutils.dist import Distribution as Distribution from distutils.extension import Extension as Extension from typing import Any, List, Mapping, Optional, Tuple, Type, Union def setup( *, name: str = ..., version: str = ..., description: str = ..., long_description: str = ..., author: str = ..., author_email: str = ..., maintainer: str = ..., maintainer_email: str = ..., url: str = ..., download_url: str = ..., packages: List[str] = ..., py_modules: List[str] = ..., scripts: List[str] = ..., ext_modules: List[Extension] = ..., classifiers: List[str] = ..., distclass: Type[Distribution] = ..., script_name: str = ..., script_args: List[str] = ..., options: Mapping[str, Any] = ..., license: str = ..., keywords: Union[List[str], str] = ..., platforms: Union[List[str], str] = ..., cmdclass: Mapping[str, Type[Command]] = ..., data_files: List[Tuple[str, List[str]]] = ..., package_dir: Mapping[str, str] = ..., obsoletes: List[str] = ..., provides: List[str] = ..., requires: List[str] = ..., command_packages: List[str] = ..., command_options: Mapping[str, Mapping[str, Tuple[Any, Any]]] = ..., package_data: Mapping[str, List[str]] = ..., include_package_data: bool = ..., libraries: List[str] = ..., headers: List[str] = ..., ext_package: str = ..., include_dirs: List[str] = ..., password: str = ..., fullname: str = ..., **attrs: Any, ) -> None: ... def run_setup(script_name: str, script_args: Optional[List[str]] = ..., stop_after: str = ...) -> Distribution: ...
1,688
Python
.py
47
31.489362
115
0.577439
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,003
text_file.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/text_file.pyi
from typing import IO, List, Optional, Tuple, Union class TextFile: def __init__( self, filename: Optional[str] = ..., file: Optional[IO[str]] = ..., *, strip_comments: bool = ..., lstrip_ws: bool = ..., rstrip_ws: bool = ..., skip_blanks: bool = ..., join_lines: bool = ..., collapse_join: bool = ..., ) -> None: ... def open(self, filename: str) -> None: ... def close(self) -> None: ... def warn(self, msg: str, line: Union[List[int], Tuple[int, int], int] = ...) -> None: ... def readline(self) -> Optional[str]: ... def readlines(self) -> List[str]: ... def unreadline(self, line: str) -> str: ...
716
Python
.py
20
29.15
93
0.513669
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,004
extension.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/extension.pyi
from typing import List, Optional, Tuple class Extension: def __init__( self, name: str, sources: List[str], include_dirs: List[str] = ..., define_macros: List[Tuple[str, Optional[str]]] = ..., undef_macros: List[str] = ..., library_dirs: List[str] = ..., libraries: List[str] = ..., runtime_library_dirs: List[str] = ..., extra_objects: List[str] = ..., extra_compile_args: List[str] = ..., extra_link_args: List[str] = ..., export_symbols: List[str] = ..., swig_opts: Optional[str] = ..., # undocumented depends: List[str] = ..., language: str = ..., ) -> None: ...
706
Python
.py
20
27.45
61
0.512409
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,005
errors.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/errors.pyi
class DistutilsError(Exception): ... class DistutilsModuleError(DistutilsError): ... class DistutilsClassError(DistutilsError): ... class DistutilsGetoptError(DistutilsError): ... class DistutilsArgError(DistutilsError): ... class DistutilsFileError(DistutilsError): ... class DistutilsOptionError(DistutilsError): ... class DistutilsSetupError(DistutilsError): ... class DistutilsPlatformError(DistutilsError): ... class DistutilsExecError(DistutilsError): ... class DistutilsInternalError(DistutilsError): ... class DistutilsTemplateError(DistutilsError): ... class DistutilsByteCompileError(DistutilsError): ... class CCompilerError(Exception): ... class PreprocessError(CCompilerError): ... class CompileError(CCompilerError): ... class LibError(CCompilerError): ... class LinkError(CCompilerError): ... class UnknownFileError(CCompilerError): ...
852
Python
.py
19
43.842105
52
0.817527
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,006
spawn.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/spawn.pyi
from typing import List, Optional def spawn(cmd: List[str], search_path: bool = ..., verbose: bool = ..., dry_run: bool = ...) -> None: ... def find_executable(executable: str, path: Optional[str] = ...) -> Optional[str]: ...
227
Python
.py
3
74.333333
105
0.632287
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,007
fancy_getopt.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/fancy_getopt.pyi
from typing import Any, List, Mapping, Optional, Tuple, Union, overload _Option = Tuple[str, Optional[str], str] _GR = Tuple[List[str], OptionDummy] def fancy_getopt( options: List[_Option], negative_opt: Mapping[_Option, _Option], object: Any, args: Optional[List[str]] ) -> Union[List[str], _GR]: ... def wrap_text(text: str, width: int) -> List[str]: ... class FancyGetopt: def __init__(self, option_table: Optional[List[_Option]] = ...) -> None: ... # TODO kinda wrong, `getopt(object=object())` is invalid @overload def getopt(self, args: Optional[List[str]] = ...) -> _GR: ... @overload def getopt(self, args: Optional[List[str]], object: Any) -> List[str]: ... def get_option_order(self) -> List[Tuple[str, str]]: ... def generate_help(self, header: Optional[str] = ...) -> List[str]: ... class OptionDummy: ...
859
Python
.py
17
47.176471
107
0.643198
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,008
version.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/version.pyi
from abc import abstractmethod from typing import Optional, Pattern, Text, Tuple, TypeVar, Union _T = TypeVar("_T", bound=Version) class Version: def __repr__(self) -> str: ... @abstractmethod def __init__(self, vstring: Optional[Text] = ...) -> None: ... @abstractmethod def parse(self: _T, vstring: Text) -> _T: ... @abstractmethod def __str__(self) -> str: ... @abstractmethod def __cmp__(self: _T, other: Union[_T, str]) -> bool: ... class StrictVersion(Version): version_re: Pattern[str] version: Tuple[int, int, int] prerelease: Optional[Tuple[Text, int]] def __init__(self, vstring: Optional[Text] = ...) -> None: ... def parse(self: _T, vstring: Text) -> _T: ... def __str__(self) -> str: ... def __cmp__(self: _T, other: Union[_T, str]) -> bool: ... class LooseVersion(Version): component_re: Pattern[str] vstring: Text version: Tuple[Union[Text, int], ...] def __init__(self, vstring: Optional[Text] = ...) -> None: ... def parse(self: _T, vstring: Text) -> _T: ... def __str__(self) -> str: ... def __cmp__(self: _T, other: Union[_T, str]) -> bool: ...
1,160
Python
.py
29
35.689655
66
0.585626
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,009
dep_util.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/dep_util.pyi
from typing import List, Tuple def newer(source: str, target: str) -> bool: ... def newer_pairwise(sources: List[str], targets: List[str]) -> List[Tuple[str, str]]: ... def newer_group(sources: List[str], target: str, missing: str = ...) -> bool: ...
252
Python
.py
4
61.75
88
0.663968
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,010
dir_util.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/dir_util.pyi
from typing import List def mkpath(name: str, mode: int = ..., verbose: int = ..., dry_run: int = ...) -> List[str]: ... def create_tree(base_dir: str, files: List[str], mode: int = ..., verbose: int = ..., dry_run: int = ...) -> None: ... def copy_tree( src: str, dst: str, preserve_mode: int = ..., preserve_times: int = ..., preserve_symlinks: int = ..., update: int = ..., verbose: int = ..., dry_run: int = ..., ) -> List[str]: ... def remove_tree(directory: str, verbose: int = ..., dry_run: int = ...) -> None: ...
555
Python
.py
14
36.285714
118
0.537037
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,011
cmd.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/cmd.pyi
from abc import abstractmethod from distutils.dist import Distribution from typing import Any, Callable, Iterable, List, Optional, Text, Tuple, Union class Command: sub_commands: List[Tuple[str, Optional[Callable[[Command], bool]]]] def __init__(self, dist: Distribution) -> None: ... @abstractmethod def initialize_options(self) -> None: ... @abstractmethod def finalize_options(self) -> None: ... @abstractmethod def run(self) -> None: ... def announce(self, msg: Text, level: int = ...) -> None: ... def debug_print(self, msg: Text) -> None: ... def ensure_string(self, option: str, default: Optional[str] = ...) -> None: ... def ensure_string_list(self, option: Union[str, List[str]]) -> None: ... def ensure_filename(self, option: str) -> None: ... def ensure_dirname(self, option: str) -> None: ... def get_command_name(self) -> str: ... def set_undefined_options(self, src_cmd: Text, *option_pairs: Tuple[str, str]) -> None: ... def get_finalized_command(self, command: Text, create: int = ...) -> Command: ... def reinitialize_command(self, command: Union[Command, Text], reinit_subcommands: int = ...) -> Command: ... def run_command(self, command: Text) -> None: ... def get_sub_commands(self) -> List[str]: ... def warn(self, msg: Text) -> None: ... def execute(self, func: Callable[..., Any], args: Iterable[Any], msg: Optional[Text] = ..., level: int = ...) -> None: ... def mkpath(self, name: str, mode: int = ...) -> None: ... def copy_file( self, infile: str, outfile: str, preserve_mode: int = ..., preserve_times: int = ..., link: Optional[str] = ..., level: Any = ..., ) -> Tuple[str, bool]: ... # level is not used def copy_tree( self, infile: str, outfile: str, preserve_mode: int = ..., preserve_times: int = ..., preserve_symlinks: int = ..., level: Any = ..., ) -> List[str]: ... # level is not used def move_file(self, src: str, dst: str, level: Any = ...) -> str: ... # level is not used def spawn(self, cmd: Iterable[str], search_path: int = ..., level: Any = ...) -> None: ... # level is not used def make_archive( self, base_name: str, format: str, root_dir: Optional[str] = ..., base_dir: Optional[str] = ..., owner: Optional[str] = ..., group: Optional[str] = ..., ) -> str: ... def make_file( self, infiles: Union[str, List[str], Tuple[str]], outfile: str, func: Callable[..., Any], args: List[Any], exec_msg: Optional[str] = ..., skip_msg: Optional[str] = ..., level: Any = ..., ) -> None: ... # level is not used
2,817
Python
.py
66
36.151515
126
0.562909
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,012
sysconfig.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/sysconfig.pyi
from distutils.ccompiler import CCompiler from typing import Mapping, Optional, Union PREFIX: str EXEC_PREFIX: str def get_config_var(name: str) -> Union[int, str, None]: ... def get_config_vars(*args: str) -> Mapping[str, Union[int, str]]: ... def get_config_h_filename() -> str: ... def get_makefile_filename() -> str: ... def get_python_inc(plat_specific: bool = ..., prefix: Optional[str] = ...) -> str: ... def get_python_lib(plat_specific: bool = ..., standard_lib: bool = ..., prefix: Optional[str] = ...) -> str: ... def customize_compiler(compiler: CCompiler) -> None: ... def set_python_build() -> None: ...
620
Python
.py
12
50.5
112
0.666667
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,013
log.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/log.pyi
from typing import Any, Text DEBUG: int INFO: int WARN: int ERROR: int FATAL: int class Log: def __init__(self, threshold: int = ...) -> None: ... def log(self, level: int, msg: Text, *args: Any) -> None: ... def debug(self, msg: Text, *args: Any) -> None: ... def info(self, msg: Text, *args: Any) -> None: ... def warn(self, msg: Text, *args: Any) -> None: ... def error(self, msg: Text, *args: Any) -> None: ... def fatal(self, msg: Text, *args: Any) -> None: ... def log(level: int, msg: Text, *args: Any) -> None: ... def debug(msg: Text, *args: Any) -> None: ... def info(msg: Text, *args: Any) -> None: ... def warn(msg: Text, *args: Any) -> None: ... def error(msg: Text, *args: Any) -> None: ... def fatal(msg: Text, *args: Any) -> None: ... def set_threshold(level: int) -> int: ... def set_verbosity(v: int) -> None: ...
863
Python
.py
22
36.818182
65
0.583532
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,014
config.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/command/config.pyi
from distutils import log as log from distutils.ccompiler import CCompiler from distutils.core import Command as Command from distutils.errors import DistutilsExecError as DistutilsExecError from distutils.sysconfig import customize_compiler as customize_compiler from typing import Dict, List, Optional, Pattern, Sequence, Tuple, Union LANG_EXT: Dict[str, str] class config(Command): description: str = ... # Tuple is full name, short name, description user_options: Sequence[Tuple[str, Optional[str], str]] = ... compiler: Optional[Union[str, CCompiler]] = ... cc: Optional[str] = ... include_dirs: Optional[Sequence[str]] = ... libraries: Optional[Sequence[str]] = ... library_dirs: Optional[Sequence[str]] = ... noisy: int = ... dump_source: int = ... temp_files: Sequence[str] = ... def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ... def try_cpp( self, body: Optional[str] = ..., headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def search_cpp( self, pattern: Union[Pattern[str], str], body: Optional[str] = ..., headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def try_compile( self, body: str, headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., lang: str = ... ) -> bool: ... def try_link( self, body: str, headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., libraries: Optional[Sequence[str]] = ..., library_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def try_run( self, body: str, headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., libraries: Optional[Sequence[str]] = ..., library_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def check_func( self, func: str, headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., libraries: Optional[Sequence[str]] = ..., library_dirs: Optional[Sequence[str]] = ..., decl: int = ..., call: int = ..., ) -> bool: ... def check_lib( self, library: str, library_dirs: Optional[Sequence[str]] = ..., headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., other_libraries: List[str] = ..., ) -> bool: ... def check_header( self, header: str, include_dirs: Optional[Sequence[str]] = ..., library_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def dump_file(filename: str, head: Optional[str] = ...) -> None: ...
3,059
Python
.py
84
29.666667
125
0.566958
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,015
build_py.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/command/build_py.pyi
from distutils.cmd import Command class build_py(Command): def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ...
181
Python
.py
5
32.6
45
0.662857
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,016
install_egg_info.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/command/install_egg_info.pyi
from distutils.cmd import Command from typing import ClassVar, List, Optional, Tuple class install_egg_info(Command): description: ClassVar[str] user_options: ClassVar[List[Tuple[str, Optional[str], str]]] def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ... def get_outputs(self) -> List[str]: ...
380
Python
.py
9
38.444444
64
0.689189
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,017
upload.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/command/upload.pyi
from distutils.config import PyPIRCCommand from typing import ClassVar, List, Optional, Tuple class upload(PyPIRCCommand): description: ClassVar[str] boolean_options: ClassVar[List[str]] def run(self) -> None: ... def upload_file(self, command, pyversion, filename) -> None: ...
296
Python
.py
7
38.857143
68
0.739583
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,018
install.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/command/install.pyi
from distutils.cmd import Command from typing import Optional, Text class install(Command): user: bool prefix: Optional[Text] home: Optional[Text] root: Optional[Text] install_lib: Optional[Text] def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ...
338
Python
.py
11
26.727273
45
0.687117
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,019
bdist_msi.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/distutils/command/bdist_msi.pyi
from distutils.cmd import Command class bdist_msi(Command): def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ...
182
Python
.py
5
32.8
45
0.664773
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,020
util.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/multiprocessing/util.pyi
import threading from typing import Any, Optional SUBDEBUG: Any SUBWARNING: Any def sub_debug(msg, *args): ... def debug(msg, *args): ... def info(msg, *args): ... def sub_warning(msg, *args): ... def get_logger(): ... def log_to_stderr(level: Optional[Any] = ...): ... def get_temp_dir(): ... def register_after_fork(obj, func): ... class Finalize: def __init__(self, obj, callback, args=..., kwargs: Optional[Any] = ..., exitpriority: Optional[Any] = ...): ... def __call__(self, wr: Optional[Any] = ...): ... def cancel(self): ... def still_active(self): ... def is_exiting(): ... class ForkAwareThreadLock: def __init__(self): ... class ForkAwareLocal(threading.local): def __init__(self): ... def __reduce__(self): ...
758
Python
.py
23
30.478261
116
0.621399
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,021
pool.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/multiprocessing/pool.pyi
from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, TypeVar _T = TypeVar("_T", bound=Pool) class AsyncResult: def get(self, timeout: Optional[float] = ...) -> Any: ... def wait(self, timeout: Optional[float] = ...) -> None: ... def ready(self) -> bool: ... def successful(self) -> bool: ... class IMapIterator(Iterator[Any]): def __iter__(self) -> Iterator[Any]: ... def next(self, timeout: Optional[float] = ...) -> Any: ... class IMapUnorderedIterator(IMapIterator): ... class Pool(object): def __init__( self, processes: Optional[int] = ..., initializer: Optional[Callable[..., None]] = ..., initargs: Iterable[Any] = ..., maxtasksperchild: Optional[int] = ..., ) -> None: ... def apply(self, func: Callable[..., Any], args: Iterable[Any] = ..., kwds: Dict[str, Any] = ...) -> Any: ... def apply_async( self, func: Callable[..., Any], args: Iterable[Any] = ..., kwds: Dict[str, Any] = ..., callback: Optional[Callable[..., None]] = ..., ) -> AsyncResult: ... def map(self, func: Callable[..., Any], iterable: Iterable[Any] = ..., chunksize: Optional[int] = ...) -> List[Any]: ... def map_async( self, func: Callable[..., Any], iterable: Iterable[Any] = ..., chunksize: Optional[int] = ..., callback: Optional[Callable[..., None]] = ..., ) -> AsyncResult: ... def imap(self, func: Callable[..., Any], iterable: Iterable[Any] = ..., chunksize: Optional[int] = ...) -> IMapIterator: ... def imap_unordered( self, func: Callable[..., Any], iterable: Iterable[Any] = ..., chunksize: Optional[int] = ... ) -> IMapIterator: ... def close(self) -> None: ... def terminate(self) -> None: ... def join(self) -> None: ... class ThreadPool(Pool): def __init__( self, processes: Optional[int] = ..., initializer: Optional[Callable[..., Any]] = ..., initargs: Iterable[Any] = ... ) -> None: ...
2,038
Python
.py
46
38.304348
128
0.558409
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,022
process.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/multiprocessing/process.pyi
from typing import Any, Optional def current_process(): ... def active_children(): ... class Process: def __init__( self, group: Optional[Any] = ..., target: Optional[Any] = ..., name: Optional[Any] = ..., args=..., kwargs=... ): ... def run(self): ... def start(self): ... def terminate(self): ... def join(self, timeout: Optional[Any] = ...): ... def is_alive(self): ... @property def name(self): ... @name.setter def name(self, name): ... @property def daemon(self): ... @daemon.setter def daemon(self, daemonic): ... @property def authkey(self): ... @authkey.setter def authkey(self, authkey): ... @property def exitcode(self): ... @property def ident(self): ... pid: Any class AuthenticationString(bytes): def __reduce__(self): ... class _MainProcess(Process): def __init__(self): ...
906
Python
.py
33
22.939394
118
0.578826
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,023
__init__.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/multiprocessing/__init__.pyi
from multiprocessing import pool from multiprocessing.process import Process as Process, active_children as active_children, current_process as current_process from multiprocessing.util import SUBDEBUG as SUBDEBUG, SUBWARNING as SUBWARNING from Queue import Queue as _BaseQueue from typing import Any, Callable, Iterable, Optional, TypeVar class ProcessError(Exception): ... class BufferTooShort(ProcessError): ... class TimeoutError(ProcessError): ... class AuthenticationError(ProcessError): ... _T = TypeVar("_T") class Queue(_BaseQueue[_T]): def __init__(self, maxsize: int = ...) -> None: ... def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ... def put(self, item: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ... def qsize(self) -> int: ... def empty(self) -> bool: ... def full(self) -> bool: ... def put_nowait(self, item: _T) -> None: ... def get_nowait(self) -> _T: ... def close(self) -> None: ... def join_thread(self) -> None: ... def cancel_join_thread(self) -> None: ... def Manager(): ... def Pipe(duplex: bool = ...): ... def cpu_count() -> int: ... def freeze_support(): ... def get_logger(): ... def log_to_stderr(level: Optional[Any] = ...): ... def allow_connection_pickling(): ... def Lock(): ... def RLock(): ... def Condition(lock: Optional[Any] = ...): ... def Semaphore(value: int = ...): ... def BoundedSemaphore(value: int = ...): ... def Event(): ... def JoinableQueue(maxsize: int = ...): ... def RawValue(typecode_or_type, *args): ... def RawArray(typecode_or_type, size_or_initializer): ... def Value(typecode_or_type, *args, **kwds): ... def Array(typecode_or_type, size_or_initializer, **kwds): ... def Pool( processes: Optional[int] = ..., initializer: Optional[Callable[..., Any]] = ..., initargs: Iterable[Any] = ..., maxtasksperchild: Optional[int] = ..., ) -> pool.Pool: ...
1,921
Python
.py
46
39.369565
126
0.644575
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,024
__init__.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/multiprocessing/dummy/__init__.pyi
import array import itertools import sys import threading import weakref from multiprocessing import TimeoutError, cpu_count from multiprocessing.dummy.connection import Pipe from Queue import Queue from threading import BoundedSemaphore, Event, Lock, RLock, Semaphore from typing import Any, List, Optional, Type class DummyProcess(threading.Thread): _children: weakref.WeakKeyDictionary[Any, Any] _parent: threading.Thread _pid: None _start_called: bool def __init__(self, group=..., target=..., name=..., args=..., kwargs=...) -> None: ... @property def exitcode(self) -> Optional[int]: ... Process = DummyProcess # This should be threading._Condition but threading.pyi exports it as Condition class Condition(threading.Condition): notify_all: Any class Namespace(object): def __init__(self, **kwds) -> None: ... class Value(object): _typecode: Any _value: Any value: Any def __init__(self, typecode, value, lock=...) -> None: ... def _get(self) -> Any: ... def _set(self, value) -> None: ... JoinableQueue = Queue def Array(typecode, sequence, lock=...) -> array.array[Any]: ... def Manager() -> Any: ... def Pool(processes=..., initializer=..., initargs=...) -> Any: ... def active_children() -> List[Any]: ... def current_process() -> threading.Thread: ... def freeze_support() -> None: ... def shutdown() -> None: ...
1,392
Python
.py
39
32.974359
90
0.688707
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,025
connection.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/multiprocessing/dummy/connection.pyi
from Queue import Queue from typing import Any, List, Optional, Tuple, Type families: List[None] class Connection(object): _in: Any _out: Any recv: Any recv_bytes: Any send: Any send_bytes: Any def __init__(self, _in, _out) -> None: ... def close(self) -> None: ... def poll(self, timeout=...) -> Any: ... class Listener(object): _backlog_queue: Optional[Queue[Any]] address: Any def __init__(self, address=..., family=..., backlog=...) -> None: ... def accept(self) -> Connection: ... def close(self) -> None: ... def Client(address) -> Connection: ... def Pipe(duplex=...) -> Tuple[Connection, Connection]: ...
673
Python
.py
21
28.190476
73
0.614198
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,026
__init__.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/os/__init__.pyi
import sys from _typeshed import AnyPath, FileDescriptorLike from builtins import OSError from io import TextIOWrapper as _TextIOWrapper from posix import listdir as listdir, stat_result as stat_result # TODO: use this, see https://github.com/python/mypy/issues/3078 from typing import ( IO, Any, AnyStr, Callable, Dict, Generic, Iterator, List, Mapping, MutableMapping, NamedTuple, NoReturn, Optional, Sequence, Set, Text, Tuple, TypeVar, Union, overload, ) from . import path as path # We need to use something from path, or flake8 and pytype get unhappy _supports_unicode_filenames = path.supports_unicode_filenames _T = TypeVar("_T") # ----- os variables ----- error = OSError if sys.version_info >= (3, 2): supports_bytes_environ: bool if sys.version_info >= (3, 3): supports_dir_fd: Set[Callable[..., Any]] supports_fd: Set[Callable[..., Any]] supports_effective_ids: Set[Callable[..., Any]] supports_follow_symlinks: Set[Callable[..., Any]] SEEK_SET: int SEEK_CUR: int SEEK_END: int O_RDONLY: int O_WRONLY: int O_RDWR: int O_APPEND: int O_CREAT: int O_EXCL: int O_TRUNC: int # We don't use sys.platform for O_* flags to denote platform-dependent APIs because some codes, # including tests for mypy, use a more finer way than sys.platform before using these APIs # See https://github.com/python/typeshed/pull/2286 for discussions O_DSYNC: int # Unix only O_RSYNC: int # Unix only O_SYNC: int # Unix only O_NDELAY: int # Unix only O_NONBLOCK: int # Unix only O_NOCTTY: int # Unix only O_SHLOCK: int # Unix only O_EXLOCK: int # Unix only O_BINARY: int # Windows only O_NOINHERIT: int # Windows only O_SHORT_LIVED: int # Windows only O_TEMPORARY: int # Windows only O_RANDOM: int # Windows only O_SEQUENTIAL: int # Windows only O_TEXT: int # Windows only O_ASYNC: int # Gnu extension if in C library O_DIRECT: int # Gnu extension if in C library O_DIRECTORY: int # Gnu extension if in C library O_NOFOLLOW: int # Gnu extension if in C library O_NOATIME: int # Gnu extension if in C library O_LARGEFILE: int # Gnu extension if in C library curdir: str pardir: str sep: str if sys.platform == "win32": altsep: str else: altsep: Optional[str] extsep: str pathsep: str defpath: str linesep: str devnull: str name: str F_OK: int R_OK: int W_OK: int X_OK: int class _Environ(MutableMapping[AnyStr, AnyStr], Generic[AnyStr]): def copy(self) -> Dict[AnyStr, AnyStr]: ... def __delitem__(self, key: AnyStr) -> None: ... def __getitem__(self, key: AnyStr) -> AnyStr: ... def __setitem__(self, key: AnyStr, value: AnyStr) -> None: ... def __iter__(self) -> Iterator[AnyStr]: ... def __len__(self) -> int: ... environ: _Environ[str] if sys.version_info >= (3, 2): environb: _Environ[bytes] if sys.platform != "win32": # Unix only confstr_names: Dict[str, int] pathconf_names: Dict[str, int] sysconf_names: Dict[str, int] EX_OK: int EX_USAGE: int EX_DATAERR: int EX_NOINPUT: int EX_NOUSER: int EX_NOHOST: int EX_UNAVAILABLE: int EX_SOFTWARE: int EX_OSERR: int EX_OSFILE: int EX_CANTCREAT: int EX_IOERR: int EX_TEMPFAIL: int EX_PROTOCOL: int EX_NOPERM: int EX_CONFIG: int EX_NOTFOUND: int P_NOWAIT: int P_NOWAITO: int P_WAIT: int if sys.platform == "win32": P_DETACH: int P_OVERLAY: int # wait()/waitpid() options if sys.platform != "win32": WNOHANG: int # Unix only WCONTINUED: int # some Unix systems WUNTRACED: int # Unix only TMP_MAX: int # Undocumented, but used by tempfile # ----- os classes (structures) ----- if sys.version_info >= (3, 6): from builtins import _PathLike PathLike = _PathLike # See comment in builtins class _StatVFS(NamedTuple): f_bsize: int f_frsize: int f_blocks: int f_bfree: int f_bavail: int f_files: int f_ffree: int f_favail: int f_flag: int f_namemax: int def getlogin() -> str: ... def getpid() -> int: ... def getppid() -> int: ... def strerror(code: int) -> str: ... def umask(mask: int) -> int: ... if sys.platform != "win32": def ctermid() -> str: ... def getegid() -> int: ... def geteuid() -> int: ... def getgid() -> int: ... def getgroups() -> List[int]: ... # Unix only, behaves differently on Mac def initgroups(username: str, gid: int) -> None: ... def getpgid(pid: int) -> int: ... def getpgrp() -> int: ... def getresuid() -> Tuple[int, int, int]: ... def getresgid() -> Tuple[int, int, int]: ... def getuid() -> int: ... def setegid(egid: int) -> None: ... def seteuid(euid: int) -> None: ... def setgid(gid: int) -> None: ... def setgroups(groups: Sequence[int]) -> None: ... def setpgrp() -> None: ... def setpgid(pid: int, pgrp: int) -> None: ... def setregid(rgid: int, egid: int) -> None: ... def setresgid(rgid: int, egid: int, sgid: int) -> None: ... def setresuid(ruid: int, euid: int, suid: int) -> None: ... def setreuid(ruid: int, euid: int) -> None: ... def getsid(pid: int) -> int: ... def setsid() -> None: ... def setuid(uid: int) -> None: ... def uname() -> Tuple[str, str, str, str, str]: ... @overload def getenv(key: Text) -> Optional[str]: ... @overload def getenv(key: Text, default: _T) -> Union[str, _T]: ... def putenv(key: Union[bytes, Text], value: Union[bytes, Text]) -> None: ... def unsetenv(key: Union[bytes, Text]) -> None: ... def fdopen(fd: int, *args, **kwargs) -> IO[Any]: ... def close(fd: int) -> None: ... def closerange(fd_low: int, fd_high: int) -> None: ... def dup(fd: int) -> int: ... def dup2(fd: int, fd2: int) -> None: ... def fstat(fd: int) -> Any: ... def fsync(fd: FileDescriptorLike) -> None: ... def lseek(fd: int, pos: int, how: int) -> int: ... def open(file: AnyPath, flags: int, mode: int = ...) -> int: ... def pipe() -> Tuple[int, int]: ... def read(fd: int, n: int) -> bytes: ... def write(fd: int, string: Union[bytes, buffer]) -> int: ... def access(path: AnyPath, mode: int) -> bool: ... def chdir(path: AnyPath) -> None: ... def fchdir(fd: FileDescriptorLike) -> None: ... def getcwd() -> str: ... def getcwdu() -> unicode: ... def chmod(path: AnyPath, mode: int) -> None: ... def link(src: AnyPath, link_name: AnyPath) -> None: ... def lstat(path: AnyPath) -> Any: ... def mknod(filename: AnyPath, mode: int = ..., device: int = ...) -> None: ... def major(device: int) -> int: ... def minor(device: int) -> int: ... def makedev(major: int, minor: int) -> int: ... def mkdir(path: AnyPath, mode: int = ...) -> None: ... def makedirs(path: AnyPath, mode: int = ...) -> None: ... def readlink(path: AnyStr) -> AnyStr: ... def remove(path: AnyPath) -> None: ... def removedirs(path: AnyPath) -> None: ... def rename(src: AnyPath, dst: AnyPath) -> None: ... def renames(old: AnyPath, new: AnyPath) -> None: ... def rmdir(path: AnyPath) -> None: ... def stat(path: AnyPath) -> Any: ... @overload def stat_float_times() -> bool: ... @overload def stat_float_times(newvalue: bool) -> None: ... def symlink(source: AnyPath, link_name: AnyPath) -> None: ... def unlink(path: AnyPath) -> None: ... # TODO: add ns, dir_fd, follow_symlinks argument if sys.version_info >= (3, 0): def utime(path: AnyPath, times: Optional[Tuple[float, float]] = ...) -> None: ... else: def utime(path: AnyPath, times: Optional[Tuple[float, float]]) -> None: ... if sys.platform != "win32": # Unix only def fchmod(fd: int, mode: int) -> None: ... def fchown(fd: int, uid: int, gid: int) -> None: ... if sys.platform != "darwin": def fdatasync(fd: FileDescriptorLike) -> None: ... # Unix only, not Mac def fpathconf(fd: int, name: Union[str, int]) -> int: ... def fstatvfs(fd: int) -> _StatVFS: ... def ftruncate(fd: int, length: int) -> None: ... def isatty(fd: int) -> bool: ... def openpty() -> Tuple[int, int]: ... # some flavors of Unix def tcgetpgrp(fd: int) -> int: ... def tcsetpgrp(fd: int, pg: int) -> None: ... def ttyname(fd: int) -> str: ... def chflags(path: AnyPath, flags: int) -> None: ... def chroot(path: AnyPath) -> None: ... def chown(path: AnyPath, uid: int, gid: int) -> None: ... def lchflags(path: AnyPath, flags: int) -> None: ... def lchmod(path: AnyPath, mode: int) -> None: ... def lchown(path: AnyPath, uid: int, gid: int) -> None: ... def mkfifo(path: AnyPath, mode: int = ...) -> None: ... def pathconf(path: AnyPath, name: Union[str, int]) -> int: ... def statvfs(path: AnyPath) -> _StatVFS: ... if sys.version_info >= (3, 6): def walk( top: Union[AnyStr, PathLike[AnyStr]], topdown: bool = ..., onerror: Optional[Callable[[OSError], Any]] = ..., followlinks: bool = ..., ) -> Iterator[Tuple[AnyStr, List[AnyStr], List[AnyStr]]]: ... else: def walk( top: AnyStr, topdown: bool = ..., onerror: Optional[Callable[[OSError], Any]] = ..., followlinks: bool = ... ) -> Iterator[Tuple[AnyStr, List[AnyStr], List[AnyStr]]]: ... def abort() -> NoReturn: ... # These are defined as execl(file, *args) but the first *arg is mandatory. def execl(file: AnyPath, __arg0: Union[bytes, Text], *args: Union[bytes, Text]) -> NoReturn: ... def execlp(file: AnyPath, __arg0: Union[bytes, Text], *args: Union[bytes, Text]) -> NoReturn: ... # These are: execle(file, *args, env) but env is pulled from the last element of the args. def execle(file: AnyPath, __arg0: Union[bytes, Text], *args: Any) -> NoReturn: ... def execlpe(file: AnyPath, __arg0: Union[bytes, Text], *args: Any) -> NoReturn: ... # The docs say `args: tuple or list of strings` # The implementation enforces tuple or list so we can't use Sequence. _ExecVArgs = Union[Tuple[Union[bytes, Text], ...], List[bytes], List[Text], List[Union[bytes, Text]]] def execv(path: AnyPath, args: _ExecVArgs) -> NoReturn: ... def execve(path: AnyPath, args: _ExecVArgs, env: Mapping[str, str]) -> NoReturn: ... def execvp(file: AnyPath, args: _ExecVArgs) -> NoReturn: ... def execvpe(file: AnyPath, args: _ExecVArgs, env: Mapping[str, str]) -> NoReturn: ... def _exit(n: int) -> NoReturn: ... def kill(pid: int, sig: int) -> None: ... if sys.platform != "win32": # Unix only def fork() -> int: ... def forkpty() -> Tuple[int, int]: ... # some flavors of Unix def killpg(__pgid: int, __signal: int) -> None: ... def nice(increment: int) -> int: ... def plock(op: int) -> None: ... # ???op is int? if sys.version_info >= (3, 0): class popen(_TextIOWrapper): # TODO 'b' modes or bytes command not accepted? def __init__(self, command: str, mode: str = ..., bufsize: int = ...) -> None: ... def close(self) -> Any: ... # may return int else: def popen(command: str, *args, **kwargs) -> IO[Any]: ... def popen2(cmd: str, *args, **kwargs) -> Tuple[IO[Any], IO[Any]]: ... def popen3(cmd: str, *args, **kwargs) -> Tuple[IO[Any], IO[Any], IO[Any]]: ... def popen4(cmd: str, *args, **kwargs) -> Tuple[IO[Any], IO[Any]]: ... def spawnl(mode: int, path: AnyPath, arg0: Union[bytes, Text], *args: Union[bytes, Text]) -> int: ... def spawnle(mode: int, path: AnyPath, arg0: Union[bytes, Text], *args: Any) -> int: ... # Imprecise sig def spawnv(mode: int, path: AnyPath, args: List[Union[bytes, Text]]) -> int: ... def spawnve(mode: int, path: AnyPath, args: List[Union[bytes, Text]], env: Mapping[str, str]) -> int: ... def system(command: AnyPath) -> int: ... def times() -> Tuple[float, float, float, float, float]: ... def waitpid(pid: int, options: int) -> Tuple[int, int]: ... def urandom(n: int) -> bytes: ... if sys.platform == "win32": def startfile(path: AnyPath, operation: Optional[str] = ...) -> None: ... else: # Unix only def spawnlp(mode: int, file: AnyPath, arg0: Union[bytes, Text], *args: Union[bytes, Text]) -> int: ... def spawnlpe(mode: int, file: AnyPath, arg0: Union[bytes, Text], *args: Any) -> int: ... # Imprecise signature def spawnvp(mode: int, file: AnyPath, args: List[Union[bytes, Text]]) -> int: ... def spawnvpe(mode: int, file: AnyPath, args: List[Union[bytes, Text]], env: Mapping[str, str]) -> int: ... def wait() -> Tuple[int, int]: ... def wait3(options: int) -> Tuple[int, int, Any]: ... def wait4(pid: int, options: int) -> Tuple[int, int, Any]: ... def WCOREDUMP(status: int) -> bool: ... def WIFCONTINUED(status: int) -> bool: ... def WIFSTOPPED(status: int) -> bool: ... def WIFSIGNALED(status: int) -> bool: ... def WIFEXITED(status: int) -> bool: ... def WEXITSTATUS(status: int) -> int: ... def WSTOPSIG(status: int) -> int: ... def WTERMSIG(status: int) -> int: ... def confstr(name: Union[str, int]) -> Optional[str]: ... def getloadavg() -> Tuple[float, float, float]: ... def sysconf(name: Union[str, int]) -> int: ... if sys.version_info >= (3, 0): def sched_getaffinity(id: int) -> Set[int]: ... if sys.version_info >= (3, 3): class waitresult: si_pid: int def waitid(idtype: int, id: int, options: int) -> waitresult: ... if sys.version_info < (3, 0): def tmpfile() -> IO[Any]: ... def tmpnam() -> str: ... def tempnam(dir: str = ..., prefix: str = ...) -> str: ... P_ALL: int WEXITED: int WNOWAIT: int
13,380
Python
.py
341
35.985337
130
0.624702
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,027
path.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/os/path.pyi
import os import sys from _typeshed import AnyPath, BytesPath, StrPath from genericpath import exists as exists from typing import Any, AnyStr, Callable, List, Optional, Sequence, Text, Tuple, TypeVar, overload _T = TypeVar("_T") # ----- os.path variables ----- supports_unicode_filenames: bool # aliases (also in os) curdir: str pardir: str sep: str if sys.platform == "win32": altsep: str else: altsep: Optional[str] extsep: str pathsep: str defpath: str devnull: str # ----- os.path function stubs ----- def abspath(path: AnyStr) -> AnyStr: ... def basename(p: AnyStr) -> AnyStr: ... def dirname(p: AnyStr) -> AnyStr: ... def expanduser(path: AnyStr) -> AnyStr: ... def expandvars(path: AnyStr) -> AnyStr: ... def normcase(s: AnyStr) -> AnyStr: ... def normpath(path: AnyStr) -> AnyStr: ... if sys.platform == "win32": def realpath(path: AnyStr) -> AnyStr: ... else: def realpath(filename: AnyStr) -> AnyStr: ... # NOTE: Empty lists results in '' (str) regardless of contained type. # Also, in Python 2 mixed sequences of Text and bytes results in either Text or bytes # So, fall back to Any def commonprefix(m: Sequence[AnyPath]) -> Any: ... def lexists(path: AnyPath) -> bool: ... # These return float if os.stat_float_times() == True, # but int is a subclass of float. def getatime(filename: AnyPath) -> float: ... def getmtime(filename: AnyPath) -> float: ... def getctime(filename: AnyPath) -> float: ... def getsize(filename: AnyPath) -> int: ... def isabs(s: AnyPath) -> bool: ... def isfile(path: AnyPath) -> bool: ... def isdir(s: AnyPath) -> bool: ... def islink(path: AnyPath) -> bool: ... def ismount(path: AnyPath) -> bool: ... # Make sure signatures are disjunct, and allow combinations of bytes and unicode. # (Since Python 2 allows that, too) # Note that e.g. os.path.join("a", "b", "c", "d", u"e") will still result in # a type error. @overload def join(__p1: bytes, *p: bytes) -> bytes: ... @overload def join(__p1: bytes, __p2: bytes, __p3: bytes, __p4: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: bytes, __p3: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: Text, *p: AnyPath) -> Text: ... @overload def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ... @overload def relpath(path: StrPath, start: Optional[StrPath] = ...) -> Text: ... def samefile(f1: AnyPath, f2: AnyPath) -> bool: ... def sameopenfile(fp1: int, fp2: int) -> bool: ... def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ... def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... if sys.platform == "win32": def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... # deprecated def walk(path: AnyStr, visit: Callable[[_T, AnyStr, List[AnyStr]], Any], arg: _T) -> None: ...
2,937
Python
.py
75
37.76
98
0.670056
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,028
base64mime.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/base64mime.pyi
def base64_len(s: bytes) -> int: ... def header_encode(header, charset=..., keep_eols=..., maxlinelen=..., eol=...): ... def encode(s, binary=..., maxlinelen=..., eol=...): ... body_encode = encode encodestring = encode def decode(s, convert_eols=...): ... body_decode = decode decodestring = decode
303
Python
.py
8
36.5
83
0.643836
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,029
quoprimime.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/quoprimime.pyi
def header_quopri_check(c): ... def body_quopri_check(c): ... def header_quopri_len(s): ... def body_quopri_len(str): ... def unquote(s): ... def quote(c): ... def header_encode(header, charset: str = ..., keep_eols: bool = ..., maxlinelen: int = ..., eol=...): ... def encode(body, binary: bool = ..., maxlinelen: int = ..., eol=...): ... body_encode = encode encodestring = encode def decode(encoded, eol=...): ... body_decode = decode decodestring = decode def header_decode(s): ...
490
Python
.py
14
33.714286
105
0.633475
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,030
utils.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/utils.pyi
from email._parseaddr import ( AddressList as _AddressList, mktime_tz as mktime_tz, parsedate as _parsedate, parsedate_tz as _parsedate_tz, ) from quopri import decodestring as _qdecode from typing import Any, Optional def formataddr(pair): ... def getaddresses(fieldvalues): ... def formatdate(timeval: Optional[Any] = ..., localtime: bool = ..., usegmt: bool = ...): ... def make_msgid(idstring: Optional[Any] = ...): ... def parsedate(data): ... def parsedate_tz(data): ... def parseaddr(addr): ... def unquote(str): ... def decode_rfc2231(s): ... def encode_rfc2231(s, charset: Optional[Any] = ..., language: Optional[Any] = ...): ... def decode_params(params): ... def collapse_rfc2231_value(value, errors=..., fallback_charset=...): ...
760
Python
.py
20
36.15
92
0.684709
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,031
feedparser.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/feedparser.pyi
class BufferedSubFile: def __init__(self) -> None: ... def push_eof_matcher(self, pred) -> None: ... def pop_eof_matcher(self): ... def close(self) -> None: ... def readline(self): ... def unreadline(self, line) -> None: ... def push(self, data): ... def pushlines(self, lines) -> None: ... def is_closed(self): ... def __iter__(self): ... def next(self): ... class FeedParser: def __init__(self, _factory=...) -> None: ... def feed(self, data) -> None: ... def close(self): ...
536
Python
.py
16
28.9375
49
0.549133
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,032
__init__.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/__init__.pyi
from typing import IO, Any, AnyStr def message_from_string(s: AnyStr, *args, **kwargs): ... def message_from_bytes(s: str, *args, **kwargs): ... def message_from_file(fp: IO[AnyStr], *args, **kwargs): ... def message_from_binary_file(fp: IO[str], *args, **kwargs): ...
270
Python
.py
5
52.8
63
0.666667
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,033
iterators.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/iterators.pyi
from typing import Any, Generator def walk(self) -> Generator[Any, Any, Any]: ... def body_line_iterator(msg, decode: bool = ...) -> Generator[Any, Any, Any]: ... def typed_subpart_iterator(msg, maintype=..., subtype=...) -> Generator[Any, Any, Any]: ...
256
Python
.py
4
62.75
91
0.661355
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,034
parser.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/parser.pyi
from .feedparser import FeedParser as FeedParser # not in __all__ but listed in documentation class Parser: def __init__(self, *args, **kws) -> None: ... def parse(self, fp, headersonly: bool = ...): ... def parsestr(self, text, headersonly: bool = ...): ... class HeaderParser(Parser): def parse(self, fp, headersonly: bool = ...): ... def parsestr(self, text, headersonly: bool = ...): ...
415
Python
.py
8
48.125
94
0.632099
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,035
encoders.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/encoders.pyi
def encode_base64(msg) -> None: ... def encode_quopri(msg) -> None: ... def encode_7or8bit(msg) -> None: ... def encode_noop(msg) -> None: ...
143
Python
.py
4
34.75
36
0.625899
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,036
generator.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/generator.pyi
class Generator: def __init__(self, outfp, mangle_from_: bool = ..., maxheaderlen: int = ...) -> None: ... def write(self, s) -> None: ... def flatten(self, msg, unixfrom: bool = ...) -> None: ... def clone(self, fp): ... class DecodedGenerator(Generator): def __init__(self, outfp, mangle_from_: bool = ..., maxheaderlen: int = ..., fmt=...) -> None: ...
377
Python
.py
7
49.857143
102
0.566396
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,037
charset.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/charset.pyi
def add_charset(charset, header_enc=..., body_enc=..., output_charset=...) -> None: ... def add_alias(alias, canonical) -> None: ... def add_codec(charset, codecname) -> None: ... QP: int # undocumented BASE64: int # undocumented SHORTEST: int # undocumented class Charset: input_charset = ... header_encoding = ... body_encoding = ... output_charset = ... input_codec = ... output_codec = ... def __init__(self, input_charset=...) -> None: ... def __eq__(self, other): ... def __ne__(self, other): ... def get_body_encoding(self): ... def convert(self, s): ... def to_splittable(self, s): ... def from_splittable(self, ustr, to_output: bool = ...): ... def get_output_charset(self): ... def encoded_header_len(self, s): ... def header_encode(self, s, convert: bool = ...): ... def body_encode(self, s, convert: bool = ...): ...
902
Python
.py
24
33.666667
87
0.586758
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,038
header.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/header.pyi
def decode_header(header): ... def make_header(decoded_seq, maxlinelen=..., header_name=..., continuation_ws=...): ... class Header: def __init__(self, s=..., charset=..., maxlinelen=..., header_name=..., continuation_ws=..., errors=...) -> None: ... def __unicode__(self): ... def __eq__(self, other): ... def __ne__(self, other): ... def append(self, s, charset=..., errors=...) -> None: ... def encode(self, splitchars=...): ...
457
Python
.py
9
47
121
0.55481
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,039
_parseaddr.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/_parseaddr.pyi
from typing import Any, Optional def parsedate_tz(data): ... def parsedate(data): ... def mktime_tz(data): ... def quote(str): ... class AddrlistClass: specials: Any pos: Any LWS: Any CR: Any FWS: Any atomends: Any phraseends: Any field: Any commentlist: Any def __init__(self, field): ... def gotonext(self): ... def getaddrlist(self): ... def getaddress(self): ... def getrouteaddr(self): ... def getaddrspec(self): ... def getdomain(self): ... def getdelimited(self, beginchar, endchars, allowcomments: bool = ...): ... def getquote(self): ... def getcomment(self): ... def getdomainliteral(self): ... def getatom(self, atomends: Optional[Any] = ...): ... def getphraselist(self): ... class AddressList(AddrlistClass): addresslist: Any def __init__(self, field): ... def __len__(self): ... def __add__(self, other): ... def __iadd__(self, other): ... def __sub__(self, other): ... def __isub__(self, other): ... def __getitem__(self, index): ...
1,072
Python
.py
37
24.648649
79
0.59593
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,040
message.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/message.pyi
from typing import Any, Generator class Message: preamble = ... epilogue = ... defects = ... def __init__(self): ... def as_string(self, unixfrom=...): ... def is_multipart(self) -> bool: ... def set_unixfrom(self, unixfrom) -> None: ... def get_unixfrom(self): ... def attach(self, payload) -> None: ... def get_payload(self, i=..., decode: bool = ...): ... def set_payload(self, payload, charset=...) -> None: ... def set_charset(self, charset): ... def get_charset(self): ... def __len__(self): ... def __getitem__(self, name): ... def __setitem__(self, name, val) -> None: ... def __delitem__(self, name) -> None: ... def __contains__(self, name): ... def has_key(self, name) -> bool: ... def keys(self): ... def values(self): ... def items(self): ... def get(self, name, failobj=...): ... def get_all(self, name, failobj=...): ... def add_header(self, _name, _value, **_params) -> None: ... def replace_header(self, _name, _value) -> None: ... def get_content_type(self): ... def get_content_maintype(self): ... def get_content_subtype(self): ... def get_default_type(self): ... def set_default_type(self, ctype) -> None: ... def get_params(self, failobj=..., header=..., unquote: bool = ...): ... def get_param(self, param, failobj=..., header=..., unquote: bool = ...): ... def set_param(self, param, value, header=..., requote: bool = ..., charset=..., language=...) -> None: ... def del_param(self, param, header=..., requote: bool = ...): ... def set_type(self, type, header=..., requote: bool = ...): ... def get_filename(self, failobj=...): ... def get_boundary(self, failobj=...): ... def set_boundary(self, boundary) -> None: ... def get_content_charset(self, failobj=...): ... def get_charsets(self, failobj=...): ... def walk(self) -> Generator[Any, Any, Any]: ...
1,950
Python
.py
44
39.477273
110
0.55748
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,041
MIMEText.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/MIMEText.pyi
from email.mime.nonmultipart import MIMENonMultipart class MIMEText(MIMENonMultipart): def __init__(self, _text, _subtype=..., _charset=...) -> None: ...
159
Python
.py
3
50.333333
70
0.703226
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,042
application.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/mime/application.pyi
from email.mime.nonmultipart import MIMENonMultipart from typing import Callable, Optional, Tuple, Union _ParamsType = Union[str, None, Tuple[str, Optional[str], str]] class MIMEApplication(MIMENonMultipart): def __init__( self, _data: bytes, _subtype: str = ..., _encoder: Callable[[MIMEApplication], None] = ..., **_params: _ParamsType ) -> None: ...
371
Python
.py
7
49.428571
122
0.698895
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,043
base.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/mime/base.pyi
from email import message class MIMEBase(message.Message): def __init__(self, _maintype, _subtype, **_params) -> None: ...
128
Python
.py
3
40
67
0.685484
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,044
multipart.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/mime/multipart.pyi
from email.mime.base import MIMEBase class MIMEMultipart(MIMEBase): def __init__(self, _subtype=..., boundary=..., _subparts=..., **_params) -> None: ...
159
Python
.py
3
50.333333
89
0.651613
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,045
message.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/mime/message.pyi
from email.mime.nonmultipart import MIMENonMultipart class MIMEMessage(MIMENonMultipart): def __init__(self, _msg, _subtype=...) -> None: ...
147
Python
.py
3
46.333333
55
0.727273
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,046
nonmultipart.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/mime/nonmultipart.pyi
from email.mime.base import MIMEBase class MIMENonMultipart(MIMEBase): def attach(self, payload): ...
107
Python
.py
3
33
36
0.776699
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,047
audio.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/mime/audio.pyi
from email.mime.nonmultipart import MIMENonMultipart class MIMEAudio(MIMENonMultipart): def __init__(self, _audiodata, _subtype=..., _encoder=..., **_params) -> None: ...
176
Python
.py
3
56
86
0.703488
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,048
image.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/mime/image.pyi
from email.mime.nonmultipart import MIMENonMultipart class MIMEImage(MIMENonMultipart): def __init__(self, _imagedata, _subtype=..., _encoder=..., **_params) -> None: ...
176
Python
.py
3
56
86
0.703488
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,049
text.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2/email/mime/text.pyi
from email.mime.nonmultipart import MIMENonMultipart class MIMEText(MIMENonMultipart): def __init__(self, _text, _subtype=..., _charset=...) -> None: ...
159
Python
.py
3
50.333333
70
0.703226
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,050
cgi.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/cgi.pyi
import sys from _typeshed import SupportsGetItem, SupportsItemAccess from builtins import type as _type from typing import IO, Any, AnyStr, Dict, Iterable, Iterator, List, Mapping, Optional, Protocol, Tuple, TypeVar, Union _T = TypeVar("_T", bound=FieldStorage) def parse( fp: Optional[IO[Any]] = ..., environ: SupportsItemAccess[str, str] = ..., keep_blank_values: bool = ..., strict_parsing: bool = ..., ) -> Dict[str, List[str]]: ... if sys.version_info < (3, 8): def parse_qs(qs: str, keep_blank_values: bool = ..., strict_parsing: bool = ...) -> Dict[str, List[str]]: ... def parse_qsl(qs: str, keep_blank_values: bool = ..., strict_parsing: bool = ...) -> List[Tuple[str, str]]: ... if sys.version_info >= (3, 7): def parse_multipart( fp: IO[Any], pdict: SupportsGetItem[str, bytes], encoding: str = ..., errors: str = ... ) -> Dict[str, List[Any]]: ... else: def parse_multipart(fp: IO[Any], pdict: SupportsGetItem[str, bytes]) -> Dict[str, List[bytes]]: ... class _Environ(Protocol): def __getitem__(self, __k: str) -> str: ... def keys(self) -> Iterable[str]: ... def parse_header(line: str) -> Tuple[str, Dict[str, str]]: ... def test(environ: _Environ = ...) -> None: ... def print_environ(environ: _Environ = ...) -> None: ... def print_form(form: Dict[str, Any]) -> None: ... def print_directory() -> None: ... def print_environ_usage() -> None: ... if sys.version_info < (3,): def escape(s: AnyStr, quote: bool = ...) -> AnyStr: ... elif sys.version_info < (3, 8): def escape(s: str, quote: Optional[bool] = ...) -> str: ... class MiniFieldStorage: # The first five "Any" attributes here are always None, but mypy doesn't support that filename: Any list: Any type: Any file: Optional[IO[bytes]] type_options: Dict[Any, Any] disposition: Any disposition_options: Dict[Any, Any] headers: Dict[Any, Any] name: Any value: Any def __init__(self, name: Any, value: Any) -> None: ... def __repr__(self) -> str: ... class FieldStorage(object): FieldStorageClass: Optional[_type] keep_blank_values: int strict_parsing: int qs_on_post: Optional[str] headers: Mapping[str, str] fp: IO[bytes] encoding: str errors: str outerboundary: bytes bytes_read: int limit: Optional[int] disposition: str disposition_options: Dict[str, str] filename: Optional[str] file: Optional[IO[bytes]] type: str type_options: Dict[str, str] innerboundary: bytes length: int done: int list: Optional[List[Any]] value: Union[None, bytes, List[Any]] if sys.version_info >= (3, 6): def __init__( self, fp: Optional[IO[Any]] = ..., headers: Optional[Mapping[str, str]] = ..., outerboundary: bytes = ..., environ: SupportsGetItem[str, str] = ..., keep_blank_values: int = ..., strict_parsing: int = ..., limit: Optional[int] = ..., encoding: str = ..., errors: str = ..., max_num_fields: Optional[int] = ..., ) -> None: ... elif sys.version_info >= (3, 0): def __init__( self, fp: Optional[IO[Any]] = ..., headers: Optional[Mapping[str, str]] = ..., outerboundary: bytes = ..., environ: SupportsGetItem[str, str] = ..., keep_blank_values: int = ..., strict_parsing: int = ..., limit: Optional[int] = ..., encoding: str = ..., errors: str = ..., ) -> None: ... else: def __init__( self, fp: IO[Any] = ..., headers: Mapping[str, str] = ..., outerboundary: bytes = ..., environ: SupportsGetItem[str, str] = ..., keep_blank_values: int = ..., strict_parsing: int = ..., ) -> None: ... if sys.version_info >= (3, 0): def __enter__(self: _T) -> _T: ... def __exit__(self, *args: Any) -> None: ... def __repr__(self) -> str: ... def __iter__(self) -> Iterator[str]: ... def __getitem__(self, key: str) -> Any: ... def getvalue(self, key: str, default: Any = ...) -> Any: ... def getfirst(self, key: str, default: Any = ...) -> Any: ... def getlist(self, key: str) -> List[Any]: ... def keys(self) -> List[str]: ... if sys.version_info < (3, 0): def has_key(self, key: str) -> bool: ... def __contains__(self, key: str) -> bool: ... def __len__(self) -> int: ... if sys.version_info >= (3, 0): def __bool__(self) -> bool: ... else: def __nonzero__(self) -> bool: ... if sys.version_info >= (3, 0): # In Python 3 it returns bytes or str IO depending on an internal flag def make_file(self) -> IO[Any]: ... else: # In Python 2 it always returns bytes and ignores the "binary" flag def make_file(self, binary: Any = ...) -> IO[bytes]: ... if sys.version_info < (3, 0): from UserDict import UserDict class FormContentDict(UserDict[str, List[str]]): query_string: str def __init__(self, environ: Mapping[str, str] = ..., keep_blank_values: int = ..., strict_parsing: int = ...) -> None: ... class SvFormContentDict(FormContentDict): def getlist(self, key: Any) -> Any: ... class InterpFormContentDict(SvFormContentDict): ... class FormContent(FormContentDict): # TODO this should have # def values(self, key: Any) -> Any: ... # but this is incompatible with the supertype, and adding '# type: ignore' triggers # a parse error in pytype (https://github.com/google/pytype/issues/53) def indexed_value(self, key: Any, location: int) -> Any: ... def value(self, key: Any) -> Any: ... def length(self, key: Any) -> int: ... def stripped(self, key: Any) -> Any: ... def pars(self) -> Dict[Any, Any]: ...
6,016
Python
.py
149
33.624161
130
0.561326
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,051
pydoc.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/pydoc.pyi
import sys from _typeshed import SupportsWrite from types import MethodType, ModuleType, TracebackType from typing import ( IO, Any, AnyStr, Callable, Container, Dict, List, Mapping, MutableMapping, NoReturn, Optional, Text, Tuple, Type, Union, ) if sys.version_info >= (3,): from reprlib import Repr else: from repr import Repr # the return type of sys.exc_info(), used by ErrorDuringImport.__init__ _Exc_Info = Tuple[Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]] __author__: str __date__: str __version__: str __credits__: str def pathdirs() -> List[str]: ... def getdoc(object: object) -> Text: ... def splitdoc(doc: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def classname(object: object, modname: str) -> str: ... def isdata(object: object) -> bool: ... def replace(text: AnyStr, *pairs: AnyStr) -> AnyStr: ... def cram(text: str, maxlen: int) -> str: ... def stripid(text: str) -> str: ... def allmethods(cl: type) -> MutableMapping[str, MethodType]: ... def visiblename(name: str, all: Optional[Container[str]] = ..., obj: Optional[object] = ...) -> bool: ... def classify_class_attrs(object: object) -> List[Tuple[str, str, type, str]]: ... def ispackage(path: str) -> bool: ... def source_synopsis(file: IO[AnyStr]) -> Optional[AnyStr]: ... def synopsis(filename: str, cache: MutableMapping[str, Tuple[int, str]] = ...) -> Optional[str]: ... class ErrorDuringImport(Exception): filename: str exc: Optional[Type[BaseException]] value: Optional[BaseException] tb: Optional[TracebackType] def __init__(self, filename: str, exc_info: _Exc_Info) -> None: ... def importfile(path: str) -> ModuleType: ... def safeimport(path: str, forceload: bool = ..., cache: MutableMapping[str, ModuleType] = ...) -> ModuleType: ... class Doc: PYTHONDOCS: str def document(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def fail(self, object: object, name: Optional[str] = ..., *args: Any) -> NoReturn: ... def docmodule(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def docclass(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def docroutine(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def docother(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def docproperty(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def docdata(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def getdocloc(self, object: object, basedir: str = ...) -> Optional[str]: ... class HTMLRepr(Repr): maxlist: int maxtuple: int maxdict: int maxstring: int maxother: int def __init__(self) -> None: ... def escape(self, text: str) -> str: ... def repr(self, object: object) -> str: ... def repr1(self, x: object, level: complex) -> str: ... def repr_string(self, x: Text, level: complex) -> str: ... def repr_str(self, x: Text, level: complex) -> str: ... def repr_instance(self, x: object, level: complex) -> str: ... def repr_unicode(self, x: AnyStr, level: complex) -> str: ... class HTMLDoc(Doc): repr: Callable[[object], str] escape: Callable[[str], str] def page(self, title: str, contents: str) -> str: ... def heading(self, title: str, fgcol: str, bgcol: str, extras: str = ...) -> str: ... def section( self, title: str, fgcol: str, bgcol: str, contents: str, width: int = ..., prelude: str = ..., marginalia: Optional[str] = ..., gap: str = ..., ) -> str: ... def bigsection(self, title: str, *args: Any) -> str: ... def preformat(self, text: str) -> str: ... def multicolumn(self, list: List[Any], format: Callable[[Any], str], cols: int = ...) -> str: ... def grey(self, text: str) -> str: ... def namelink(self, name: str, *dicts: MutableMapping[str, str]) -> str: ... def classlink(self, object: object, modname: str) -> str: ... def modulelink(self, object: object) -> str: ... def modpkglink(self, modpkginfo: Tuple[str, str, bool, bool]) -> str: ... def markup( self, text: str, escape: Optional[Callable[[str], str]] = ..., funcs: Mapping[str, str] = ..., classes: Mapping[str, str] = ..., methods: Mapping[str, str] = ..., ) -> str: ... def formattree( self, tree: List[Union[Tuple[type, Tuple[type, ...]], List[Any]]], modname: str, parent: Optional[type] = ... ) -> str: ... def docmodule(self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., *ignored: Any) -> str: ... def docclass( self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., funcs: Mapping[str, str] = ..., classes: Mapping[str, str] = ..., *ignored: Any, ) -> str: ... def formatvalue(self, object: object) -> str: ... def docroutine( self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., funcs: Mapping[str, str] = ..., classes: Mapping[str, str] = ..., methods: Mapping[str, str] = ..., cl: Optional[type] = ..., *ignored: Any, ) -> str: ... def docproperty( self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., cl: Optional[Any] = ..., *ignored: Any ) -> str: ... def docother(self, object: object, name: Optional[str] = ..., mod: Optional[Any] = ..., *ignored: Any) -> str: ... def docdata( self, object: object, name: Optional[str] = ..., mod: Optional[Any] = ..., cl: Optional[Any] = ..., *ignored: Any ) -> str: ... def index(self, dir: str, shadowed: Optional[MutableMapping[str, bool]] = ...) -> str: ... def filelink(self, url: str, path: str) -> str: ... class TextRepr(Repr): maxlist: int maxtuple: int maxdict: int maxstring: int maxother: int def __init__(self) -> None: ... def repr1(self, x: object, level: complex) -> str: ... def repr_string(self, x: str, level: complex) -> str: ... def repr_str(self, x: str, level: complex) -> str: ... def repr_instance(self, x: object, level: complex) -> str: ... class TextDoc(Doc): repr: Callable[[object], str] def bold(self, text: str) -> str: ... def indent(self, text: str, prefix: str = ...) -> str: ... def section(self, title: str, contents: str) -> str: ... def formattree( self, tree: List[Union[Tuple[type, Tuple[type, ...]], List[Any]]], modname: str, parent: Optional[type] = ..., prefix: str = ..., ) -> str: ... def docmodule(self, object: object, name: Optional[str] = ..., mod: Optional[Any] = ..., *ignored: Any) -> str: ... def docclass(self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., *ignored: Any) -> str: ... def formatvalue(self, object: object) -> str: ... def docroutine( self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., cl: Optional[Any] = ..., *ignored: Any ) -> str: ... def docproperty( self, object: object, name: Optional[str] = ..., mod: Optional[Any] = ..., cl: Optional[Any] = ..., *ignored: Any ) -> str: ... def docdata( self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., cl: Optional[Any] = ..., *ignored: Any ) -> str: ... def docother( self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., parent: Optional[str] = ..., maxlen: Optional[int] = ..., doc: Optional[Any] = ..., *ignored: Any, ) -> str: ... def pager(text: str) -> None: ... def getpager() -> Callable[[str], None]: ... def plain(text: str) -> str: ... def pipepager(text: str, cmd: str) -> None: ... def tempfilepager(text: str, cmd: str) -> None: ... def ttypager(text: str) -> None: ... def plainpager(text: str) -> None: ... def describe(thing: Any) -> str: ... def locate(path: str, forceload: bool = ...) -> object: ... text: TextDoc html: HTMLDoc class _OldStyleClass: ... def resolve(thing: Union[str, object], forceload: bool = ...) -> Optional[Tuple[object, str]]: ... def render_doc(thing: Union[str, object], title: str = ..., forceload: bool = ..., renderer: Optional[Doc] = ...) -> str: ... def doc( thing: Union[str, object], title: str = ..., forceload: bool = ..., output: Optional[SupportsWrite[str]] = ... ) -> None: ... def writedoc(thing: Union[str, object], forceload: bool = ...) -> None: ... def writedocs(dir: str, pkgpath: str = ..., done: Optional[Any] = ...) -> None: ... class Helper: keywords: Dict[str, Union[str, Tuple[str, str]]] symbols: Dict[str, str] topics: Dict[str, Union[str, Tuple[str, ...]]] def __init__(self, input: Optional[IO[str]] = ..., output: Optional[IO[str]] = ...) -> None: ... input: IO[str] output: IO[str] def __call__(self, request: Union[str, Helper, object] = ...) -> None: ... def interact(self) -> None: ... def getline(self, prompt: str) -> str: ... def help(self, request: Any) -> None: ... def intro(self) -> None: ... def list(self, items: List[str], columns: int = ..., width: int = ...) -> None: ... def listkeywords(self) -> None: ... def listsymbols(self) -> None: ... def listtopics(self) -> None: ... def showtopic(self, topic: str, more_xrefs: str = ...) -> None: ... def showsymbol(self, symbol: str) -> None: ... def listmodules(self, key: str = ...) -> None: ... help: Helper # See Python issue #11182: "remove the unused and undocumented pydoc.Scanner class" # class Scanner: # roots = ... # type: Any # state = ... # type: Any # children = ... # type: Any # descendp = ... # type: Any # def __init__(self, roots, children, descendp) -> None: ... # def next(self): ... class ModuleScanner: quit: bool def run( self, callback: Callable[[Optional[str], str, str], None], key: Optional[Any] = ..., completer: Optional[Callable[[], None]] = ..., onerror: Optional[Callable[[str], None]] = ..., ) -> None: ... def apropos(key: str) -> None: ... def ispath(x: Any) -> bool: ... def cli() -> None: ... if sys.version_info < (3,): def serve( port: int, callback: Optional[Callable[[Any], None]] = ..., completer: Optional[Callable[[], None]] = ... ) -> None: ... def gui() -> None: ...
10,660
Python
.py
252
37.40873
125
0.578127
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,052
bisect.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/bisect.pyi
from _bisect import * bisect = bisect_right insort = insort_right
67
Python
.py
3
21
21
0.793651
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,053
mailcap.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/mailcap.pyi
from typing import Dict, List, Mapping, Optional, Sequence, Tuple, Union _Cap = Dict[str, Union[str, int]] def findmatch( caps: Mapping[str, List[_Cap]], MIMEtype: str, key: str = ..., filename: str = ..., plist: Sequence[str] = ... ) -> Tuple[Optional[str], Optional[_Cap]]: ... def getcaps() -> Dict[str, List[_Cap]]: ...
330
Python
.py
6
53
114
0.639752
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,054
pstats.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/pstats.pyi
import sys from _typeshed import AnyPath from cProfile import Profile as _cProfile from profile import Profile from typing import IO, Any, Dict, Iterable, List, Optional, Text, Tuple, TypeVar, Union, overload _Selector = Union[str, float, int] _T = TypeVar("_T", bound=Stats) if sys.version_info >= (3, 7): from enum import Enum class SortKey(str, Enum): CALLS: str CUMULATIVE: str FILENAME: str LINE: str NAME: str NFL: str PCALLS: str STDNAME: str TIME: str class Stats: sort_arg_dict_default: Dict[str, Tuple[Any, str]] def __init__( self: _T, __arg: Union[None, str, Text, Profile, _cProfile] = ..., *args: Union[None, str, Text, Profile, _cProfile, _T], stream: Optional[IO[Any]] = ..., ) -> None: ... def init(self, arg: Union[None, str, Text, Profile, _cProfile]) -> None: ... def load_stats(self, arg: Union[None, str, Text, Profile, _cProfile]) -> None: ... def get_top_level_stats(self) -> None: ... def add(self: _T, *arg_list: Union[None, str, Text, Profile, _cProfile, _T]) -> _T: ... def dump_stats(self, filename: AnyPath) -> None: ... def get_sort_arg_defs(self) -> Dict[str, Tuple[Tuple[Tuple[int, int], ...], str]]: ... @overload def sort_stats(self: _T, field: int) -> _T: ... @overload def sort_stats(self: _T, *field: str) -> _T: ... def reverse_order(self: _T) -> _T: ... def strip_dirs(self: _T) -> _T: ... def calc_callees(self) -> None: ... def eval_print_amount(self, sel: _Selector, list: List[str], msg: str) -> Tuple[List[str], str]: ... def get_print_list(self, sel_list: Iterable[_Selector]) -> Tuple[int, List[str]]: ... def print_stats(self: _T, *amount: _Selector) -> _T: ... def print_callees(self: _T, *amount: _Selector) -> _T: ... def print_callers(self: _T, *amount: _Selector) -> _T: ... def print_call_heading(self, name_size: int, column_title: str) -> None: ... def print_call_line(self, name_size: int, source: str, call_dict: Dict[str, Any], arrow: str = ...) -> None: ... def print_title(self) -> None: ... def print_line(self, func: str) -> None: ...
2,213
Python
.py
49
39.77551
116
0.595095
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,055
zipimport.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/zipimport.pyi
import os import sys from types import CodeType, ModuleType from typing import Any, List, Optional, Tuple, Union if sys.version_info >= (3, 7): from importlib.abc import ResourceReader class ZipImportError(ImportError): ... class zipimporter(object): archive: str prefix: str if sys.version_info >= (3, 6): def __init__(self, path: Union[str, bytes, os.PathLike[Any]]) -> None: ... else: def __init__(self, path: Union[str, bytes]) -> None: ... if sys.version_info >= (3,): def find_loader( self, fullname: str, path: Optional[str] = ... ) -> Tuple[Optional[zipimporter], List[str]]: ... # undocumented def find_module(self, fullname: str, path: Optional[str] = ...) -> Optional[zipimporter]: ... def get_code(self, fullname: str) -> CodeType: ... def get_data(self, pathname: str) -> str: ... def get_filename(self, fullname: str) -> str: ... if sys.version_info >= (3, 7): def get_resource_reader(self, fullname: str) -> Optional[ResourceReader]: ... # undocumented def get_source(self, fullname: str) -> Optional[str]: ... def is_package(self, fullname: str) -> bool: ... def load_module(self, fullname: str) -> ModuleType: ...
1,244
Python
.py
27
40.962963
101
0.631796
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,056
fractions.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/fractions.pyi
import sys from decimal import Decimal from numbers import Integral, Rational, Real from typing import Optional, Tuple, Union, overload from typing_extensions import Literal _ComparableNum = Union[int, float, Decimal, Real] if sys.version_info < (3, 9): @overload def gcd(a: int, b: int) -> int: ... @overload def gcd(a: Integral, b: int) -> Integral: ... @overload def gcd(a: int, b: Integral) -> Integral: ... @overload def gcd(a: Integral, b: Integral) -> Integral: ... class Fraction(Rational): @overload def __new__( cls, numerator: Union[int, Rational] = ..., denominator: Optional[Union[int, Rational]] = ..., *, _normalize: bool = ... ) -> Fraction: ... @overload def __new__(cls, __value: Union[float, Decimal, str], *, _normalize: bool = ...) -> Fraction: ... @classmethod def from_float(cls, f: float) -> Fraction: ... @classmethod def from_decimal(cls, dec: Decimal) -> Fraction: ... def limit_denominator(self, max_denominator: int = ...) -> Fraction: ... if sys.version_info >= (3, 8): def as_integer_ratio(self) -> Tuple[int, int]: ... @property def numerator(self) -> int: ... @property def denominator(self) -> int: ... @overload def __add__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __add__(self, other: float) -> float: ... @overload def __add__(self, other: complex) -> complex: ... @overload def __radd__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __radd__(self, other: float) -> float: ... @overload def __radd__(self, other: complex) -> complex: ... @overload def __sub__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __sub__(self, other: float) -> float: ... @overload def __sub__(self, other: complex) -> complex: ... @overload def __rsub__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __rsub__(self, other: float) -> float: ... @overload def __rsub__(self, other: complex) -> complex: ... @overload def __mul__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __mul__(self, other: float) -> float: ... @overload def __mul__(self, other: complex) -> complex: ... @overload def __rmul__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __rmul__(self, other: float) -> float: ... @overload def __rmul__(self, other: complex) -> complex: ... @overload def __truediv__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __truediv__(self, other: float) -> float: ... @overload def __truediv__(self, other: complex) -> complex: ... @overload def __rtruediv__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __rtruediv__(self, other: float) -> float: ... @overload def __rtruediv__(self, other: complex) -> complex: ... if sys.version_info < (3, 0): @overload def __div__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __div__(self, other: float) -> float: ... @overload def __div__(self, other: complex) -> complex: ... @overload def __rdiv__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __rdiv__(self, other: float) -> float: ... @overload def __rdiv__(self, other: complex) -> complex: ... @overload def __floordiv__(self, other: Union[int, Fraction]) -> int: ... @overload def __floordiv__(self, other: float) -> float: ... @overload def __rfloordiv__(self, other: Union[int, Fraction]) -> int: ... @overload def __rfloordiv__(self, other: float) -> float: ... @overload def __mod__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __mod__(self, other: float) -> float: ... @overload def __rmod__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __rmod__(self, other: float) -> float: ... @overload def __divmod__(self, other: Union[int, Fraction]) -> Tuple[int, Fraction]: ... @overload def __divmod__(self, other: float) -> Tuple[float, Fraction]: ... @overload def __rdivmod__(self, other: Union[int, Fraction]) -> Tuple[int, Fraction]: ... @overload def __rdivmod__(self, other: float) -> Tuple[float, Fraction]: ... @overload def __pow__(self, other: int) -> Fraction: ... @overload def __pow__(self, other: Union[float, Fraction]) -> float: ... @overload def __pow__(self, other: complex) -> complex: ... @overload def __rpow__(self, other: Union[int, float, Fraction]) -> float: ... @overload def __rpow__(self, other: complex) -> complex: ... def __pos__(self) -> Fraction: ... def __neg__(self) -> Fraction: ... def __abs__(self) -> Fraction: ... def __trunc__(self) -> int: ... if sys.version_info >= (3, 0): def __floor__(self) -> int: ... def __ceil__(self) -> int: ... @overload def __round__(self, ndigits: None = ...) -> int: ... @overload def __round__(self, ndigits: int) -> Fraction: ... def __hash__(self) -> int: ... def __eq__(self, other: object) -> bool: ... def __lt__(self, other: _ComparableNum) -> bool: ... def __gt__(self, other: _ComparableNum) -> bool: ... def __le__(self, other: _ComparableNum) -> bool: ... def __ge__(self, other: _ComparableNum) -> bool: ... if sys.version_info >= (3, 0): def __bool__(self) -> bool: ... else: def __nonzero__(self) -> bool: ... # Not actually defined within fractions.py, but provides more useful # overrides @property def real(self) -> Fraction: ... @property def imag(self) -> Literal[0]: ... def conjugate(self) -> Fraction: ...
5,936
Python
.py
156
32.673077
128
0.56898
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,057
hmac.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/hmac.pyi
import sys from _typeshed import ReadableBuffer from types import ModuleType from typing import Any, AnyStr, Callable, Optional, Union, overload # TODO more precise type for object of hashlib _Hash = Any _DigestMod = Union[str, Callable[[], _Hash], ModuleType] digest_size: None if sys.version_info >= (3, 8): # In reality digestmod has a default value, but the function always throws an error # if the argument is not given, so we pretend it is a required argument. @overload def new(key: bytes, msg: Optional[ReadableBuffer], digestmod: _DigestMod) -> HMAC: ... @overload def new(key: bytes, *, digestmod: _DigestMod) -> HMAC: ... elif sys.version_info >= (3, 4): def new(key: bytes, msg: Optional[ReadableBuffer] = ..., digestmod: Optional[_DigestMod] = ...) -> HMAC: ... else: def new(key: bytes, msg: Optional[ReadableBuffer] = ..., digestmod: Optional[_DigestMod] = ...) -> HMAC: ... class HMAC: if sys.version_info >= (3,): digest_size: int if sys.version_info >= (3, 4): block_size: int name: str def __init__(self, key: bytes, msg: Optional[ReadableBuffer] = ..., digestmod: _DigestMod = ...) -> None: ... def update(self, msg: ReadableBuffer) -> None: ... def digest(self) -> bytes: ... def hexdigest(self) -> str: ... def copy(self) -> HMAC: ... @overload def compare_digest(__a: ReadableBuffer, __b: ReadableBuffer) -> bool: ... @overload def compare_digest(__a: AnyStr, __b: AnyStr) -> bool: ... if sys.version_info >= (3, 7): def digest(key: bytes, msg: ReadableBuffer, digest: str) -> bytes: ...
1,607
Python
.py
36
40.972222
113
0.65643
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,058
math.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/math.pyi
import sys from typing import Iterable, Optional, SupportsFloat, SupportsInt, Tuple, overload e: float pi: float if sys.version_info >= (3, 5): inf: float nan: float if sys.version_info >= (3, 6): tau: float def acos(__x: SupportsFloat) -> float: ... def acosh(__x: SupportsFloat) -> float: ... def asin(__x: SupportsFloat) -> float: ... def asinh(__x: SupportsFloat) -> float: ... def atan(__x: SupportsFloat) -> float: ... def atan2(__y: SupportsFloat, __x: SupportsFloat) -> float: ... def atanh(__x: SupportsFloat) -> float: ... if sys.version_info >= (3,): def ceil(__x: SupportsFloat) -> int: ... else: def ceil(__x: SupportsFloat) -> float: ... if sys.version_info >= (3, 8): def comb(__n: int, __k: int) -> int: ... def copysign(__x: SupportsFloat, __y: SupportsFloat) -> float: ... def cos(__x: SupportsFloat) -> float: ... def cosh(__x: SupportsFloat) -> float: ... def degrees(__x: SupportsFloat) -> float: ... if sys.version_info >= (3, 8): def dist(__p: Iterable[SupportsFloat], __q: Iterable[SupportsFloat]) -> float: ... def erf(__x: SupportsFloat) -> float: ... def erfc(__x: SupportsFloat) -> float: ... def exp(__x: SupportsFloat) -> float: ... def expm1(__x: SupportsFloat) -> float: ... def fabs(__x: SupportsFloat) -> float: ... def factorial(__x: SupportsInt) -> int: ... if sys.version_info >= (3,): def floor(__x: SupportsFloat) -> int: ... else: def floor(__x: SupportsFloat) -> float: ... def fmod(__x: SupportsFloat, __y: SupportsFloat) -> float: ... def frexp(__x: SupportsFloat) -> Tuple[float, int]: ... def fsum(__seq: Iterable[float]) -> float: ... def gamma(__x: SupportsFloat) -> float: ... if sys.version_info >= (3, 9): def gcd(*integers: int) -> int: ... elif sys.version_info >= (3, 5): def gcd(__x: int, __y: int) -> int: ... if sys.version_info >= (3, 8): def hypot(*coordinates: SupportsFloat) -> float: ... else: def hypot(__x: SupportsFloat, __y: SupportsFloat) -> float: ... if sys.version_info >= (3, 5): def isclose(a: SupportsFloat, b: SupportsFloat, *, rel_tol: SupportsFloat = ..., abs_tol: SupportsFloat = ...) -> bool: ... def isinf(__x: SupportsFloat) -> bool: ... if sys.version_info >= (3,): def isfinite(__x: SupportsFloat) -> bool: ... def isnan(__x: SupportsFloat) -> bool: ... if sys.version_info >= (3, 8): def isqrt(__n: int) -> int: ... if sys.version_info >= (3, 9): def lcm(*integers: int) -> int: ... def ldexp(__x: SupportsFloat, __i: int) -> float: ... def lgamma(__x: SupportsFloat) -> float: ... def log(x: SupportsFloat, base: SupportsFloat = ...) -> float: ... def log10(__x: SupportsFloat) -> float: ... def log1p(__x: SupportsFloat) -> float: ... if sys.version_info >= (3, 3): def log2(__x: SupportsFloat) -> float: ... def modf(__x: SupportsFloat) -> Tuple[float, float]: ... if sys.version_info >= (3, 9): def nextafter(__x: SupportsFloat, __y: SupportsFloat) -> float: ... if sys.version_info >= (3, 8): def perm(__n: int, __k: Optional[int] = ...) -> int: ... def pow(__x: SupportsFloat, __y: SupportsFloat) -> float: ... if sys.version_info >= (3, 8): @overload def prod(__iterable: Iterable[int], *, start: int = ...) -> int: ... # type: ignore @overload def prod(__iterable: Iterable[SupportsFloat], *, start: SupportsFloat = ...) -> float: ... def radians(__x: SupportsFloat) -> float: ... if sys.version_info >= (3, 7): def remainder(__x: SupportsFloat, __y: SupportsFloat) -> float: ... def sin(__x: SupportsFloat) -> float: ... def sinh(__x: SupportsFloat) -> float: ... def sqrt(__x: SupportsFloat) -> float: ... def tan(__x: SupportsFloat) -> float: ... def tanh(__x: SupportsFloat) -> float: ... def trunc(__x: SupportsFloat) -> int: ... if sys.version_info >= (3, 9): def ulp(__x: SupportsFloat) -> float: ...
3,835
Python
.py
89
40.561798
127
0.610124
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,059
_random.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/_random.pyi
import sys from typing import Tuple # Actually Tuple[(int,) * 625] _State = Tuple[int, ...] class Random(object): def __init__(self, seed: object = ...) -> None: ... def seed(self, __n: object = ...) -> None: ... def getstate(self) -> _State: ... def setstate(self, __state: _State) -> None: ... def random(self) -> float: ... def getrandbits(self, __k: int) -> int: ... if sys.version_info < (3,): def jumpahead(self, i: int) -> None: ...
478
Python
.py
13
32.846154
55
0.559395
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,060
sched.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/sched.pyi
import sys from typing import Any, Callable, Dict, List, NamedTuple, Optional, Text, Tuple class Event(NamedTuple): time: float priority: Any action: Callable[..., Any] argument: Tuple[Any, ...] kwargs: Dict[Text, Any] class scheduler: if sys.version_info >= (3, 3): def __init__(self, timefunc: Callable[[], float] = ..., delayfunc: Callable[[float], None] = ...) -> None: ... def enterabs( self, time: float, priority: Any, action: Callable[..., Any], argument: Tuple[Any, ...] = ..., kwargs: Dict[str, Any] = ..., ) -> Event: ... def enter( self, delay: float, priority: Any, action: Callable[..., Any], argument: Tuple[Any, ...] = ..., kwargs: Dict[str, Any] = ..., ) -> Event: ... def run(self, blocking: bool = ...) -> Optional[float]: ... else: def __init__(self, timefunc: Callable[[], float], delayfunc: Callable[[float], None]) -> None: ... def enterabs(self, time: float, priority: Any, action: Callable[..., Any], argument: Tuple[Any, ...]) -> Event: ... def enter(self, delay: float, priority: Any, action: Callable[..., Any], argument: Tuple[Any, ...]) -> Event: ... def run(self) -> None: ... def cancel(self, event: Event) -> None: ... def empty(self) -> bool: ... @property def queue(self) -> List[Event]: ...
1,497
Python
.py
37
32.162162
123
0.522634
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,061
syslog.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/syslog.pyi
from typing import overload LOG_ALERT: int LOG_AUTH: int LOG_CONS: int LOG_CRIT: int LOG_CRON: int LOG_DAEMON: int LOG_DEBUG: int LOG_EMERG: int LOG_ERR: int LOG_INFO: int LOG_KERN: int LOG_LOCAL0: int LOG_LOCAL1: int LOG_LOCAL2: int LOG_LOCAL3: int LOG_LOCAL4: int LOG_LOCAL5: int LOG_LOCAL6: int LOG_LOCAL7: int LOG_LPR: int LOG_MAIL: int LOG_NDELAY: int LOG_NEWS: int LOG_NOTICE: int LOG_NOWAIT: int LOG_PERROR: int LOG_PID: int LOG_SYSLOG: int LOG_USER: int LOG_UUCP: int LOG_WARNING: int def LOG_MASK(a: int) -> int: ... def LOG_UPTO(a: int) -> int: ... def closelog() -> None: ... def openlog(ident: str = ..., logoption: int = ..., facility: int = ...) -> None: ... def setlogmask(x: int) -> int: ... @overload def syslog(priority: int, message: str) -> None: ... @overload def syslog(message: str) -> None: ...
821
Python
.py
41
18.97561
85
0.709512
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,062
genericpath.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/genericpath.pyi
import sys from typing import AnyStr, Sequence, Text, Union if sys.version_info >= (3, 0): def commonprefix(m: Sequence[str]) -> str: ... else: def commonprefix(m: Sequence[AnyStr]) -> AnyStr: ... if sys.version_info >= (3, 6): from builtins import _PathLike def exists(path: Union[AnyStr, _PathLike[AnyStr]]) -> bool: ... else: def exists(path: Text) -> bool: ... def isfile(path: Text) -> bool: ... def isdir(s: Text) -> bool: ... def getsize(filename: Text) -> int: ... def getmtime(filename: Text) -> float: ... def getatime(filename: Text) -> float: ... def getctime(filename: Text) -> float: ... if sys.version_info >= (3, 4): def samestat(s1: str, s2: str) -> int: ... def samefile(f1: str, f2: str) -> int: ... def sameopenfile(fp1: str, fp2: str) -> int: ...
806
Python
.py
21
35.571429
67
0.629012
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,063
bdb.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/bdb.pyi
from types import CodeType, FrameType, TracebackType from typing import IO, Any, Callable, Dict, Iterable, List, Mapping, Optional, Set, SupportsInt, Tuple, Type, TypeVar, Union _T = TypeVar("_T") _TraceDispatch = Callable[[FrameType, str, Any], Any] # TODO: Recursive type _ExcInfo = Tuple[Type[BaseException], BaseException, FrameType] GENERATOR_AND_COROUTINE_FLAGS: int = ... class BdbQuit(Exception): ... class Bdb: skip: Optional[Set[str]] breaks: Dict[str, List[int]] fncache: Dict[str, str] frame_returning: Optional[FrameType] botframe: Optional[FrameType] quitting: bool stopframe: Optional[FrameType] returnframe: Optional[FrameType] stoplineno: int def __init__(self, skip: Optional[Iterable[str]] = ...) -> None: ... def canonic(self, filename: str) -> str: ... def reset(self) -> None: ... def trace_dispatch(self, frame: FrameType, event: str, arg: Any) -> _TraceDispatch: ... def dispatch_line(self, frame: FrameType) -> _TraceDispatch: ... def dispatch_call(self, frame: FrameType, arg: None) -> _TraceDispatch: ... def dispatch_return(self, frame: FrameType, arg: Any) -> _TraceDispatch: ... def dispatch_exception(self, frame: FrameType, arg: _ExcInfo) -> _TraceDispatch: ... def is_skipped_module(self, module_name: str) -> bool: ... def stop_here(self, frame: FrameType) -> bool: ... def break_here(self, frame: FrameType) -> bool: ... def do_clear(self, arg: Any) -> Optional[bool]: ... def break_anywhere(self, frame: FrameType) -> bool: ... def user_call(self, frame: FrameType, argument_list: None) -> None: ... def user_line(self, frame: FrameType) -> None: ... def user_return(self, frame: FrameType, return_value: Any) -> None: ... def user_exception(self, frame: FrameType, exc_info: _ExcInfo) -> None: ... def set_until(self, frame: FrameType, lineno: Optional[int] = ...) -> None: ... def set_step(self) -> None: ... def set_next(self, frame: FrameType) -> None: ... def set_return(self, frame: FrameType) -> None: ... def set_trace(self, frame: Optional[FrameType] = ...) -> None: ... def set_continue(self) -> None: ... def set_quit(self) -> None: ... def set_break( self, filename: str, lineno: int, temporary: bool = ..., cond: Optional[str] = ..., funcname: Optional[str] = ... ) -> None: ... def clear_break(self, filename: str, lineno: int) -> None: ... def clear_bpbynumber(self, arg: SupportsInt) -> None: ... def clear_all_file_breaks(self, filename: str) -> None: ... def clear_all_breaks(self) -> None: ... def get_bpbynumber(self, arg: SupportsInt) -> Breakpoint: ... def get_break(self, filename: str, lineno: int) -> bool: ... def get_breaks(self, filename: str, lineno: int) -> List[Breakpoint]: ... def get_file_breaks(self, filename: str) -> List[Breakpoint]: ... def get_all_breaks(self) -> List[Breakpoint]: ... def get_stack(self, f: Optional[FrameType], t: Optional[TracebackType]) -> Tuple[List[Tuple[FrameType, int]], int]: ... def format_stack_entry(self, frame_lineno: int, lprefix: str = ...) -> str: ... def run( self, cmd: Union[str, CodeType], globals: Optional[Dict[str, Any]] = ..., locals: Optional[Mapping[str, Any]] = ... ) -> None: ... def runeval(self, expr: str, globals: Optional[Dict[str, Any]] = ..., locals: Optional[Mapping[str, Any]] = ...) -> None: ... def runctx( self, cmd: Union[str, CodeType], globals: Optional[Dict[str, Any]], locals: Optional[Mapping[str, Any]] ) -> None: ... def runcall(self, __func: Callable[..., _T], *args: Any, **kwds: Any) -> Optional[_T]: ... class Breakpoint: next: int = ... bplist: Dict[Tuple[str, int], List[Breakpoint]] = ... bpbynumber: List[Optional[Breakpoint]] = ... funcname: Optional[str] func_first_executable_line: Optional[int] file: str line: int temporary: bool cond: Optional[str] enabled: bool ignore: int hits: int number: int def __init__( self, file: str, line: int, temporary: bool = ..., cond: Optional[str] = ..., funcname: Optional[str] = ... ) -> None: ... def deleteMe(self) -> None: ... def enable(self) -> None: ... def disable(self) -> None: ... def bpprint(self, out: Optional[IO[str]] = ...) -> None: ... def bpformat(self) -> str: ... def __str__(self) -> str: ... def checkfuncname(b: Breakpoint, frame: FrameType) -> bool: ... def effective(file: str, line: int, frame: FrameType) -> Union[Tuple[Breakpoint, bool], Tuple[None, None]]: ... def set_trace() -> None: ...
4,644
Python
.py
89
47.438202
129
0.630004
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,064
telnetlib.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/telnetlib.pyi
import socket import sys from typing import Any, Callable, Match, Optional, Pattern, Sequence, Tuple, Union DEBUGLEVEL: int TELNET_PORT: int IAC: bytes DONT: bytes DO: bytes WONT: bytes WILL: bytes theNULL: bytes SE: bytes NOP: bytes DM: bytes BRK: bytes IP: bytes AO: bytes AYT: bytes EC: bytes EL: bytes GA: bytes SB: bytes BINARY: bytes ECHO: bytes RCP: bytes SGA: bytes NAMS: bytes STATUS: bytes TM: bytes RCTE: bytes NAOL: bytes NAOP: bytes NAOCRD: bytes NAOHTS: bytes NAOHTD: bytes NAOFFD: bytes NAOVTS: bytes NAOVTD: bytes NAOLFD: bytes XASCII: bytes LOGOUT: bytes BM: bytes DET: bytes SUPDUP: bytes SUPDUPOUTPUT: bytes SNDLOC: bytes TTYPE: bytes EOR: bytes TUID: bytes OUTMRK: bytes TTYLOC: bytes VT3270REGIME: bytes X3PAD: bytes NAWS: bytes TSPEED: bytes LFLOW: bytes LINEMODE: bytes XDISPLOC: bytes OLD_ENVIRON: bytes AUTHENTICATION: bytes ENCRYPT: bytes NEW_ENVIRON: bytes TN3270E: bytes XAUTH: bytes CHARSET: bytes RSP: bytes COM_PORT_OPTION: bytes SUPPRESS_LOCAL_ECHO: bytes TLS: bytes KERMIT: bytes SEND_URL: bytes FORWARD_X: bytes PRAGMA_LOGON: bytes SSPI_LOGON: bytes PRAGMA_HEARTBEAT: bytes EXOPL: bytes NOOPT: bytes class Telnet: def __init__(self, host: Optional[str] = ..., port: int = ..., timeout: int = ...) -> None: ... def open(self, host: str, port: int = ..., timeout: int = ...) -> None: ... def msg(self, msg: str, *args: Any) -> None: ... def set_debuglevel(self, debuglevel: int) -> None: ... def close(self) -> None: ... def get_socket(self) -> socket.socket: ... def fileno(self) -> int: ... def write(self, buffer: bytes) -> None: ... def read_until(self, match: bytes, timeout: Optional[int] = ...) -> bytes: ... def read_all(self) -> bytes: ... def read_some(self) -> bytes: ... def read_very_eager(self) -> bytes: ... def read_eager(self) -> bytes: ... def read_lazy(self) -> bytes: ... def read_very_lazy(self) -> bytes: ... def read_sb_data(self) -> bytes: ... def set_option_negotiation_callback(self, callback: Optional[Callable[[socket.socket, bytes, bytes], Any]]) -> None: ... def process_rawq(self) -> None: ... def rawq_getchar(self) -> bytes: ... def fill_rawq(self) -> None: ... def sock_avail(self) -> bool: ... def interact(self) -> None: ... def mt_interact(self) -> None: ... def listener(self) -> None: ... def expect( self, list: Sequence[Union[Pattern[bytes], bytes]], timeout: Optional[int] = ... ) -> Tuple[int, Optional[Match[bytes]], bytes]: ... if sys.version_info >= (3, 6): def __enter__(self) -> Telnet: ... def __exit__(self, type: Any, value: Any, traceback: Any) -> None: ...
2,680
Python
.py
108
22.537037
124
0.674591
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,065
bz2.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/bz2.pyi
import io import sys from _typeshed import AnyPath from typing import IO, Any, Optional, TextIO, TypeVar, Union, overload from typing_extensions import Literal _PathOrFile = Union[AnyPath, IO[bytes]] _T = TypeVar("_T") def compress(data: bytes, compresslevel: int = ...) -> bytes: ... def decompress(data: bytes) -> bytes: ... if sys.version_info >= (3, 3): _OpenBinaryMode = Literal["r", "rb", "w", "wb", "x", "xb", "a", "ab"] _OpenTextMode = Literal["rt", "wt", "xt", "at"] @overload def open( filename: _PathOrFile, mode: _OpenBinaryMode = ..., compresslevel: int = ..., encoding: None = ..., errors: None = ..., newline: None = ..., ) -> BZ2File: ... @overload def open( filename: AnyPath, mode: _OpenTextMode, compresslevel: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> TextIO: ... @overload def open( filename: _PathOrFile, mode: str, compresslevel: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> Union[BZ2File, TextIO]: ... class BZ2File(io.BufferedIOBase, IO[bytes]): def __enter__(self: _T) -> _T: ... if sys.version_info >= (3, 9): def __init__(self, filename: _PathOrFile, mode: str = ..., *, compresslevel: int = ...) -> None: ... else: def __init__( self, filename: _PathOrFile, mode: str = ..., buffering: Optional[Any] = ..., compresslevel: int = ... ) -> None: ... class BZ2Compressor(object): def __init__(self, compresslevel: int = ...) -> None: ... def compress(self, data: bytes) -> bytes: ... def flush(self) -> bytes: ... class BZ2Decompressor(object): if sys.version_info >= (3, 5): def decompress(self, data: bytes, max_length: int = ...) -> bytes: ... else: def decompress(self, data: bytes) -> bytes: ... if sys.version_info >= (3, 3): @property def eof(self) -> bool: ... if sys.version_info >= (3, 5): @property def needs_input(self) -> bool: ... @property def unused_data(self) -> bytes: ...
2,267
Python
.py
64
29.328125
114
0.552572
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,066
winsound.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/winsound.pyi
import sys from typing import Optional, Union, overload from typing_extensions import Literal if sys.platform == "win32": SND_FILENAME: int SND_ALIAS: int SND_LOOP: int SND_MEMORY: int SND_PURGE: int SND_ASYNC: int SND_NODEFAULT: int SND_NOSTOP: int SND_NOWAIT: int MB_ICONASTERISK: int MB_ICONEXCLAMATION: int MB_ICONHAND: int MB_ICONQUESTION: int MB_OK: int def Beep(frequency: int, duration: int) -> None: ... # Can actually accept anything ORed with 4, and if not it's definitely str, but that's inexpressible @overload def PlaySound(sound: Optional[bytes], flags: Literal[4]) -> None: ... @overload def PlaySound(sound: Optional[Union[str, bytes]], flags: int) -> None: ... def MessageBeep(type: int = ...) -> None: ...
811
Python
.py
25
28
104
0.67602
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,067
sndhdr.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/sndhdr.pyi
import sys from _typeshed import AnyPath from typing import NamedTuple, Optional, Tuple, Union if sys.version_info >= (3, 5): class SndHeaders(NamedTuple): filetype: str framerate: int nchannels: int nframes: int sampwidth: Union[int, str] _SndHeaders = SndHeaders else: _SndHeaders = Tuple[str, int, int, int, Union[int, str]] def what(filename: AnyPath) -> Optional[_SndHeaders]: ... def whathdr(filename: AnyPath) -> Optional[_SndHeaders]: ...
501
Python
.py
15
28.8
60
0.683884
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,068
pickletools.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/pickletools.pyi
import sys from typing import IO, Any, Callable, Iterator, List, MutableMapping, Optional, Text, Tuple, Type, Union _Reader = Callable[[IO[bytes]], Any] if sys.version_info >= (3, 0): bytes_types: Tuple[Type[Any], ...] UP_TO_NEWLINE: int TAKEN_FROM_ARGUMENT1: int TAKEN_FROM_ARGUMENT4: int if sys.version_info >= (3, 3): TAKEN_FROM_ARGUMENT4U: int if sys.version_info >= (3, 4): TAKEN_FROM_ARGUMENT8U: int class ArgumentDescriptor(object): name: str n: int reader: _Reader doc: str def __init__(self, name: str, n: int, reader: _Reader, doc: str) -> None: ... def read_uint1(f: IO[bytes]) -> int: ... uint1: ArgumentDescriptor def read_uint2(f: IO[bytes]) -> int: ... uint2: ArgumentDescriptor def read_int4(f: IO[bytes]) -> int: ... int4: ArgumentDescriptor if sys.version_info >= (3, 3): def read_uint4(f: IO[bytes]) -> int: ... uint4: ArgumentDescriptor if sys.version_info >= (3, 5): def read_uint8(f: IO[bytes]) -> int: ... uint8: ArgumentDescriptor def read_stringnl(f: IO[bytes], decode: bool = ..., stripquotes: bool = ...) -> Union[bytes, Text]: ... stringnl: ArgumentDescriptor def read_stringnl_noescape(f: IO[bytes]) -> str: ... stringnl_noescape: ArgumentDescriptor def read_stringnl_noescape_pair(f: IO[bytes]) -> Text: ... stringnl_noescape_pair: ArgumentDescriptor def read_string1(f: IO[bytes]) -> str: ... string1: ArgumentDescriptor def read_string4(f: IO[bytes]) -> str: ... string4: ArgumentDescriptor if sys.version_info >= (3, 3): def read_bytes1(f: IO[bytes]) -> bytes: ... bytes1: ArgumentDescriptor def read_bytes4(f: IO[bytes]) -> bytes: ... bytes4: ArgumentDescriptor if sys.version_info >= (3, 4): def read_bytes8(f: IO[bytes]) -> bytes: ... bytes8: ArgumentDescriptor def read_unicodestringnl(f: IO[bytes]) -> Text: ... unicodestringnl: ArgumentDescriptor if sys.version_info >= (3, 4): def read_unicodestring1(f: IO[bytes]) -> Text: ... unicodestring1: ArgumentDescriptor def read_unicodestring4(f: IO[bytes]) -> Text: ... unicodestring4: ArgumentDescriptor if sys.version_info >= (3, 4): def read_unicodestring8(f: IO[bytes]) -> Text: ... unicodestring8: ArgumentDescriptor def read_decimalnl_short(f: IO[bytes]) -> int: ... def read_decimalnl_long(f: IO[bytes]) -> int: ... decimalnl_short: ArgumentDescriptor decimalnl_long: ArgumentDescriptor def read_floatnl(f: IO[bytes]) -> float: ... floatnl: ArgumentDescriptor def read_float8(f: IO[bytes]) -> float: ... float8: ArgumentDescriptor def read_long1(f: IO[bytes]) -> int: ... long1: ArgumentDescriptor def read_long4(f: IO[bytes]) -> int: ... long4: ArgumentDescriptor class StackObject(object): name: str obtype: Union[Type[Any], Tuple[Type[Any], ...]] doc: str def __init__(self, name: str, obtype: Union[Type[Any], Tuple[Type[Any], ...]], doc: str) -> None: ... pyint: StackObject pylong: StackObject pyinteger_or_bool: StackObject pybool: StackObject pyfloat: StackObject if sys.version_info >= (3, 4): pybytes_or_str: StackObject pystring: StackObject if sys.version_info >= (3, 0): pybytes: StackObject pyunicode: StackObject pynone: StackObject pytuple: StackObject pylist: StackObject pydict: StackObject if sys.version_info >= (3, 4): pyset: StackObject pyfrozenset: StackObject anyobject: StackObject markobject: StackObject stackslice: StackObject class OpcodeInfo(object): name: str code: str arg: Optional[ArgumentDescriptor] stack_before: List[StackObject] stack_after: List[StackObject] proto: int doc: str def __init__( self, name: str, code: str, arg: Optional[ArgumentDescriptor], stack_before: List[StackObject], stack_after: List[StackObject], proto: int, doc: str, ) -> None: ... opcodes: List[OpcodeInfo] def genops(pickle: Union[bytes, IO[bytes]]) -> Iterator[Tuple[OpcodeInfo, Optional[Any], Optional[int]]]: ... def optimize(p: Union[bytes, IO[bytes]]) -> bytes: ... if sys.version_info >= (3, 2): def dis( pickle: Union[bytes, IO[bytes]], out: Optional[IO[str]] = ..., memo: Optional[MutableMapping[int, Any]] = ..., indentlevel: int = ..., annotate: int = ..., ) -> None: ... else: def dis( pickle: Union[bytes, IO[bytes]], out: Optional[IO[str]] = ..., memo: Optional[MutableMapping[int, Any]] = ..., indentlevel: int = ..., ) -> None: ...
4,510
Python
.py
132
30.477273
109
0.674209
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,069
pyclbr.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/pyclbr.pyi
import sys from typing import Dict, List, Optional, Sequence, Union class Class: module: str name: str super: Optional[List[Union[Class, str]]] methods: Dict[str, int] file: int lineno: int if sys.version_info >= (3, 7): def __init__( self, module: str, name: str, super: Optional[List[Union[Class, str]]], file: str, lineno: int, parent: Optional[Class] = ..., ) -> None: ... else: def __init__(self, module: str, name: str, super: Optional[List[Union[Class, str]]], file: str, lineno: int) -> None: ... class Function: module: str name: str file: int lineno: int if sys.version_info >= (3, 7): def __init__(self, module: str, name: str, file: str, lineno: int, parent: Optional[Function] = ...) -> None: ... else: def __init__(self, module: str, name: str, file: str, lineno: int) -> None: ... def readmodule(module: str, path: Optional[Sequence[str]] = ...) -> Dict[str, Class]: ... def readmodule_ex(module: str, path: Optional[Sequence[str]] = ...) -> Dict[str, Union[Class, Function, List[str]]]: ...
1,192
Python
.py
32
30.46875
129
0.568831
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,070
time.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/time.pyi
import sys from typing import Any, NamedTuple, Optional, Tuple, Union if sys.version_info >= (3, 3): from types import SimpleNamespace _TimeTuple = Tuple[int, int, int, int, int, int, int, int, int] if sys.version_info < (3, 3): accept2dyear: bool altzone: int daylight: int timezone: int tzname: Tuple[str, str] if sys.version_info >= (3, 7) and sys.platform != "win32": CLOCK_BOOTTIME: int # Linux CLOCK_PROF: int # FreeBSD, NetBSD, OpenBSD CLOCK_UPTIME: int # FreeBSD, OpenBSD if sys.version_info >= (3, 3) and sys.platform != "win32": CLOCK_HIGHRES: int # Solaris only CLOCK_MONOTONIC: int # Unix only CLOCK_MONOTONIC_RAW: int # Linux 2.6.28 or later CLOCK_PROCESS_CPUTIME_ID: int # Unix only CLOCK_REALTIME: int # Unix only CLOCK_THREAD_CPUTIME_ID: int # Unix only if sys.version_info >= (3, 8) and sys.platform == "darwin": CLOCK_UPTIME_RAW: int class _struct_time(NamedTuple): tm_year: int tm_mon: int tm_mday: int tm_hour: int tm_min: int tm_sec: int tm_wday: int tm_yday: int tm_isdst: int @property def n_fields(self) -> int: ... @property def n_sequence_fields(self) -> int: ... @property def n_unnamed_fields(self) -> int: ... if sys.version_info >= (3, 3): class struct_time(_struct_time): def __init__( self, o: Union[ Tuple[int, int, int, int, int, int, int, int, int], Tuple[int, int, int, int, int, int, int, int, int, str], Tuple[int, int, int, int, int, int, int, int, int, str, int], ], _arg: Any = ..., ) -> None: ... def __new__( cls, o: Union[ Tuple[int, int, int, int, int, int, int, int, int], Tuple[int, int, int, int, int, int, int, int, int, str], Tuple[int, int, int, int, int, int, int, int, int, str, int], ], _arg: Any = ..., ) -> struct_time: ... if sys.version_info >= (3, 6) or sys.platform != "win32": @property def tm_zone(self) -> str: ... @property def tm_gmtoff(self) -> int: ... else: class struct_time(_struct_time): def __init__(self, o: _TimeTuple, _arg: Any = ...) -> None: ... def __new__(cls, o: _TimeTuple, _arg: Any = ...) -> struct_time: ... def asctime(t: Union[_TimeTuple, struct_time] = ...) -> str: ... if sys.version_info < (3, 8): def clock() -> float: ... def ctime(secs: Optional[float] = ...) -> str: ... def gmtime(secs: Optional[float] = ...) -> struct_time: ... def localtime(secs: Optional[float] = ...) -> struct_time: ... def mktime(t: Union[_TimeTuple, struct_time]) -> float: ... def sleep(secs: float) -> None: ... def strftime(format: str, t: Union[_TimeTuple, struct_time] = ...) -> str: ... def strptime(string: str, format: str = ...) -> struct_time: ... def time() -> float: ... if sys.platform != "win32": def tzset() -> None: ... # Unix only if sys.version_info >= (3, 3): def get_clock_info(name: str) -> SimpleNamespace: ... def monotonic() -> float: ... def perf_counter() -> float: ... def process_time() -> float: ... if sys.platform != "win32": def clock_getres(clk_id: int) -> float: ... # Unix only def clock_gettime(clk_id: int) -> float: ... # Unix only def clock_settime(clk_id: int, time: float) -> None: ... # Unix only if sys.version_info >= (3, 7): if sys.platform != "win32": def clock_gettime_ns(clock_id: int) -> int: ... def clock_settime_ns(clock_id: int, time: int) -> int: ... def monotonic_ns() -> int: ... def perf_counter_ns() -> int: ... def process_time_ns() -> int: ... def time_ns() -> int: ... def thread_time() -> float: ... def thread_time_ns() -> int: ...
3,900
Python
.py
101
32.435644
78
0.559197
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,071
codecs.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/codecs.pyi
import sys import types from abc import abstractmethod from typing import ( IO, Any, BinaryIO, Callable, Generator, Iterable, Iterator, List, Optional, Protocol, Text, TextIO, Tuple, Type, TypeVar, Union, overload, ) from typing_extensions import Literal # TODO: this only satisfies the most common interface, where # bytes (py2 str) is the raw form and str (py2 unicode) is the cooked form. # In the long run, both should become template parameters maybe? # There *are* bytes->bytes and str->str encodings in the standard library. # They are much more common in Python 2 than in Python 3. _Decoded = Text _Encoded = bytes class _Encoder(Protocol): def __call__(self, input: _Decoded, errors: str = ...) -> Tuple[_Encoded, int]: ... # signature of Codec().encode class _Decoder(Protocol): def __call__(self, input: _Encoded, errors: str = ...) -> Tuple[_Decoded, int]: ... # signature of Codec().decode class _StreamReader(Protocol): def __call__(self, stream: IO[_Encoded], errors: str = ...) -> StreamReader: ... class _StreamWriter(Protocol): def __call__(self, stream: IO[_Encoded], errors: str = ...) -> StreamWriter: ... class _IncrementalEncoder(Protocol): def __call__(self, errors: str = ...) -> IncrementalEncoder: ... class _IncrementalDecoder(Protocol): def __call__(self, errors: str = ...) -> IncrementalDecoder: ... # The type ignore on `encode` and `decode` is to avoid issues with overlapping overloads, for more details, see #300 # mypy and pytype disagree about where the type ignore can and cannot go, so alias the long type _BytesToBytesEncodingT = Literal[ "base64", "base_64", "base64_codec", "bz2", "bz2_codec", "hex", "hex_codec", "quopri", "quotedprintable", "quoted_printable", "quopri_codec", "uu", "uu_codec", "zip", "zlib", "zlib_codec", ] @overload def encode(obj: bytes, encoding: _BytesToBytesEncodingT, errors: str = ...) -> bytes: ... @overload def encode(obj: str, encoding: Literal["rot13", "rot_13"] = ..., errors: str = ...) -> str: ... # type: ignore @overload def encode(obj: _Decoded, encoding: str = ..., errors: str = ...) -> _Encoded: ... @overload def decode(obj: bytes, encoding: _BytesToBytesEncodingT, errors: str = ...) -> bytes: ... # type: ignore @overload def decode(obj: str, encoding: Literal["rot13", "rot_13"] = ..., errors: str = ...) -> Text: ... @overload def decode(obj: _Encoded, encoding: str = ..., errors: str = ...) -> _Decoded: ... def lookup(__encoding: str) -> CodecInfo: ... def utf_16_be_decode(__obj: _Encoded, __errors: str = ..., __final: bool = ...) -> Tuple[_Decoded, int]: ... # undocumented def utf_16_be_encode(__obj: _Decoded, __errors: str = ...) -> Tuple[_Encoded, int]: ... # undocumented class CodecInfo(Tuple[_Encoder, _Decoder, _StreamReader, _StreamWriter]): @property def encode(self) -> _Encoder: ... @property def decode(self) -> _Decoder: ... @property def streamreader(self) -> _StreamReader: ... @property def streamwriter(self) -> _StreamWriter: ... @property def incrementalencoder(self) -> _IncrementalEncoder: ... @property def incrementaldecoder(self) -> _IncrementalDecoder: ... name: str def __new__( cls, encode: _Encoder, decode: _Decoder, streamreader: Optional[_StreamReader] = ..., streamwriter: Optional[_StreamWriter] = ..., incrementalencoder: Optional[_IncrementalEncoder] = ..., incrementaldecoder: Optional[_IncrementalDecoder] = ..., name: Optional[str] = ..., *, _is_text_encoding: Optional[bool] = ..., ) -> CodecInfo: ... def getencoder(encoding: str) -> _Encoder: ... def getdecoder(encoding: str) -> _Decoder: ... def getincrementalencoder(encoding: str) -> _IncrementalEncoder: ... def getincrementaldecoder(encoding: str) -> _IncrementalDecoder: ... def getreader(encoding: str) -> _StreamReader: ... def getwriter(encoding: str) -> _StreamWriter: ... def register(__search_function: Callable[[str], Optional[CodecInfo]]) -> None: ... def open( filename: str, mode: str = ..., encoding: Optional[str] = ..., errors: str = ..., buffering: int = ... ) -> StreamReaderWriter: ... def EncodedFile( file: IO[_Encoded], data_encoding: str, file_encoding: Optional[str] = ..., errors: str = ... ) -> StreamRecoder: ... def iterencode(iterator: Iterable[_Decoded], encoding: str, errors: str = ...) -> Generator[_Encoded, None, None]: ... def iterdecode(iterator: Iterable[_Encoded], encoding: str, errors: str = ...) -> Generator[_Decoded, None, None]: ... BOM: bytes BOM_BE: bytes BOM_LE: bytes BOM_UTF8: bytes BOM_UTF16: bytes BOM_UTF16_BE: bytes BOM_UTF16_LE: bytes BOM_UTF32: bytes BOM_UTF32_BE: bytes BOM_UTF32_LE: bytes # It is expected that different actions be taken depending on which of the # three subclasses of `UnicodeError` is actually ...ed. However, the Union # is still needed for at least one of the cases. def register_error(__errors: str, __handler: Callable[[UnicodeError], Tuple[Union[str, bytes], int]]) -> None: ... def lookup_error(__name: str) -> Callable[[UnicodeError], Tuple[Union[str, bytes], int]]: ... def strict_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... def replace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... def ignore_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... def xmlcharrefreplace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... def backslashreplace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... class Codec: # These are sort of @abstractmethod but sort of not. # The StreamReader and StreamWriter subclasses only implement one. def encode(self, input: _Decoded, errors: str = ...) -> Tuple[_Encoded, int]: ... def decode(self, input: _Encoded, errors: str = ...) -> Tuple[_Decoded, int]: ... class IncrementalEncoder: errors: str def __init__(self, errors: str = ...) -> None: ... @abstractmethod def encode(self, object: _Decoded, final: bool = ...) -> _Encoded: ... def reset(self) -> None: ... # documentation says int but str is needed for the subclass. def getstate(self) -> Union[int, _Decoded]: ... def setstate(self, state: Union[int, _Decoded]) -> None: ... class IncrementalDecoder: errors: str def __init__(self, errors: str = ...) -> None: ... @abstractmethod def decode(self, input: _Encoded, final: bool = ...) -> _Decoded: ... def reset(self) -> None: ... def getstate(self) -> Tuple[_Encoded, int]: ... def setstate(self, state: Tuple[_Encoded, int]) -> None: ... # These are not documented but used in encodings/*.py implementations. class BufferedIncrementalEncoder(IncrementalEncoder): buffer: str def __init__(self, errors: str = ...) -> None: ... @abstractmethod def _buffer_encode(self, input: _Decoded, errors: str, final: bool) -> _Encoded: ... def encode(self, input: _Decoded, final: bool = ...) -> _Encoded: ... class BufferedIncrementalDecoder(IncrementalDecoder): buffer: bytes def __init__(self, errors: str = ...) -> None: ... @abstractmethod def _buffer_decode(self, input: _Encoded, errors: str, final: bool) -> Tuple[_Decoded, int]: ... def decode(self, object: _Encoded, final: bool = ...) -> _Decoded: ... _SW = TypeVar("_SW", bound=StreamWriter) # TODO: it is not possible to specify the requirement that all other # attributes and methods are passed-through from the stream. class StreamWriter(Codec): errors: str def __init__(self, stream: IO[_Encoded], errors: str = ...) -> None: ... def write(self, obj: _Decoded) -> None: ... def writelines(self, list: Iterable[_Decoded]) -> None: ... def reset(self) -> None: ... def __enter__(self: _SW) -> _SW: ... def __exit__( self, typ: Optional[Type[BaseException]], exc: Optional[BaseException], tb: Optional[types.TracebackType] ) -> None: ... def __getattr__(self, name: str) -> Any: ... _SR = TypeVar("_SR", bound=StreamReader) class StreamReader(Codec): errors: str def __init__(self, stream: IO[_Encoded], errors: str = ...) -> None: ... def read(self, size: int = ..., chars: int = ..., firstline: bool = ...) -> _Decoded: ... def readline(self, size: int = ..., keepends: bool = ...) -> _Decoded: ... def readlines(self, sizehint: int = ..., keepends: bool = ...) -> List[_Decoded]: ... def reset(self) -> None: ... def __enter__(self: _SR) -> _SR: ... def __exit__( self, typ: Optional[Type[BaseException]], exc: Optional[BaseException], tb: Optional[types.TracebackType] ) -> None: ... def __iter__(self) -> Iterator[_Decoded]: ... def __getattr__(self, name: str) -> Any: ... _T = TypeVar("_T", bound=StreamReaderWriter) # Doesn't actually inherit from TextIO, but wraps a BinaryIO to provide text reading and writing # and delegates attributes to the underlying binary stream with __getattr__. class StreamReaderWriter(TextIO): def __init__(self, stream: IO[_Encoded], Reader: _StreamReader, Writer: _StreamWriter, errors: str = ...) -> None: ... def read(self, size: int = ...) -> _Decoded: ... def readline(self, size: Optional[int] = ...) -> _Decoded: ... def readlines(self, sizehint: Optional[int] = ...) -> List[_Decoded]: ... if sys.version_info >= (3,): def __next__(self) -> Text: ... else: def next(self) -> Text: ... def __iter__(self: _T) -> _T: ... # This actually returns None, but that's incompatible with the supertype def write(self, data: _Decoded) -> int: ... def writelines(self, list: Iterable[_Decoded]) -> None: ... def reset(self) -> None: ... # Same as write() def seek(self, offset: int, whence: int = ...) -> int: ... def __enter__(self: _T) -> _T: ... def __exit__( self, typ: Optional[Type[BaseException]], exc: Optional[BaseException], tb: Optional[types.TracebackType] ) -> None: ... def __getattr__(self, name: str) -> Any: ... # These methods don't actually exist directly, but they are needed to satisfy the TextIO # interface. At runtime, they are delegated through __getattr__. def close(self) -> None: ... def fileno(self) -> int: ... def flush(self) -> None: ... def isatty(self) -> bool: ... def readable(self) -> bool: ... def truncate(self, size: Optional[int] = ...) -> int: ... def seekable(self) -> bool: ... def tell(self) -> int: ... def writable(self) -> bool: ... _SRT = TypeVar("_SRT", bound=StreamRecoder) class StreamRecoder(BinaryIO): def __init__( self, stream: IO[_Encoded], encode: _Encoder, decode: _Decoder, Reader: _StreamReader, Writer: _StreamWriter, errors: str = ..., ) -> None: ... def read(self, size: int = ...) -> bytes: ... def readline(self, size: Optional[int] = ...) -> bytes: ... def readlines(self, sizehint: Optional[int] = ...) -> List[bytes]: ... if sys.version_info >= (3,): def __next__(self) -> bytes: ... else: def next(self) -> bytes: ... def __iter__(self: _SRT) -> _SRT: ... def write(self, data: bytes) -> int: ... def writelines(self, list: Iterable[bytes]) -> int: ... # type: ignore # it's supposed to return None def reset(self) -> None: ... def __getattr__(self, name: str) -> Any: ... def __enter__(self: _SRT) -> _SRT: ... def __exit__( self, type: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType] ) -> None: ... # These methods don't actually exist directly, but they are needed to satisfy the BinaryIO # interface. At runtime, they are delegated through __getattr__. def seek(self, offset: int, whence: int = ...) -> int: ... def close(self) -> None: ... def fileno(self) -> int: ... def flush(self) -> None: ... def isatty(self) -> bool: ... def readable(self) -> bool: ... def truncate(self, size: Optional[int] = ...) -> int: ... def seekable(self) -> bool: ... def tell(self) -> int: ... def writable(self) -> bool: ...
12,312
Python
.py
275
40.621818
124
0.629423
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,072
formatter.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/formatter.pyi
from typing import IO, Any, Iterable, List, Optional, Tuple AS_IS: None _FontType = Tuple[str, bool, bool, bool] _StylesType = Tuple[Any, ...] class NullFormatter: writer: Optional[NullWriter] def __init__(self, writer: Optional[NullWriter] = ...) -> None: ... def end_paragraph(self, blankline: int) -> None: ... def add_line_break(self) -> None: ... def add_hor_rule(self, *args: Any, **kw: Any) -> None: ... def add_label_data(self, format: str, counter: int, blankline: Optional[int] = ...) -> None: ... def add_flowing_data(self, data: str) -> None: ... def add_literal_data(self, data: str) -> None: ... def flush_softspace(self) -> None: ... def push_alignment(self, align: Optional[str]) -> None: ... def pop_alignment(self) -> None: ... def push_font(self, x: _FontType) -> None: ... def pop_font(self) -> None: ... def push_margin(self, margin: int) -> None: ... def pop_margin(self) -> None: ... def set_spacing(self, spacing: Optional[str]) -> None: ... def push_style(self, *styles: _StylesType) -> None: ... def pop_style(self, n: int = ...) -> None: ... def assert_line_data(self, flag: int = ...) -> None: ... class AbstractFormatter: writer: NullWriter align: Optional[str] align_stack: List[Optional[str]] font_stack: List[_FontType] margin_stack: List[int] spacing: Optional[str] style_stack: Any nospace: int softspace: int para_end: int parskip: int hard_break: int have_label: int def __init__(self, writer: NullWriter) -> None: ... def end_paragraph(self, blankline: int) -> None: ... def add_line_break(self) -> None: ... def add_hor_rule(self, *args: Any, **kw: Any) -> None: ... def add_label_data(self, format: str, counter: int, blankline: Optional[int] = ...) -> None: ... def format_counter(self, format: Iterable[str], counter: int) -> str: ... def format_letter(self, case: str, counter: int) -> str: ... def format_roman(self, case: str, counter: int) -> str: ... def add_flowing_data(self, data: str) -> None: ... def add_literal_data(self, data: str) -> None: ... def flush_softspace(self) -> None: ... def push_alignment(self, align: Optional[str]) -> None: ... def pop_alignment(self) -> None: ... def push_font(self, font: _FontType) -> None: ... def pop_font(self) -> None: ... def push_margin(self, margin: int) -> None: ... def pop_margin(self) -> None: ... def set_spacing(self, spacing: Optional[str]) -> None: ... def push_style(self, *styles: _StylesType) -> None: ... def pop_style(self, n: int = ...) -> None: ... def assert_line_data(self, flag: int = ...) -> None: ... class NullWriter: def __init__(self) -> None: ... def flush(self) -> None: ... def new_alignment(self, align: Optional[str]) -> None: ... def new_font(self, font: _FontType) -> None: ... def new_margin(self, margin: int, level: int) -> None: ... def new_spacing(self, spacing: Optional[str]) -> None: ... def new_styles(self, styles: Tuple[Any, ...]) -> None: ... def send_paragraph(self, blankline: int) -> None: ... def send_line_break(self) -> None: ... def send_hor_rule(self, *args: Any, **kw: Any) -> None: ... def send_label_data(self, data: str) -> None: ... def send_flowing_data(self, data: str) -> None: ... def send_literal_data(self, data: str) -> None: ... class AbstractWriter(NullWriter): def new_alignment(self, align: Optional[str]) -> None: ... def new_font(self, font: _FontType) -> None: ... def new_margin(self, margin: int, level: int) -> None: ... def new_spacing(self, spacing: Optional[str]) -> None: ... def new_styles(self, styles: Tuple[Any, ...]) -> None: ... def send_paragraph(self, blankline: int) -> None: ... def send_line_break(self) -> None: ... def send_hor_rule(self, *args: Any, **kw: Any) -> None: ... def send_label_data(self, data: str) -> None: ... def send_flowing_data(self, data: str) -> None: ... def send_literal_data(self, data: str) -> None: ... class DumbWriter(NullWriter): file: IO[str] maxcol: int def __init__(self, file: Optional[IO[str]] = ..., maxcol: int = ...) -> None: ... def reset(self) -> None: ... def send_paragraph(self, blankline: int) -> None: ... def send_line_break(self) -> None: ... def send_hor_rule(self, *args: Any, **kw: Any) -> None: ... def send_literal_data(self, data: str) -> None: ... def send_flowing_data(self, data: str) -> None: ... def test(file: Optional[str] = ...) -> None: ...
4,639
Python
.py
96
43.666667
100
0.599647
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,073
operator.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/operator.pyi
import sys from typing import ( Any, Callable, Container, Mapping, MutableMapping, MutableSequence, Sequence, SupportsAbs, Tuple, TypeVar, overload, ) _T = TypeVar("_T") _K = TypeVar("_K") _V = TypeVar("_V") def lt(__a: Any, __b: Any) -> Any: ... def le(__a: Any, __b: Any) -> Any: ... def eq(__a: Any, __b: Any) -> Any: ... def ne(__a: Any, __b: Any) -> Any: ... def ge(__a: Any, __b: Any) -> Any: ... def gt(__a: Any, __b: Any) -> Any: ... def __lt__(a: Any, b: Any) -> Any: ... def __le__(a: Any, b: Any) -> Any: ... def __eq__(a: Any, b: Any) -> Any: ... def __ne__(a: Any, b: Any) -> Any: ... def __ge__(a: Any, b: Any) -> Any: ... def __gt__(a: Any, b: Any) -> Any: ... def not_(__a: Any) -> bool: ... def __not__(a: Any) -> bool: ... def truth(__a: Any) -> bool: ... def is_(__a: Any, __b: Any) -> bool: ... def is_not(__a: Any, __b: Any) -> bool: ... def abs(__a: SupportsAbs[_T]) -> _T: ... def __abs__(a: SupportsAbs[_T]) -> _T: ... def add(__a: Any, __b: Any) -> Any: ... def __add__(a: Any, b: Any) -> Any: ... def and_(__a: Any, __b: Any) -> Any: ... def __and__(a: Any, b: Any) -> Any: ... if sys.version_info < (3,): def div(a: Any, b: Any) -> Any: ... def __div__(a: Any, b: Any) -> Any: ... def floordiv(__a: Any, __b: Any) -> Any: ... def __floordiv__(a: Any, b: Any) -> Any: ... def index(__a: Any) -> int: ... def __index__(a: Any) -> int: ... def inv(__a: Any) -> Any: ... def invert(__a: Any) -> Any: ... def __inv__(a: Any) -> Any: ... def __invert__(a: Any) -> Any: ... def lshift(__a: Any, __b: Any) -> Any: ... def __lshift__(a: Any, b: Any) -> Any: ... def mod(__a: Any, __b: Any) -> Any: ... def __mod__(a: Any, b: Any) -> Any: ... def mul(__a: Any, __b: Any) -> Any: ... def __mul__(a: Any, b: Any) -> Any: ... if sys.version_info >= (3, 5): def matmul(__a: Any, __b: Any) -> Any: ... def __matmul__(a: Any, b: Any) -> Any: ... def neg(__a: Any) -> Any: ... def __neg__(a: Any) -> Any: ... def or_(__a: Any, __b: Any) -> Any: ... def __or__(a: Any, b: Any) -> Any: ... def pos(__a: Any) -> Any: ... def __pos__(a: Any) -> Any: ... def pow(__a: Any, __b: Any) -> Any: ... def __pow__(a: Any, b: Any) -> Any: ... def rshift(__a: Any, __b: Any) -> Any: ... def __rshift__(a: Any, b: Any) -> Any: ... def sub(__a: Any, __b: Any) -> Any: ... def __sub__(a: Any, b: Any) -> Any: ... def truediv(__a: Any, __b: Any) -> Any: ... def __truediv__(a: Any, b: Any) -> Any: ... def xor(__a: Any, __b: Any) -> Any: ... def __xor__(a: Any, b: Any) -> Any: ... def concat(__a: Sequence[_T], __b: Sequence[_T]) -> Sequence[_T]: ... def __concat__(a: Sequence[_T], b: Sequence[_T]) -> Sequence[_T]: ... def contains(__a: Container[Any], __b: Any) -> bool: ... def __contains__(a: Container[Any], b: Any) -> bool: ... def countOf(__a: Container[Any], __b: Any) -> int: ... @overload def delitem(__a: MutableSequence[_T], __b: int) -> None: ... @overload def delitem(__a: MutableSequence[_T], __b: slice) -> None: ... @overload def delitem(__a: MutableMapping[_K, _V], __b: _K) -> None: ... @overload def __delitem__(a: MutableSequence[_T], b: int) -> None: ... @overload def __delitem__(a: MutableSequence[_T], b: slice) -> None: ... @overload def __delitem__(a: MutableMapping[_K, _V], b: _K) -> None: ... if sys.version_info < (3,): def delslice(a: MutableSequence[Any], b: int, c: int) -> None: ... def __delslice__(a: MutableSequence[Any], b: int, c: int) -> None: ... @overload def getitem(__a: Sequence[_T], __b: int) -> _T: ... @overload def getitem(__a: Sequence[_T], __b: slice) -> Sequence[_T]: ... @overload def getitem(__a: Mapping[_K, _V], __b: _K) -> _V: ... @overload def __getitem__(a: Sequence[_T], b: int) -> _T: ... @overload def __getitem__(a: Sequence[_T], b: slice) -> Sequence[_T]: ... @overload def __getitem__(a: Mapping[_K, _V], b: _K) -> _V: ... if sys.version_info < (3,): def getslice(a: Sequence[_T], b: int, c: int) -> Sequence[_T]: ... def __getslice__(a: Sequence[_T], b: int, c: int) -> Sequence[_T]: ... def indexOf(__a: Sequence[_T], __b: _T) -> int: ... if sys.version_info < (3,): def repeat(a: Any, b: int) -> Any: ... def __repeat__(a: Any, b: int) -> Any: ... if sys.version_info < (3,): def sequenceIncludes(a: Container[Any], b: Any) -> bool: ... @overload def setitem(__a: MutableSequence[_T], __b: int, __c: _T) -> None: ... @overload def setitem(__a: MutableSequence[_T], __b: slice, __c: Sequence[_T]) -> None: ... @overload def setitem(__a: MutableMapping[_K, _V], __b: _K, __c: _V) -> None: ... @overload def __setitem__(a: MutableSequence[_T], b: int, c: _T) -> None: ... @overload def __setitem__(a: MutableSequence[_T], b: slice, c: Sequence[_T]) -> None: ... @overload def __setitem__(a: MutableMapping[_K, _V], b: _K, c: _V) -> None: ... if sys.version_info < (3,): def setslice(a: MutableSequence[_T], b: int, c: int, v: Sequence[_T]) -> None: ... def __setslice__(a: MutableSequence[_T], b: int, c: int, v: Sequence[_T]) -> None: ... if sys.version_info >= (3, 4): def length_hint(__obj: Any, __default: int = ...) -> int: ... @overload def attrgetter(attr: str) -> Callable[[Any], Any]: ... @overload def attrgetter(*attrs: str) -> Callable[[Any], Tuple[Any, ...]]: ... @overload def itemgetter(item: Any) -> Callable[[Any], Any]: ... @overload def itemgetter(*items: Any) -> Callable[[Any], Tuple[Any, ...]]: ... def methodcaller(__name: str, *args: Any, **kwargs: Any) -> Callable[..., Any]: ... def iadd(__a: Any, __b: Any) -> Any: ... def __iadd__(a: Any, b: Any) -> Any: ... def iand(__a: Any, __b: Any) -> Any: ... def __iand__(a: Any, b: Any) -> Any: ... def iconcat(__a: Any, __b: Any) -> Any: ... def __iconcat__(a: Any, b: Any) -> Any: ... if sys.version_info < (3,): def idiv(a: Any, b: Any) -> Any: ... def __idiv__(a: Any, b: Any) -> Any: ... def ifloordiv(__a: Any, __b: Any) -> Any: ... def __ifloordiv__(a: Any, b: Any) -> Any: ... def ilshift(__a: Any, __b: Any) -> Any: ... def __ilshift__(a: Any, b: Any) -> Any: ... def imod(__a: Any, __b: Any) -> Any: ... def __imod__(a: Any, b: Any) -> Any: ... def imul(__a: Any, __b: Any) -> Any: ... def __imul__(a: Any, b: Any) -> Any: ... if sys.version_info >= (3, 5): def imatmul(__a: Any, __b: Any) -> Any: ... def __imatmul__(a: Any, b: Any) -> Any: ... def ior(__a: Any, __b: Any) -> Any: ... def __ior__(a: Any, b: Any) -> Any: ... def ipow(__a: Any, __b: Any) -> Any: ... def __ipow__(a: Any, b: Any) -> Any: ... if sys.version_info < (3,): def irepeat(a: Any, b: int) -> Any: ... def __irepeat__(a: Any, b: int) -> Any: ... def irshift(__a: Any, __b: Any) -> Any: ... def __irshift__(a: Any, b: Any) -> Any: ... def isub(__a: Any, __b: Any) -> Any: ... def __isub__(a: Any, b: Any) -> Any: ... def itruediv(__a: Any, __b: Any) -> Any: ... def __itruediv__(a: Any, b: Any) -> Any: ... def ixor(__a: Any, __b: Any) -> Any: ... def __ixor__(a: Any, b: Any) -> Any: ... if sys.version_info < (3,): def isCallable(x: Any) -> bool: ... def isMappingType(x: Any) -> bool: ... def isNumberType(x: Any) -> bool: ... def isSequenceType(x: Any) -> bool: ...
7,146
Python
.py
183
37.15847
90
0.516715
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,074
weakref.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/weakref.pyi
import sys import types from _weakrefset import WeakSet as WeakSet from typing import ( Any, Callable, Dict, Generic, Iterable, Iterator, List, Mapping, MutableMapping, Optional, Tuple, Type, TypeVar, Union, overload, ) from _weakref import ( CallableProxyType as CallableProxyType, ProxyType as ProxyType, ReferenceType as ReferenceType, getweakrefcount as getweakrefcount, getweakrefs as getweakrefs, proxy as proxy, ref as ref, ) if sys.version_info < (3, 0): from exceptions import ReferenceError as ReferenceError _S = TypeVar("_S") _T = TypeVar("_T") _KT = TypeVar("_KT") _VT = TypeVar("_VT") ProxyTypes: Tuple[Type[Any], ...] if sys.version_info >= (3, 4): class WeakMethod(ref[types.MethodType]): def __new__(cls, meth: types.MethodType, callback: Optional[Callable[[types.MethodType], Any]] = ...) -> WeakMethod: ... def __call__(self) -> Optional[types.MethodType]: ... class WeakValueDictionary(MutableMapping[_KT, _VT]): @overload def __init__(self) -> None: ... @overload def __init__(self, __other: Union[Mapping[_KT, _VT], Iterable[Tuple[_KT, _VT]]], **kwargs: _VT) -> None: ... def __len__(self) -> int: ... def __getitem__(self, k: _KT) -> _VT: ... def __setitem__(self, k: _KT, v: _VT) -> None: ... def __delitem__(self, v: _KT) -> None: ... if sys.version_info < (3, 0): def has_key(self, key: object) -> bool: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_KT]: ... def __str__(self) -> str: ... def copy(self) -> WeakValueDictionary[_KT, _VT]: ... if sys.version_info < (3, 0): def keys(self) -> List[_KT]: ... def values(self) -> List[_VT]: ... def items(self) -> List[Tuple[_KT, _VT]]: ... def iterkeys(self) -> Iterator[_KT]: ... def itervalues(self) -> Iterator[_VT]: ... def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ... else: # These are incompatible with Mapping def keys(self) -> Iterator[_KT]: ... # type: ignore def values(self) -> Iterator[_VT]: ... # type: ignore def items(self) -> Iterator[Tuple[_KT, _VT]]: ... # type: ignore def itervaluerefs(self) -> Iterator[KeyedRef[_KT, _VT]]: ... def valuerefs(self) -> List[KeyedRef[_KT, _VT]]: ... class KeyedRef(ref[_T], Generic[_KT, _T]): key: _KT def __new__(type, ob: _T, callback: Callable[[_T], Any], key: _KT) -> KeyedRef: ... def __init__(self, ob: _T, callback: Callable[[_T], Any], key: _KT) -> None: ... class WeakKeyDictionary(MutableMapping[_KT, _VT]): @overload def __init__(self, dict: None = ...) -> None: ... @overload def __init__(self, dict: Union[Mapping[_KT, _VT], Iterable[Tuple[_KT, _VT]]]) -> None: ... def __len__(self) -> int: ... def __getitem__(self, k: _KT) -> _VT: ... def __setitem__(self, k: _KT, v: _VT) -> None: ... def __delitem__(self, v: _KT) -> None: ... if sys.version_info < (3, 0): def has_key(self, key: object) -> bool: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_KT]: ... def __str__(self) -> str: ... def copy(self) -> WeakKeyDictionary[_KT, _VT]: ... if sys.version_info < (3, 0): def keys(self) -> List[_KT]: ... def values(self) -> List[_VT]: ... def items(self) -> List[Tuple[_KT, _VT]]: ... def iterkeys(self) -> Iterator[_KT]: ... def itervalues(self) -> Iterator[_VT]: ... def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ... def iterkeyrefs(self) -> Iterator[ref[_KT]]: ... else: # These are incompatible with Mapping def keys(self) -> Iterator[_KT]: ... # type: ignore def values(self) -> Iterator[_VT]: ... # type: ignore def items(self) -> Iterator[Tuple[_KT, _VT]]: ... # type: ignore def keyrefs(self) -> List[ref[_KT]]: ... if sys.version_info >= (3, 4): class finalize: def __init__(self, __obj: _S, __func: Callable[..., _T], *args: Any, **kwargs: Any) -> None: ... def __call__(self, _: Any = ...) -> Optional[_T]: ... def detach(self) -> Optional[Tuple[_S, _T, Tuple[Any, ...], Dict[str, Any]]]: ... def peek(self) -> Optional[Tuple[_S, _T, Tuple[Any, ...], Dict[str, Any]]]: ... alive: bool atexit: bool
4,433
Python
.py
110
34.745455
128
0.556096
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,075
linecache.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/linecache.pyi
import sys from typing import Any, Dict, List, Optional, Text _ModuleGlobals = Dict[str, Any] def getline(filename: Text, lineno: int, module_globals: Optional[_ModuleGlobals] = ...) -> str: ... def clearcache() -> None: ... def getlines(filename: Text, module_globals: Optional[_ModuleGlobals] = ...) -> List[str]: ... def checkcache(filename: Optional[Text] = ...) -> None: ... def updatecache(filename: Text, module_globals: Optional[_ModuleGlobals] = ...) -> List[str]: ... if sys.version_info >= (3, 5): def lazycache(filename: Text, module_globals: _ModuleGlobals) -> bool: ...
591
Python
.py
10
57.4
100
0.685121
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,076
shutil.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/shutil.pyi
import os import sys from _typeshed import StrPath, SupportsRead, SupportsWrite from typing import ( Any, AnyStr, Callable, Iterable, List, NamedTuple, Optional, Sequence, Set, Tuple, Type, TypeVar, Union, overload, ) if sys.version_info >= (3, 6): _AnyStr = str _AnyPath = TypeVar("_AnyPath", str, os.PathLike[str]) # Return value of some functions that may either return a path-like object that was passed in or # a string _PathReturn = Any elif sys.version_info >= (3,): _AnyStr = str _AnyPath = str _PathReturn = str else: _AnyStr = TypeVar("_AnyStr", str, unicode) _AnyPath = TypeVar("_AnyPath", str, unicode) _PathReturn = Type[None] if sys.version_info >= (3,): class Error(OSError): ... class SameFileError(Error): ... class SpecialFileError(OSError): ... class ExecError(OSError): ... class ReadError(OSError): ... class RegistryError(Exception): ... else: class Error(EnvironmentError): ... class SpecialFileError(EnvironmentError): ... class ExecError(EnvironmentError): ... def copyfileobj(fsrc: SupportsRead[AnyStr], fdst: SupportsWrite[AnyStr], length: int = ...) -> None: ... if sys.version_info >= (3,): def copyfile(src: StrPath, dst: _AnyPath, *, follow_symlinks: bool = ...) -> _AnyPath: ... def copymode(src: StrPath, dst: StrPath, *, follow_symlinks: bool = ...) -> None: ... def copystat(src: StrPath, dst: StrPath, *, follow_symlinks: bool = ...) -> None: ... def copy(src: StrPath, dst: StrPath, *, follow_symlinks: bool = ...) -> _PathReturn: ... def copy2(src: StrPath, dst: StrPath, *, follow_symlinks: bool = ...) -> _PathReturn: ... else: def copyfile(src: StrPath, dst: StrPath) -> None: ... def copymode(src: StrPath, dst: StrPath) -> None: ... def copystat(src: StrPath, dst: StrPath) -> None: ... def copy(src: StrPath, dst: StrPath) -> _PathReturn: ... def copy2(src: StrPath, dst: StrPath) -> _PathReturn: ... def ignore_patterns(*patterns: StrPath) -> Callable[[Any, List[_AnyStr]], Set[_AnyStr]]: ... if sys.version_info >= (3, 8): def copytree( src: StrPath, dst: StrPath, symlinks: bool = ..., ignore: Union[None, Callable[[str, List[str]], Iterable[str]], Callable[[StrPath, List[str]], Iterable[str]]] = ..., copy_function: Callable[[str, str], None] = ..., ignore_dangling_symlinks: bool = ..., dirs_exist_ok: bool = ..., ) -> _PathReturn: ... elif sys.version_info >= (3,): def copytree( src: StrPath, dst: StrPath, symlinks: bool = ..., ignore: Union[None, Callable[[str, List[str]], Iterable[str]], Callable[[StrPath, List[str]], Iterable[str]]] = ..., copy_function: Callable[[str, str], None] = ..., ignore_dangling_symlinks: bool = ..., ) -> _PathReturn: ... else: def copytree( src: AnyStr, dst: AnyStr, symlinks: bool = ..., ignore: Union[None, Callable[[AnyStr, List[AnyStr]], Iterable[AnyStr]]] = ..., ) -> _PathReturn: ... if sys.version_info >= (3,): def rmtree( path: Union[bytes, StrPath], ignore_errors: bool = ..., onerror: Optional[Callable[[Any, Any, Any], Any]] = ... ) -> None: ... else: def rmtree( path: _AnyPath, ignore_errors: bool = ..., onerror: Optional[Callable[[Any, _AnyPath, Any], Any]] = ... ) -> None: ... _CopyFn = Union[Callable[[str, str], None], Callable[[StrPath, StrPath], None]] if sys.version_info >= (3, 9): def move(src: StrPath, dst: StrPath, copy_function: _CopyFn = ...) -> _PathReturn: ... elif sys.version_info >= (3, 5): # See https://bugs.python.org/issue32689 def move(src: str, dst: StrPath, copy_function: _CopyFn = ...) -> _PathReturn: ... else: def move(src: StrPath, dst: StrPath) -> _PathReturn: ... if sys.version_info >= (3,): class _ntuple_diskusage(NamedTuple): total: int used: int free: int def disk_usage(path: StrPath) -> _ntuple_diskusage: ... def chown(path: StrPath, user: Optional[Union[str, int]] = ..., group: Optional[Union[str, int]] = ...) -> None: ... if sys.version_info >= (3, 8): @overload def which(cmd: StrPath, mode: int = ..., path: Optional[StrPath] = ...) -> Optional[str]: ... @overload def which(cmd: bytes, mode: int = ..., path: Optional[StrPath] = ...) -> Optional[bytes]: ... elif sys.version_info >= (3,): def which(cmd: StrPath, mode: int = ..., path: Optional[StrPath] = ...) -> Optional[str]: ... def make_archive( base_name: _AnyStr, format: str, root_dir: Optional[StrPath] = ..., base_dir: Optional[StrPath] = ..., verbose: bool = ..., dry_run: bool = ..., owner: Optional[str] = ..., group: Optional[str] = ..., logger: Optional[Any] = ..., ) -> _AnyStr: ... def get_archive_formats() -> List[Tuple[str, str]]: ... def register_archive_format( name: str, function: Callable[..., Any], extra_args: Optional[Sequence[Union[Tuple[str, Any], List[Any]]]] = ..., description: str = ..., ) -> None: ... def unregister_archive_format(name: str) -> None: ... if sys.version_info >= (3,): if sys.version_info >= (3, 7): def unpack_archive(filename: StrPath, extract_dir: Optional[StrPath] = ..., format: Optional[str] = ...) -> None: ... else: # See http://bugs.python.org/issue30218 def unpack_archive(filename: str, extract_dir: Optional[StrPath] = ..., format: Optional[str] = ...) -> None: ... def register_unpack_format( name: str, extensions: List[str], function: Any, extra_args: Sequence[Tuple[str, Any]] = ..., description: str = ... ) -> None: ... def unregister_unpack_format(name: str) -> None: ... def get_unpack_formats() -> List[Tuple[str, List[str], str]]: ... def get_terminal_size(fallback: Tuple[int, int] = ...) -> os.terminal_size: ...
5,961
Python
.py
145
36.158621
125
0.604314
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,077
antigravity.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/antigravity.pyi
import sys if sys.version_info >= (3, 0): def geohash(latitude: float, longitude: float, datedow: bytes) -> None: ...
123
Python
.py
3
38.333333
79
0.672269
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,078
pkgutil.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/pkgutil.pyi
import sys from _typeshed import SupportsRead from typing import IO, Any, Callable, Iterable, Iterator, NamedTuple, Optional, Tuple, Union if sys.version_info >= (3,): from importlib.abc import Loader, MetaPathFinder, PathEntryFinder else: Loader = Any MetaPathFinder = Any PathEntryFinder = Any if sys.version_info >= (3, 6): class ModuleInfo(NamedTuple): module_finder: Union[MetaPathFinder, PathEntryFinder] name: str ispkg: bool _ModuleInfoLike = ModuleInfo else: _ModuleInfoLike = Tuple[Union[MetaPathFinder, PathEntryFinder], str, bool] def extend_path(path: Iterable[str], name: str) -> Iterable[str]: ... class ImpImporter: def __init__(self, dirname: Optional[str] = ...) -> None: ... class ImpLoader: def __init__(self, fullname: str, file: IO[str], filename: str, etc: Tuple[str, str, int]) -> None: ... def find_loader(fullname: str) -> Optional[Loader]: ... def get_importer(path_item: str) -> Optional[PathEntryFinder]: ... def get_loader(module_or_name: str) -> Loader: ... def iter_importers(fullname: str = ...) -> Iterator[Union[MetaPathFinder, PathEntryFinder]]: ... def iter_modules(path: Optional[Iterable[str]] = ..., prefix: str = ...) -> Iterator[_ModuleInfoLike]: ... def read_code(stream: SupportsRead[bytes]) -> Any: ... # undocumented def walk_packages( path: Optional[Iterable[str]] = ..., prefix: str = ..., onerror: Optional[Callable[[str], None]] = ... ) -> Iterator[_ModuleInfoLike]: ... def get_data(package: str, resource: str) -> Optional[bytes]: ...
1,558
Python
.py
32
45.5
107
0.688816
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,079
struct.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/struct.pyi
import sys from array import array from mmap import mmap from typing import Any, Iterator, Text, Tuple, Union class error(Exception): ... _FmtType = Union[bytes, Text] if sys.version_info >= (3,): _BufferType = Union[array[int], bytes, bytearray, memoryview, mmap] _WriteBufferType = Union[array, bytearray, memoryview, mmap] else: _BufferType = Union[array[int], bytes, bytearray, buffer, memoryview, mmap] _WriteBufferType = Union[array[Any], bytearray, buffer, memoryview, mmap] def pack(fmt: _FmtType, *v: Any) -> bytes: ... def pack_into(fmt: _FmtType, buffer: _WriteBufferType, offset: int, *v: Any) -> None: ... def unpack(__format: _FmtType, __buffer: _BufferType) -> Tuple[Any, ...]: ... def unpack_from(__format: _FmtType, buffer: _BufferType, offset: int = ...) -> Tuple[Any, ...]: ... if sys.version_info >= (3, 4): def iter_unpack(__format: _FmtType, __buffer: _BufferType) -> Iterator[Tuple[Any, ...]]: ... def calcsize(__format: _FmtType) -> int: ... class Struct: if sys.version_info >= (3, 7): format: str else: format: bytes size: int def __init__(self, format: _FmtType) -> None: ... def pack(self, *v: Any) -> bytes: ... def pack_into(self, buffer: _WriteBufferType, offset: int, *v: Any) -> None: ... def unpack(self, __buffer: _BufferType) -> Tuple[Any, ...]: ... def unpack_from(self, buffer: _BufferType, offset: int = ...) -> Tuple[Any, ...]: ... if sys.version_info >= (3, 4): def iter_unpack(self, __buffer: _BufferType) -> Iterator[Tuple[Any, ...]]: ...
1,568
Python
.py
32
45.3125
99
0.633987
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,080
sunau.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/sunau.pyi
import sys from typing import IO, Any, NamedTuple, NoReturn, Optional, Text, Tuple, Union _File = Union[Text, IO[bytes]] class Error(Exception): ... AUDIO_FILE_MAGIC: int AUDIO_FILE_ENCODING_MULAW_8: int AUDIO_FILE_ENCODING_LINEAR_8: int AUDIO_FILE_ENCODING_LINEAR_16: int AUDIO_FILE_ENCODING_LINEAR_24: int AUDIO_FILE_ENCODING_LINEAR_32: int AUDIO_FILE_ENCODING_FLOAT: int AUDIO_FILE_ENCODING_DOUBLE: int AUDIO_FILE_ENCODING_ADPCM_G721: int AUDIO_FILE_ENCODING_ADPCM_G722: int AUDIO_FILE_ENCODING_ADPCM_G723_3: int AUDIO_FILE_ENCODING_ADPCM_G723_5: int AUDIO_FILE_ENCODING_ALAW_8: int AUDIO_UNKNOWN_SIZE: int if sys.version_info < (3, 0): _sunau_params = Tuple[int, int, int, int, str, str] else: class _sunau_params(NamedTuple): nchannels: int sampwidth: int framerate: int nframes: int comptype: str compname: str class Au_read: def __init__(self, f: _File) -> None: ... if sys.version_info >= (3, 3): def __enter__(self) -> Au_read: ... def __exit__(self, *args: Any) -> None: ... def getfp(self) -> Optional[IO[bytes]]: ... def rewind(self) -> None: ... def close(self) -> None: ... def tell(self) -> int: ... def getnchannels(self) -> int: ... def getnframes(self) -> int: ... def getsampwidth(self) -> int: ... def getframerate(self) -> int: ... def getcomptype(self) -> str: ... def getcompname(self) -> str: ... def getparams(self) -> _sunau_params: ... def getmarkers(self) -> None: ... def getmark(self, id: Any) -> NoReturn: ... def setpos(self, pos: int) -> None: ... def readframes(self, nframes: int) -> Optional[bytes]: ... class Au_write: def __init__(self, f: _File) -> None: ... if sys.version_info >= (3, 3): def __enter__(self) -> Au_write: ... def __exit__(self, *args: Any) -> None: ... def setnchannels(self, nchannels: int) -> None: ... def getnchannels(self) -> int: ... def setsampwidth(self, sampwidth: int) -> None: ... def getsampwidth(self) -> int: ... def setframerate(self, framerate: float) -> None: ... def getframerate(self) -> int: ... def setnframes(self, nframes: int) -> None: ... def getnframes(self) -> int: ... def setcomptype(self, comptype: str, compname: str) -> None: ... def getcomptype(self) -> str: ... def getcompname(self) -> str: ... def setparams(self, params: _sunau_params) -> None: ... def getparams(self) -> _sunau_params: ... def setmark(self, id: Any, pos: Any, name: Any) -> NoReturn: ... def getmark(self, id: Any) -> NoReturn: ... def getmarkers(self) -> None: ... def tell(self) -> int: ... # should be any bytes-like object after 3.4, but we don't have a type for that def writeframesraw(self, data: bytes) -> None: ... def writeframes(self, data: bytes) -> None: ... def close(self) -> None: ... # Returns a Au_read if mode is rb and Au_write if mode is wb def open(f: _File, mode: Optional[str] = ...) -> Any: ... if sys.version_info < (3, 9): openfp = open
3,085
Python
.py
78
35.217949
82
0.621207
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,081
imghdr.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/imghdr.pyi
import os import sys from typing import Any, BinaryIO, Callable, List, Optional, Protocol, Text, Union, overload class _ReadableBinary(Protocol): def tell(self) -> int: ... def read(self, size: int) -> bytes: ... def seek(self, offset: int) -> Any: ... if sys.version_info >= (3, 6): _File = Union[Text, os.PathLike[Text], _ReadableBinary] else: _File = Union[Text, _ReadableBinary] @overload def what(file: _File, h: None = ...) -> Optional[str]: ... @overload def what(file: Any, h: bytes) -> Optional[str]: ... tests: List[Callable[[bytes, Optional[BinaryIO]], Optional[str]]]
604
Python
.py
16
35.25
91
0.672945
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,082
_bisect.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/_bisect.pyi
from typing import MutableSequence, Optional, Sequence, TypeVar _T = TypeVar("_T") def bisect_left(a: Sequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> int: ... def bisect_right(a: Sequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> int: ... def insort_left(a: MutableSequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> None: ... def insort_right(a: MutableSequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> None: ...
471
Python
.py
6
77.166667
100
0.572354
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,083
netrc.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/netrc.pyi
from typing import Dict, List, Optional, Tuple class NetrcParseError(Exception): filename: Optional[str] lineno: Optional[int] msg: str # (login, account, password) tuple _NetrcTuple = Tuple[str, Optional[str], Optional[str]] class netrc: hosts: Dict[str, _NetrcTuple] macros: Dict[str, List[str]] def __init__(self, file: str = ...) -> None: ... def authenticators(self, host: str) -> Optional[_NetrcTuple]: ...
444
Python
.py
12
33.416667
69
0.682984
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,084
wave.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/wave.pyi
import sys from typing import IO, Any, BinaryIO, NamedTuple, NoReturn, Optional, Text, Tuple, Union _File = Union[Text, IO[bytes]] class Error(Exception): ... WAVE_FORMAT_PCM: int if sys.version_info < (3, 0): _wave_params = Tuple[int, int, int, int, str, str] else: class _wave_params(NamedTuple): nchannels: int sampwidth: int framerate: int nframes: int comptype: str compname: str class Wave_read: def __init__(self, f: _File) -> None: ... if sys.version_info >= (3, 0): def __enter__(self) -> Wave_read: ... def __exit__(self, *args: Any) -> None: ... def getfp(self) -> Optional[BinaryIO]: ... def rewind(self) -> None: ... def close(self) -> None: ... def tell(self) -> int: ... def getnchannels(self) -> int: ... def getnframes(self) -> int: ... def getsampwidth(self) -> int: ... def getframerate(self) -> int: ... def getcomptype(self) -> str: ... def getcompname(self) -> str: ... def getparams(self) -> _wave_params: ... def getmarkers(self) -> None: ... def getmark(self, id: Any) -> NoReturn: ... def setpos(self, pos: int) -> None: ... def readframes(self, nframes: int) -> bytes: ... class Wave_write: def __init__(self, f: _File) -> None: ... if sys.version_info >= (3, 0): def __enter__(self) -> Wave_write: ... def __exit__(self, *args: Any) -> None: ... def setnchannels(self, nchannels: int) -> None: ... def getnchannels(self) -> int: ... def setsampwidth(self, sampwidth: int) -> None: ... def getsampwidth(self) -> int: ... def setframerate(self, framerate: float) -> None: ... def getframerate(self) -> int: ... def setnframes(self, nframes: int) -> None: ... def getnframes(self) -> int: ... def setcomptype(self, comptype: str, compname: str) -> None: ... def getcomptype(self) -> str: ... def getcompname(self) -> str: ... def setparams(self, params: _wave_params) -> None: ... def getparams(self) -> _wave_params: ... def setmark(self, id: Any, pos: Any, name: Any) -> NoReturn: ... def getmark(self, id: Any) -> NoReturn: ... def getmarkers(self) -> None: ... def tell(self) -> int: ... # should be any bytes-like object after 3.4, but we don't have a type for that def writeframesraw(self, data: bytes) -> None: ... def writeframes(self, data: bytes) -> None: ... def close(self) -> None: ... # Returns a Wave_read if mode is rb and Wave_write if mode is wb def open(f: _File, mode: Optional[str] = ...) -> Any: ... if sys.version_info < (3, 9): openfp = open
2,651
Python
.py
65
35.784615
88
0.589604
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,085
fileinput.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/fileinput.pyi
import sys from _typeshed import AnyPath from typing import IO, Any, AnyStr, Callable, Generic, Iterable, Iterator, Optional, Union if sys.version_info >= (3, 8): def input( files: Union[AnyPath, Iterable[AnyPath], None] = ..., inplace: bool = ..., backup: str = ..., *, mode: str = ..., openhook: Callable[[AnyPath, str], IO[AnyStr]] = ..., ) -> FileInput[AnyStr]: ... else: def input( files: Union[AnyPath, Iterable[AnyPath], None] = ..., inplace: bool = ..., backup: str = ..., bufsize: int = ..., mode: str = ..., openhook: Callable[[AnyPath, str], IO[AnyStr]] = ..., ) -> FileInput[AnyStr]: ... def close() -> None: ... def nextfile() -> None: ... def filename() -> str: ... def lineno() -> int: ... def filelineno() -> int: ... def fileno() -> int: ... def isfirstline() -> bool: ... def isstdin() -> bool: ... class FileInput(Iterable[AnyStr], Generic[AnyStr]): if sys.version_info >= (3, 8): def __init__( self, files: Union[None, AnyPath, Iterable[AnyPath]] = ..., inplace: bool = ..., backup: str = ..., *, mode: str = ..., openhook: Callable[[AnyPath, str], IO[AnyStr]] = ..., ) -> None: ... else: def __init__( self, files: Union[None, AnyPath, Iterable[AnyPath]] = ..., inplace: bool = ..., backup: str = ..., bufsize: int = ..., mode: str = ..., openhook: Callable[[AnyPath, str], IO[AnyStr]] = ..., ) -> None: ... def __del__(self) -> None: ... def close(self) -> None: ... if sys.version_info >= (3, 2): def __enter__(self) -> FileInput[AnyStr]: ... def __exit__(self, type: Any, value: Any, traceback: Any) -> None: ... def __iter__(self) -> Iterator[AnyStr]: ... def __next__(self) -> AnyStr: ... def __getitem__(self, i: int) -> AnyStr: ... def nextfile(self) -> None: ... def readline(self) -> AnyStr: ... def filename(self) -> str: ... def lineno(self) -> int: ... def filelineno(self) -> int: ... def fileno(self) -> int: ... def isfirstline(self) -> bool: ... def isstdin(self) -> bool: ... def hook_compressed(filename: AnyPath, mode: str) -> IO[Any]: ... if sys.version_info >= (3, 6): def hook_encoded(encoding: str, errors: Optional[str] = ...) -> Callable[[AnyPath, str], IO[Any]]: ... else: def hook_encoded(encoding: str) -> Callable[[AnyPath, str], IO[Any]]: ...
2,601
Python
.py
71
29.901408
106
0.514863
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,086
dummy_threading.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/dummy_threading.pyi
from _dummy_threading import * from _dummy_threading import __all__ as __all__
79
Python
.py
2
38.5
47
0.727273
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,087
_warnings.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/_warnings.pyi
import sys from typing import Any, Dict, List, Optional, Tuple, Type, Union, overload if sys.version_info >= (3, 0): _defaultaction: str _onceregistry: Dict[Any, Any] else: default_action: str once_registry: Dict[Any, Any] filters: List[Tuple[Any, ...]] if sys.version_info >= (3, 6): @overload def warn( message: str, category: Optional[Type[Warning]] = ..., stacklevel: int = ..., source: Optional[Any] = ... ) -> None: ... @overload def warn(message: Warning, category: Any = ..., stacklevel: int = ..., source: Optional[Any] = ...) -> None: ... @overload def warn_explicit( message: str, category: Type[Warning], filename: str, lineno: int, module: Optional[str] = ..., registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ..., module_globals: Optional[Dict[str, Any]] = ..., source: Optional[Any] = ..., ) -> None: ... @overload def warn_explicit( message: Warning, category: Any, filename: str, lineno: int, module: Optional[str] = ..., registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ..., module_globals: Optional[Dict[str, Any]] = ..., source: Optional[Any] = ..., ) -> None: ... else: @overload def warn(message: str, category: Optional[Type[Warning]] = ..., stacklevel: int = ...) -> None: ... @overload def warn(message: Warning, category: Any = ..., stacklevel: int = ...) -> None: ... @overload def warn_explicit( message: str, category: Type[Warning], filename: str, lineno: int, module: Optional[str] = ..., registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ..., module_globals: Optional[Dict[str, Any]] = ..., ) -> None: ... @overload def warn_explicit( message: Warning, category: Any, filename: str, lineno: int, module: Optional[str] = ..., registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ..., module_globals: Optional[Dict[str, Any]] = ..., ) -> None: ...
2,233
Python
.py
63
28.857143
116
0.565559
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,088
turtle.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/turtle.pyi
import sys from typing import Any, Callable, Dict, List, Optional, Sequence, Text, Tuple, TypeVar, Union, overload if sys.version_info >= (3,): from tkinter import Canvas, PhotoImage else: # TODO: Replace these aliases once we have Python 2 stubs for the Tkinter module. Canvas = Any PhotoImage = Any # Note: '_Color' is the alias we use for arguments and _AnyColor is the # alias we use for return types. Really, these two aliases should be the # same, but as per the "no union returns" typeshed policy, we'll return # Any instead. _Color = Union[Text, Tuple[float, float, float]] _AnyColor = Any # TODO: Replace this with a TypedDict once it becomes standardized. _PenState = Dict[str, Any] _Speed = Union[str, float] _PolygonCoords = Sequence[Tuple[float, float]] # TODO: Type this more accurately # Vec2D is actually a custom subclass of 'tuple'. Vec2D = Tuple[float, float] class TurtleScreenBase(object): cv: Canvas = ... canvwidth: int = ... canvheight: int = ... xscale: float = ... yscale: float = ... def __init__(self, cv: Canvas) -> None: ... if sys.version_info >= (3,): def mainloop(self) -> None: ... def textinput(self, title: str, prompt: str) -> Optional[str]: ... def numinput( self, title: str, prompt: str, default: Optional[float] = ..., minval: Optional[float] = ..., maxval: Optional[float] = ..., ) -> Optional[float]: ... class Terminator(Exception): ... class TurtleGraphicsError(Exception): ... class Shape(object): def __init__(self, type_: str, data: Union[_PolygonCoords, PhotoImage, None] = ...) -> None: ... def addcomponent(self, poly: _PolygonCoords, fill: _Color, outline: Optional[_Color] = ...) -> None: ... class TurtleScreen(TurtleScreenBase): def __init__(self, cv: Canvas, mode: str = ..., colormode: float = ..., delay: int = ...) -> None: ... def clear(self) -> None: ... @overload def mode(self, mode: None = ...) -> str: ... @overload def mode(self, mode: str) -> None: ... def setworldcoordinates(self, llx: float, lly: float, urx: float, ury: float) -> None: ... def register_shape(self, name: str, shape: Union[_PolygonCoords, Shape, None] = ...) -> None: ... @overload def colormode(self, cmode: None = ...) -> float: ... @overload def colormode(self, cmode: float) -> None: ... def reset(self) -> None: ... def turtles(self) -> List[Turtle]: ... @overload def bgcolor(self) -> _AnyColor: ... @overload def bgcolor(self, color: _Color) -> None: ... @overload def bgcolor(self, r: float, g: float, b: float) -> None: ... @overload def tracer(self, n: None = ...) -> int: ... @overload def tracer(self, n: int, delay: Optional[int] = ...) -> None: ... @overload def delay(self, delay: None = ...) -> int: ... @overload def delay(self, delay: int) -> None: ... def update(self) -> None: ... def window_width(self) -> int: ... def window_height(self) -> int: ... def getcanvas(self) -> Canvas: ... def getshapes(self) -> List[str]: ... def onclick(self, fun: Callable[[float, float], Any], btn: int = ..., add: Optional[Any] = ...) -> None: ... def onkey(self, fun: Callable[[], Any], key: str) -> None: ... def listen(self, xdummy: Optional[float] = ..., ydummy: Optional[float] = ...) -> None: ... def ontimer(self, fun: Callable[[], Any], t: int = ...) -> None: ... @overload def bgpic(self, picname: None = ...) -> str: ... @overload def bgpic(self, picname: str) -> None: ... @overload def screensize(self, canvwidth: None = ..., canvheight: None = ..., bg: None = ...) -> Tuple[int, int]: ... # Looks like if self.cv is not a ScrolledCanvas, this could return a tuple as well @overload def screensize(self, canvwidth: int, canvheight: int, bg: Optional[_Color] = ...) -> None: ... onscreenclick = onclick resetscreen = reset clearscreen = clear addshape = register_shape if sys.version_info >= (3,): def onkeypress(self, fun: Callable[[], Any], key: Optional[str] = ...) -> None: ... onkeyrelease = onkey class TNavigator(object): START_ORIENTATION: Dict[str, Vec2D] = ... DEFAULT_MODE: str = ... DEFAULT_ANGLEOFFSET: int = ... DEFAULT_ANGLEORIENT: int = ... def __init__(self, mode: str = ...) -> None: ... def reset(self) -> None: ... def degrees(self, fullcircle: float = ...) -> None: ... def radians(self) -> None: ... def forward(self, distance: float) -> None: ... def back(self, distance: float) -> None: ... def right(self, angle: float) -> None: ... def left(self, angle: float) -> None: ... def pos(self) -> Vec2D: ... def xcor(self) -> float: ... def ycor(self) -> float: ... @overload def goto(self, x: Tuple[float, float], y: None = ...) -> None: ... @overload def goto(self, x: float, y: float) -> None: ... def home(self) -> None: ... def setx(self, x: float) -> None: ... def sety(self, y: float) -> None: ... @overload def distance(self, x: Union[TNavigator, Tuple[float, float]], y: None = ...) -> float: ... @overload def distance(self, x: float, y: float) -> float: ... @overload def towards(self, x: Union[TNavigator, Tuple[float, float]], y: None = ...) -> float: ... @overload def towards(self, x: float, y: float) -> float: ... def heading(self) -> float: ... def setheading(self, to_angle: float) -> None: ... def circle(self, radius: float, extent: Optional[float] = ..., steps: Optional[int] = ...) -> None: ... fd = forward bk = back backward = back rt = right lt = left position = pos setpos = goto setposition = goto seth = setheading class TPen(object): def __init__(self, resizemode: str = ...) -> None: ... @overload def resizemode(self, rmode: None = ...) -> str: ... @overload def resizemode(self, rmode: str) -> None: ... @overload def pensize(self, width: None = ...) -> int: ... @overload def pensize(self, width: int) -> None: ... def penup(self) -> None: ... def pendown(self) -> None: ... def isdown(self) -> bool: ... @overload def speed(self, speed: None = ...) -> int: ... @overload def speed(self, speed: _Speed) -> None: ... @overload def pencolor(self) -> _AnyColor: ... @overload def pencolor(self, color: _Color) -> None: ... @overload def pencolor(self, r: float, g: float, b: float) -> None: ... @overload def fillcolor(self) -> _AnyColor: ... @overload def fillcolor(self, color: _Color) -> None: ... @overload def fillcolor(self, r: float, g: float, b: float) -> None: ... @overload def color(self) -> Tuple[_AnyColor, _AnyColor]: ... @overload def color(self, color: _Color) -> None: ... @overload def color(self, r: float, g: float, b: float) -> None: ... @overload def color(self, color1: _Color, color2: _Color) -> None: ... def showturtle(self) -> None: ... def hideturtle(self) -> None: ... def isvisible(self) -> bool: ... # Note: signatures 1 and 2 overlap unsafely when no arguments are provided @overload def pen(self) -> _PenState: ... # type: ignore @overload def pen( self, pen: Optional[_PenState] = ..., *, shown: bool = ..., pendown: bool = ..., pencolor: _Color = ..., fillcolor: _Color = ..., pensize: int = ..., speed: int = ..., resizemode: str = ..., stretchfactor: Tuple[float, float] = ..., outline: int = ..., tilt: float = ..., ) -> None: ... width = pensize up = penup pu = penup pd = pendown down = pendown st = showturtle ht = hideturtle _T = TypeVar("_T") class RawTurtle(TPen, TNavigator): def __init__( self, canvas: Union[Canvas, TurtleScreen, None] = ..., shape: str = ..., undobuffersize: int = ..., visible: bool = ... ) -> None: ... def reset(self) -> None: ... def setundobuffer(self, size: Optional[int]) -> None: ... def undobufferentries(self) -> int: ... def clear(self) -> None: ... def clone(self: _T) -> _T: ... @overload def shape(self, name: None = ...) -> str: ... @overload def shape(self, name: str) -> None: ... # Unsafely overlaps when no arguments are provided @overload def shapesize(self) -> Tuple[float, float, float]: ... # type: ignore @overload def shapesize( self, stretch_wid: Optional[float] = ..., stretch_len: Optional[float] = ..., outline: Optional[float] = ... ) -> None: ... if sys.version_info >= (3,): @overload def shearfactor(self, shear: None = ...) -> float: ... @overload def shearfactor(self, shear: float) -> None: ... # Unsafely overlaps when no arguments are provided @overload def shapetransform(self) -> Tuple[float, float, float, float]: ... # type: ignore @overload def shapetransform( self, t11: Optional[float] = ..., t12: Optional[float] = ..., t21: Optional[float] = ..., t22: Optional[float] = ... ) -> None: ... def get_shapepoly(self) -> Optional[_PolygonCoords]: ... def settiltangle(self, angle: float) -> None: ... @overload def tiltangle(self, angle: None = ...) -> float: ... @overload def tiltangle(self, angle: float) -> None: ... def tilt(self, angle: float) -> None: ... # Can return either 'int' or Tuple[int, ...] based on if the stamp is # a compound stamp or not. So, as per the "no Union return" policy, # we return Any. def stamp(self) -> Any: ... def clearstamp(self, stampid: Union[int, Tuple[int, ...]]) -> None: ... def clearstamps(self, n: Optional[int] = ...) -> None: ... def filling(self) -> bool: ... def begin_fill(self) -> None: ... def end_fill(self) -> None: ... def dot(self, size: Optional[int] = ..., *color: _Color) -> None: ... def write(self, arg: object, move: bool = ..., align: str = ..., font: Tuple[str, int, str] = ...) -> None: ... def begin_poly(self) -> None: ... def end_poly(self) -> None: ... def get_poly(self) -> Optional[_PolygonCoords]: ... def getscreen(self) -> TurtleScreen: ... def getturtle(self: _T) -> _T: ... getpen = getturtle def onclick(self, fun: Callable[[float, float], Any], btn: int = ..., add: Optional[bool] = ...) -> None: ... def onrelease(self, fun: Callable[[float, float], Any], btn: int = ..., add: Optional[bool] = ...) -> None: ... def ondrag(self, fun: Callable[[float, float], Any], btn: int = ..., add: Optional[bool] = ...) -> None: ... def undo(self) -> None: ... turtlesize = shapesize class _Screen(TurtleScreen): def __init__(self) -> None: ... # Note int and float are interpreted differently, hence the Union instead of just float def setup( self, width: Union[int, float] = ..., height: Union[int, float] = ..., startx: Optional[int] = ..., starty: Optional[int] = ..., ) -> None: ... def title(self, titlestring: str) -> None: ... def bye(self) -> None: ... def exitonclick(self) -> None: ... def Screen() -> _Screen: ... class Turtle(RawTurtle): def __init__(self, shape: str = ..., undobuffersize: int = ..., visible: bool = ...) -> None: ... RawPen = RawTurtle Pen = Turtle def write_docstringdict(filename: str = ...) -> None: ... # Note: it's somewhat unfortunate that we have to copy the function signatures. # It would be nice if we could partially reduce the redundancy by doing something # like the following: # # _screen: Screen # clear = _screen.clear # # However, it seems pytype does not support this type of syntax in pyi files. # Functions copied from TurtleScreenBase: # Note: mainloop() was always present in the global scope, but was added to # TurtleScreenBase in Python 3.0 def mainloop() -> None: ... if sys.version_info >= (3,): def textinput(title: str, prompt: str) -> Optional[str]: ... def numinput( title: str, prompt: str, default: Optional[float] = ..., minval: Optional[float] = ..., maxval: Optional[float] = ... ) -> Optional[float]: ... # Functions copied from TurtleScreen: def clear() -> None: ... @overload def mode(mode: None = ...) -> str: ... @overload def mode(mode: str) -> None: ... def setworldcoordinates(llx: float, lly: float, urx: float, ury: float) -> None: ... def register_shape(name: str, shape: Union[_PolygonCoords, Shape, None] = ...) -> None: ... @overload def colormode(cmode: None = ...) -> float: ... @overload def colormode(cmode: float) -> None: ... def reset() -> None: ... def turtles() -> List[Turtle]: ... @overload def bgcolor() -> _AnyColor: ... @overload def bgcolor(color: _Color) -> None: ... @overload def bgcolor(r: float, g: float, b: float) -> None: ... @overload def tracer(n: None = ...) -> int: ... @overload def tracer(n: int, delay: Optional[int] = ...) -> None: ... @overload def delay(delay: None = ...) -> int: ... @overload def delay(delay: int) -> None: ... def update() -> None: ... def window_width() -> int: ... def window_height() -> int: ... def getcanvas() -> Canvas: ... def getshapes() -> List[str]: ... def onclick(fun: Callable[[float, float], Any], btn: int = ..., add: Optional[Any] = ...) -> None: ... def onkey(fun: Callable[[], Any], key: str) -> None: ... def listen(xdummy: Optional[float] = ..., ydummy: Optional[float] = ...) -> None: ... def ontimer(fun: Callable[[], Any], t: int = ...) -> None: ... @overload def bgpic(picname: None = ...) -> str: ... @overload def bgpic(picname: str) -> None: ... @overload def screensize(canvwidth: None = ..., canvheight: None = ..., bg: None = ...) -> Tuple[int, int]: ... @overload def screensize(canvwidth: int, canvheight: int, bg: Optional[_Color] = ...) -> None: ... onscreenclick = onclick resetscreen = reset clearscreen = clear addshape = register_shape if sys.version_info >= (3,): def onkeypress(fun: Callable[[], Any], key: Optional[str] = ...) -> None: ... onkeyrelease = onkey # Functions copied from TNavigator: def degrees(fullcircle: float = ...) -> None: ... def radians() -> None: ... def forward(distance: float) -> None: ... def back(distance: float) -> None: ... def right(angle: float) -> None: ... def left(angle: float) -> None: ... def pos() -> Vec2D: ... def xcor() -> float: ... def ycor() -> float: ... @overload def goto(x: Tuple[float, float], y: None = ...) -> None: ... @overload def goto(x: float, y: float) -> None: ... def home() -> None: ... def setx(x: float) -> None: ... def sety(y: float) -> None: ... @overload def distance(x: Union[TNavigator, Tuple[float, float]], y: None = ...) -> float: ... @overload def distance(x: float, y: float) -> float: ... @overload def towards(x: Union[TNavigator, Tuple[float, float]], y: None = ...) -> float: ... @overload def towards(x: float, y: float) -> float: ... def heading() -> float: ... def setheading(to_angle: float) -> None: ... def circle(radius: float, extent: Optional[float] = ..., steps: Optional[int] = ...) -> None: ... fd = forward bk = back backward = back rt = right lt = left position = pos setpos = goto setposition = goto seth = setheading # Functions copied from TPen: @overload def resizemode(rmode: None = ...) -> str: ... @overload def resizemode(rmode: str) -> None: ... @overload def pensize(width: None = ...) -> int: ... @overload def pensize(width: int) -> None: ... def penup() -> None: ... def pendown() -> None: ... def isdown() -> bool: ... @overload def speed(speed: None = ...) -> int: ... @overload def speed(speed: _Speed) -> None: ... @overload def pencolor() -> _AnyColor: ... @overload def pencolor(color: _Color) -> None: ... @overload def pencolor(r: float, g: float, b: float) -> None: ... @overload def fillcolor() -> _AnyColor: ... @overload def fillcolor(color: _Color) -> None: ... @overload def fillcolor(r: float, g: float, b: float) -> None: ... @overload def color() -> Tuple[_AnyColor, _AnyColor]: ... @overload def color(color: _Color) -> None: ... @overload def color(r: float, g: float, b: float) -> None: ... @overload def color(color1: _Color, color2: _Color) -> None: ... def showturtle() -> None: ... def hideturtle() -> None: ... def isvisible() -> bool: ... # Note: signatures 1 and 2 overlap unsafely when no arguments are provided @overload def pen() -> _PenState: ... # type: ignore @overload def pen( pen: Optional[_PenState] = ..., *, shown: bool = ..., pendown: bool = ..., pencolor: _Color = ..., fillcolor: _Color = ..., pensize: int = ..., speed: int = ..., resizemode: str = ..., stretchfactor: Tuple[float, float] = ..., outline: int = ..., tilt: float = ..., ) -> None: ... width = pensize up = penup pu = penup pd = pendown down = pendown st = showturtle ht = hideturtle # Functions copied from RawTurtle: def setundobuffer(size: Optional[int]) -> None: ... def undobufferentries() -> int: ... @overload def shape(name: None = ...) -> str: ... @overload def shape(name: str) -> None: ... # Unsafely overlaps when no arguments are provided @overload def shapesize() -> Tuple[float, float, float]: ... # type: ignore @overload def shapesize(stretch_wid: Optional[float] = ..., stretch_len: Optional[float] = ..., outline: Optional[float] = ...) -> None: ... if sys.version_info >= (3,): @overload def shearfactor(shear: None = ...) -> float: ... @overload def shearfactor(shear: float) -> None: ... # Unsafely overlaps when no arguments are provided @overload def shapetransform() -> Tuple[float, float, float, float]: ... # type: ignore @overload def shapetransform( t11: Optional[float] = ..., t12: Optional[float] = ..., t21: Optional[float] = ..., t22: Optional[float] = ... ) -> None: ... def get_shapepoly() -> Optional[_PolygonCoords]: ... def settiltangle(angle: float) -> None: ... @overload def tiltangle(angle: None = ...) -> float: ... @overload def tiltangle(angle: float) -> None: ... def tilt(angle: float) -> None: ... # Can return either 'int' or Tuple[int, ...] based on if the stamp is # a compound stamp or not. So, as per the "no Union return" policy, # we return Any. def stamp() -> Any: ... def clearstamp(stampid: Union[int, Tuple[int, ...]]) -> None: ... def clearstamps(n: Optional[int] = ...) -> None: ... def filling() -> bool: ... def begin_fill() -> None: ... def end_fill() -> None: ... def dot(size: Optional[int] = ..., *color: _Color) -> None: ... def write(arg: object, move: bool = ..., align: str = ..., font: Tuple[str, int, str] = ...) -> None: ... def begin_poly() -> None: ... def end_poly() -> None: ... def get_poly() -> Optional[_PolygonCoords]: ... def getscreen() -> TurtleScreen: ... def getturtle() -> Turtle: ... getpen = getturtle def onrelease(fun: Callable[[float, float], Any], btn: int = ..., add: Optional[Any] = ...) -> None: ... def ondrag(fun: Callable[[float, float], Any], btn: int = ..., add: Optional[Any] = ...) -> None: ... def undo() -> None: ... turtlesize = shapesize # Functions copied from RawTurtle with a few tweaks: def clone() -> Turtle: ... # Extra functions present only in the global scope: done = mainloop
19,476
Python
.py
514
34.167315
130
0.600328
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,089
tabnanny.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/tabnanny.pyi
from _typeshed import AnyPath from typing import Iterable, Tuple verbose: int filename_only: int class NannyNag(Exception): def __init__(self, lineno: int, msg: str, line: str) -> None: ... def get_lineno(self) -> int: ... def get_msg(self) -> str: ... def get_line(self) -> str: ... def check(file: AnyPath) -> None: ... def process_tokens(tokens: Iterable[Tuple[int, str, Tuple[int, int], Tuple[int, int], str]]) -> None: ...
447
Python
.py
11
37.909091
105
0.65358
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,090
filecmp.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/filecmp.pyi
import sys from typing import Any, AnyStr, Callable, Dict, Generic, Iterable, List, Optional, Sequence, Text, Tuple, Union if sys.version_info >= (3, 6): from os import PathLike if sys.version_info >= (3, 9): from types import GenericAlias DEFAULT_IGNORES: List[str] if sys.version_info >= (3, 6): def cmp( f1: Union[bytes, Text, PathLike[AnyStr]], f2: Union[bytes, Text, PathLike[AnyStr]], shallow: Union[int, bool] = ... ) -> bool: ... def cmpfiles( a: Union[AnyStr, PathLike[AnyStr]], b: Union[AnyStr, PathLike[AnyStr]], common: Iterable[AnyStr], shallow: Union[int, bool] = ..., ) -> Tuple[List[AnyStr], List[AnyStr], List[AnyStr]]: ... else: def cmp(f1: Union[bytes, Text], f2: Union[bytes, Text], shallow: Union[int, bool] = ...) -> bool: ... def cmpfiles( a: AnyStr, b: AnyStr, common: Iterable[AnyStr], shallow: Union[int, bool] = ... ) -> Tuple[List[AnyStr], List[AnyStr], List[AnyStr]]: ... class dircmp(Generic[AnyStr]): if sys.version_info >= (3, 6): def __init__( self, a: Union[AnyStr, PathLike[AnyStr]], b: Union[AnyStr, PathLike[AnyStr]], ignore: Optional[Sequence[AnyStr]] = ..., hide: Optional[Sequence[AnyStr]] = ..., ) -> None: ... else: def __init__( self, a: AnyStr, b: AnyStr, ignore: Optional[Sequence[AnyStr]] = ..., hide: Optional[Sequence[AnyStr]] = ... ) -> None: ... left: AnyStr right: AnyStr hide: Sequence[AnyStr] ignore: Sequence[AnyStr] # These properties are created at runtime by __getattr__ subdirs: Dict[AnyStr, dircmp[AnyStr]] same_files: List[AnyStr] diff_files: List[AnyStr] funny_files: List[AnyStr] common_dirs: List[AnyStr] common_files: List[AnyStr] common_funny: List[AnyStr] common: List[AnyStr] left_only: List[AnyStr] right_only: List[AnyStr] left_list: List[AnyStr] right_list: List[AnyStr] def report(self) -> None: ... def report_partial_closure(self) -> None: ... def report_full_closure(self) -> None: ... methodmap: Dict[str, Callable[[], None]] def phase0(self) -> None: ... def phase1(self) -> None: ... def phase2(self) -> None: ... def phase3(self) -> None: ... def phase4(self) -> None: ... def phase4_closure(self) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... if sys.version_info >= (3,): def clear_cache() -> None: ...
2,566
Python
.py
66
32.924242
123
0.601685
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,091
__future__.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/__future__.pyi
import sys from typing import List class _Feature: def getOptionalRelease(self) -> sys._version_info: ... def getMandatoryRelease(self) -> sys._version_info: ... compiler_flag: int absolute_import: _Feature division: _Feature generators: _Feature nested_scopes: _Feature print_function: _Feature unicode_literals: _Feature with_statement: _Feature if sys.version_info >= (3, 0): barry_as_FLUFL: _Feature if sys.version_info >= (3, 5): generator_stop: _Feature if sys.version_info >= (3, 7): annotations: _Feature all_feature_names: List[str] # undocumented
587
Python
.py
20
26.9
59
0.736655
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,092
pty.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/pty.pyi
import sys from typing import Callable, Iterable, Tuple, Union _Reader = Callable[[int], bytes] STDIN_FILENO: int STDOUT_FILENO: int STDERR_FILENO: int CHILD: int def openpty() -> Tuple[int, int]: ... def master_open() -> Tuple[int, str]: ... def slave_open(tty_name: str) -> int: ... def fork() -> Tuple[int, int]: ... if sys.version_info >= (3, 4): def spawn(argv: Union[str, Iterable[str]], master_read: _Reader = ..., stdin_read: _Reader = ...) -> int: ... else: def spawn(argv: Union[str, Iterable[str]], master_read: _Reader = ..., stdin_read: _Reader = ...) -> None: ...
592
Python
.py
15
37.533333
114
0.640981
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,093
_weakrefset.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/_weakrefset.pyi
import sys from typing import Any, Generic, Iterable, Iterator, MutableSet, Optional, TypeVar, Union if sys.version_info >= (3, 9): from types import GenericAlias _S = TypeVar("_S") _T = TypeVar("_T") _SelfT = TypeVar("_SelfT", bound=WeakSet[Any]) class WeakSet(MutableSet[_T], Generic[_T]): def __init__(self, data: Optional[Iterable[_T]] = ...) -> None: ... def add(self, item: _T) -> None: ... def clear(self) -> None: ... def discard(self, item: _T) -> None: ... def copy(self: _SelfT) -> _SelfT: ... def pop(self) -> _T: ... def remove(self, item: _T) -> None: ... def update(self, other: Iterable[_T]) -> None: ... def __contains__(self, item: object) -> bool: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_T]: ... def __ior__(self, other: Iterable[_S]) -> WeakSet[Union[_S, _T]]: ... def difference(self: _SelfT, other: Iterable[_T]) -> _SelfT: ... def __sub__(self: _SelfT, other: Iterable[_T]) -> _SelfT: ... def difference_update(self: _SelfT, other: Iterable[_T]) -> None: ... def __isub__(self: _SelfT, other: Iterable[_T]) -> _SelfT: ... def intersection(self: _SelfT, other: Iterable[_T]) -> _SelfT: ... def __and__(self: _SelfT, other: Iterable[_T]) -> _SelfT: ... def intersection_update(self, other: Iterable[_T]) -> None: ... def __iand__(self: _SelfT, other: Iterable[_T]) -> _SelfT: ... def issubset(self, other: Iterable[_T]) -> bool: ... def __le__(self, other: Iterable[_T]) -> bool: ... def __lt__(self, other: Iterable[_T]) -> bool: ... def issuperset(self, other: Iterable[_T]) -> bool: ... def __ge__(self, other: Iterable[_T]) -> bool: ... def __gt__(self, other: Iterable[_T]) -> bool: ... def __eq__(self, other: object) -> bool: ... def symmetric_difference(self, other: Iterable[_S]) -> WeakSet[Union[_S, _T]]: ... def __xor__(self, other: Iterable[_S]) -> WeakSet[Union[_S, _T]]: ... def symmetric_difference_update(self, other: Iterable[_S]) -> None: ... def __ixor__(self, other: Iterable[_S]) -> WeakSet[Union[_S, _T]]: ... def union(self, other: Iterable[_S]) -> WeakSet[Union[_S, _T]]: ... def __or__(self, other: Iterable[_S]) -> WeakSet[Union[_S, _T]]: ... def isdisjoint(self, other: Iterable[_T]) -> bool: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ...
2,417
Python
.py
44
50.409091
89
0.567511
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,094
smtpd.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/smtpd.pyi
import asynchat import asyncore import socket import sys from typing import Any, DefaultDict, List, Optional, Text, Tuple, Type _Address = Tuple[str, int] # (host, port) class SMTPChannel(asynchat.async_chat): COMMAND: int DATA: int if sys.version_info >= (3,): command_size_limits: DefaultDict[str, int] smtp_server: SMTPServer conn: socket.socket addr: Any received_lines: List[Text] smtp_state: int seen_greeting: str mailfrom: str rcpttos: List[str] received_data: str fqdn: str peer: str command_size_limit: int data_size_limit: int enable_SMTPUTF8: bool @property def max_command_size_limit(self) -> int: ... if sys.version_info >= (3,): def __init__( self, server: SMTPServer, conn: socket.socket, addr: Any, data_size_limit: int = ..., map: Optional[asyncore._maptype] = ..., enable_SMTPUTF8: bool = ..., decode_data: bool = ..., ) -> None: ... else: def __init__(self, server: SMTPServer, conn: socket.socket, addr: Any, data_size_limit: int = ...) -> None: ... # base asynchat.async_chat.push() accepts bytes def push(self, msg: Text) -> None: ... # type: ignore def collect_incoming_data(self, data: bytes) -> None: ... def found_terminator(self) -> None: ... def smtp_HELO(self, arg: str) -> None: ... def smtp_NOOP(self, arg: str) -> None: ... def smtp_QUIT(self, arg: str) -> None: ... def smtp_MAIL(self, arg: str) -> None: ... def smtp_RCPT(self, arg: str) -> None: ... def smtp_RSET(self, arg: str) -> None: ... def smtp_DATA(self, arg: str) -> None: ... if sys.version_info >= (3, 3): def smtp_EHLO(self, arg: str) -> None: ... def smtp_HELP(self, arg: str) -> None: ... def smtp_VRFY(self, arg: str) -> None: ... def smtp_EXPN(self, arg: str) -> None: ... class SMTPServer(asyncore.dispatcher): channel_class: Type[SMTPChannel] data_size_limit: int enable_SMTPUTF8: bool if sys.version_info >= (3,): def __init__( self, localaddr: _Address, remoteaddr: _Address, data_size_limit: int = ..., map: Optional[asyncore._maptype] = ..., enable_SMTPUTF8: bool = ..., decode_data: bool = ..., ) -> None: ... else: def __init__(self, localaddr: _Address, remoteaddr: _Address, data_size_limit: int = ...) -> None: ... def handle_accepted(self, conn: socket.socket, addr: Any) -> None: ... def process_message(self, peer: _Address, mailfrom: str, rcpttos: List[Text], data: str, **kwargs: Any) -> Optional[str]: ... class DebuggingServer(SMTPServer): ... class PureProxy(SMTPServer): ... class MailmanProxy(PureProxy): ...
2,935
Python
.py
77
30.61039
129
0.570727
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,095
errno.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/errno.pyi
from typing import Mapping errorcode: Mapping[int, str] EPERM: int ENOENT: int ESRCH: int EINTR: int EIO: int ENXIO: int E2BIG: int ENOEXEC: int EBADF: int ECHILD: int EAGAIN: int ENOMEM: int EACCES: int EFAULT: int ENOTBLK: int EBUSY: int EEXIST: int EXDEV: int ENODEV: int ENOTDIR: int EISDIR: int EINVAL: int ENFILE: int EMFILE: int ENOTTY: int ETXTBSY: int EFBIG: int ENOSPC: int ESPIPE: int EROFS: int EMLINK: int EPIPE: int EDOM: int ERANGE: int EDEADLCK: int ENAMETOOLONG: int ENOLCK: int ENOSYS: int ENOTEMPTY: int ELOOP: int EWOULDBLOCK: int ENOMSG: int EIDRM: int ECHRNG: int EL2NSYNC: int EL3HLT: int EL3RST: int ELNRNG: int EUNATCH: int ENOCSI: int EL2HLT: int EBADE: int EBADR: int EXFULL: int ENOANO: int EBADRQC: int EBADSLT: int EDEADLOCK: int EBFONT: int ENOSTR: int ENODATA: int ETIME: int ENOSR: int ENONET: int ENOPKG: int EREMOTE: int ENOLINK: int EADV: int ESRMNT: int ECOMM: int EPROTO: int EMULTIHOP: int EDOTDOT: int EBADMSG: int EOVERFLOW: int ENOTUNIQ: int EBADFD: int EREMCHG: int ELIBACC: int ELIBBAD: int ELIBSCN: int ELIBMAX: int ELIBEXEC: int EILSEQ: int ERESTART: int ESTRPIPE: int EUSERS: int ENOTSOCK: int EDESTADDRREQ: int EMSGSIZE: int EPROTOTYPE: int ENOPROTOOPT: int EPROTONOSUPPORT: int ESOCKTNOSUPPORT: int ENOTSUP: int EOPNOTSUPP: int EPFNOSUPPORT: int EAFNOSUPPORT: int EADDRINUSE: int EADDRNOTAVAIL: int ENETDOWN: int ENETUNREACH: int ENETRESET: int ECONNABORTED: int ECONNRESET: int ENOBUFS: int EISCONN: int ENOTCONN: int ESHUTDOWN: int ETOOMANYREFS: int ETIMEDOUT: int ECONNREFUSED: int EHOSTDOWN: int EHOSTUNREACH: int EALREADY: int EINPROGRESS: int ESTALE: int EUCLEAN: int ENOTNAM: int ENAVAIL: int EISNAM: int EREMOTEIO: int EDQUOT: int ECANCELED: int # undocumented EKEYEXPIRED: int # undocumented EKEYREJECTED: int # undocumented EKEYREVOKED: int # undocumented EMEDIUMTYPE: int # undocumented ENOKEY: int # undocumented ENOMEDIUM: int # undocumented ENOTRECOVERABLE: int # undocumented EOWNERDEAD: int # undocumented ERFKILL: int # undocumented
2,011
Python
.py
135
13.881481
36
0.83191
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,096
aifc.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/aifc.pyi
import sys from types import TracebackType from typing import IO, Any, List, NamedTuple, Optional, Text, Tuple, Type, Union, overload from typing_extensions import Literal class Error(Exception): ... class _aifc_params(NamedTuple): nchannels: int sampwidth: int framerate: int nframes: int comptype: bytes compname: bytes _File = Union[Text, IO[bytes]] _Marker = Tuple[int, int, bytes] class Aifc_read: def __init__(self, f: _File) -> None: ... if sys.version_info >= (3, 4): def __enter__(self) -> Aifc_read: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... def initfp(self, file: IO[bytes]) -> None: ... def getfp(self) -> IO[bytes]: ... def rewind(self) -> None: ... def close(self) -> None: ... def tell(self) -> int: ... def getnchannels(self) -> int: ... def getnframes(self) -> int: ... def getsampwidth(self) -> int: ... def getframerate(self) -> int: ... def getcomptype(self) -> bytes: ... def getcompname(self) -> bytes: ... def getparams(self) -> _aifc_params: ... def getmarkers(self) -> Optional[List[_Marker]]: ... def getmark(self, id: int) -> _Marker: ... def setpos(self, pos: int) -> None: ... def readframes(self, nframes: int) -> bytes: ... class Aifc_write: def __init__(self, f: _File) -> None: ... def __del__(self) -> None: ... if sys.version_info >= (3, 4): def __enter__(self) -> Aifc_write: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... def initfp(self, file: IO[bytes]) -> None: ... def aiff(self) -> None: ... def aifc(self) -> None: ... def setnchannels(self, nchannels: int) -> None: ... def getnchannels(self) -> int: ... def setsampwidth(self, sampwidth: int) -> None: ... def getsampwidth(self) -> int: ... def setframerate(self, framerate: int) -> None: ... def getframerate(self) -> int: ... def setnframes(self, nframes: int) -> None: ... def getnframes(self) -> int: ... def setcomptype(self, comptype: bytes, compname: bytes) -> None: ... def getcomptype(self) -> bytes: ... def getcompname(self) -> bytes: ... def setparams(self, params: Tuple[int, int, int, int, bytes, bytes]) -> None: ... def getparams(self) -> _aifc_params: ... def setmark(self, id: int, pos: int, name: bytes) -> None: ... def getmark(self, id: int) -> _Marker: ... def getmarkers(self) -> Optional[List[_Marker]]: ... def tell(self) -> int: ... def writeframesraw(self, data: Any) -> None: ... # Actual type for data is Buffer Protocol def writeframes(self, data: Any) -> None: ... def close(self) -> None: ... @overload def open(f: _File, mode: Literal["r", "rb"]) -> Aifc_read: ... @overload def open(f: _File, mode: Literal["w", "wb"]) -> Aifc_write: ... @overload def open(f: _File, mode: Optional[str] = ...) -> Any: ... if sys.version_info < (3, 9): @overload def openfp(f: _File, mode: Literal["r", "rb"]) -> Aifc_read: ... @overload def openfp(f: _File, mode: Literal["w", "wb"]) -> Aifc_write: ... @overload def openfp(f: _File, mode: Optional[str] = ...) -> Any: ...
3,393
Python
.py
81
37.148148
124
0.595159
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,097
macpath.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/macpath.pyi
import os import sys from _typeshed import AnyPath, BytesPath, StrPath from typing import Any, AnyStr, Callable, List, Optional, Sequence, Text, Tuple, TypeVar, Union, overload if sys.version_info < (3, 8): _T = TypeVar("_T") if sys.version_info >= (3, 6): from builtins import _PathLike # ----- os.path variables ----- supports_unicode_filenames: bool # aliases (also in os) curdir: str pardir: str sep: str altsep: Optional[str] extsep: str pathsep: str defpath: str devnull: str # ----- os.path function stubs ----- if sys.version_info >= (3, 6): # Overloads are necessary to work around python/mypy#3644. @overload def abspath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def abspath(path: AnyStr) -> AnyStr: ... @overload def basename(s: _PathLike[AnyStr]) -> AnyStr: ... @overload def basename(s: AnyStr) -> AnyStr: ... @overload def dirname(s: _PathLike[AnyStr]) -> AnyStr: ... @overload def dirname(s: AnyStr) -> AnyStr: ... @overload def expanduser(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def expanduser(path: AnyStr) -> AnyStr: ... @overload def expandvars(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def expandvars(path: AnyStr) -> AnyStr: ... @overload def normcase(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def normcase(path: AnyStr) -> AnyStr: ... @overload def normpath(s: _PathLike[AnyStr]) -> AnyStr: ... @overload def normpath(s: AnyStr) -> AnyStr: ... @overload def realpath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def realpath(path: AnyStr) -> AnyStr: ... else: def abspath(path: AnyStr) -> AnyStr: ... def basename(s: AnyStr) -> AnyStr: ... def dirname(s: AnyStr) -> AnyStr: ... def expanduser(path: AnyStr) -> AnyStr: ... def expandvars(path: AnyStr) -> AnyStr: ... def normcase(path: AnyStr) -> AnyStr: ... def normpath(s: AnyStr) -> AnyStr: ... def realpath(path: AnyStr) -> AnyStr: ... # NOTE: Empty lists results in '' (str) regardless of contained type. # Also, in Python 2 mixed sequences of Text and bytes results in either Text or bytes # So, fall back to Any def commonprefix(m: Sequence[AnyPath]) -> Any: ... if sys.version_info >= (3, 3): def exists(path: Union[AnyPath, int]) -> bool: ... else: def exists(path: AnyPath) -> bool: ... def lexists(path: AnyPath) -> bool: ... # These return float if os.stat_float_times() == True, # but int is a subclass of float. def getatime(filename: AnyPath) -> float: ... def getmtime(filename: AnyPath) -> float: ... def getctime(filename: AnyPath) -> float: ... def getsize(filename: AnyPath) -> int: ... def isabs(s: AnyPath) -> bool: ... def isfile(path: AnyPath) -> bool: ... def isdir(s: AnyPath) -> bool: ... def islink(s: AnyPath) -> bool: ... def ismount(s: AnyPath) -> bool: ... if sys.version_info < (3, 0): # Make sure signatures are disjunct, and allow combinations of bytes and unicode. # (Since Python 2 allows that, too) # Note that e.g. os.path.join("a", "b", "c", "d", u"e") will still result in # a type error. @overload def join(__p1: bytes, *p: bytes) -> bytes: ... @overload def join(__p1: bytes, __p2: bytes, __p3: bytes, __p4: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: bytes, __p3: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: Text, *p: AnyPath) -> Text: ... elif sys.version_info >= (3, 6): # Mypy complains that the signatures overlap, but things seem to behave correctly anyway. @overload def join(s: StrPath, *paths: StrPath) -> Text: ... @overload def join(s: BytesPath, *paths: BytesPath) -> bytes: ... else: def join(s: AnyStr, *paths: AnyStr) -> AnyStr: ... def samefile(f1: AnyPath, f2: AnyPath) -> bool: ... def sameopenfile(fp1: int, fp2: int) -> bool: ... def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ... if sys.version_info >= (3, 6): @overload def split(s: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def split(s: AnyStr) -> Tuple[AnyStr, AnyStr]: ... @overload def splitdrive(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... @overload def splitext(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... else: def split(s: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... if sys.version_info < (3,): def walk(path: AnyStr, visit: Callable[[_T, AnyStr, List[AnyStr]], Any], arg: _T) -> None: ...
5,330
Python
.py
128
34.265625
105
0.574067
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,098
numbers.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/numbers.pyi
# Note: these stubs are incomplete. The more complex type # signatures are currently omitted. import sys from abc import ABCMeta, abstractmethod from typing import Any, Optional, SupportsFloat, overload class Number(metaclass=ABCMeta): @abstractmethod def __hash__(self) -> int: ... class Complex(Number): @abstractmethod def __complex__(self) -> complex: ... if sys.version_info >= (3, 0): def __bool__(self) -> bool: ... else: def __nonzero__(self) -> bool: ... @property @abstractmethod def real(self) -> Any: ... @property @abstractmethod def imag(self) -> Any: ... @abstractmethod def __add__(self, other: Any) -> Any: ... @abstractmethod def __radd__(self, other: Any) -> Any: ... @abstractmethod def __neg__(self) -> Any: ... @abstractmethod def __pos__(self) -> Any: ... def __sub__(self, other: Any) -> Any: ... def __rsub__(self, other: Any) -> Any: ... @abstractmethod def __mul__(self, other: Any) -> Any: ... @abstractmethod def __rmul__(self, other: Any) -> Any: ... if sys.version_info < (3, 0): @abstractmethod def __div__(self, other): ... @abstractmethod def __rdiv__(self, other): ... @abstractmethod def __truediv__(self, other: Any) -> Any: ... @abstractmethod def __rtruediv__(self, other: Any) -> Any: ... @abstractmethod def __pow__(self, exponent: Any) -> Any: ... @abstractmethod def __rpow__(self, base: Any) -> Any: ... def __abs__(self) -> Real: ... def conjugate(self) -> Any: ... def __eq__(self, other: Any) -> bool: ... if sys.version_info < (3, 0): def __ne__(self, other: Any) -> bool: ... class Real(Complex, SupportsFloat): @abstractmethod def __float__(self) -> float: ... @abstractmethod def __trunc__(self) -> int: ... if sys.version_info >= (3, 0): @abstractmethod def __floor__(self) -> int: ... @abstractmethod def __ceil__(self) -> int: ... @abstractmethod @overload def __round__(self, ndigits: None = ...) -> int: ... @abstractmethod @overload def __round__(self, ndigits: int) -> Any: ... def __divmod__(self, other: Any) -> Any: ... def __rdivmod__(self, other: Any) -> Any: ... @abstractmethod def __floordiv__(self, other: Any) -> int: ... @abstractmethod def __rfloordiv__(self, other: Any) -> int: ... @abstractmethod def __mod__(self, other: Any) -> Any: ... @abstractmethod def __rmod__(self, other: Any) -> Any: ... @abstractmethod def __lt__(self, other: Any) -> bool: ... @abstractmethod def __le__(self, other: Any) -> bool: ... def __complex__(self) -> complex: ... @property def real(self) -> Any: ... @property def imag(self) -> Any: ... def conjugate(self) -> Any: ... class Rational(Real): @property @abstractmethod def numerator(self) -> int: ... @property @abstractmethod def denominator(self) -> int: ... def __float__(self) -> float: ... class Integral(Rational): if sys.version_info >= (3, 0): @abstractmethod def __int__(self) -> int: ... else: @abstractmethod def __long__(self) -> long: ... def __index__(self) -> int: ... @abstractmethod def __pow__(self, exponent: Any, modulus: Optional[Any] = ...) -> Any: ... @abstractmethod def __lshift__(self, other: Any) -> Any: ... @abstractmethod def __rlshift__(self, other: Any) -> Any: ... @abstractmethod def __rshift__(self, other: Any) -> Any: ... @abstractmethod def __rrshift__(self, other: Any) -> Any: ... @abstractmethod def __and__(self, other: Any) -> Any: ... @abstractmethod def __rand__(self, other: Any) -> Any: ... @abstractmethod def __xor__(self, other: Any) -> Any: ... @abstractmethod def __rxor__(self, other: Any) -> Any: ... @abstractmethod def __or__(self, other: Any) -> Any: ... @abstractmethod def __ror__(self, other: Any) -> Any: ... @abstractmethod def __invert__(self) -> Any: ... def __float__(self) -> float: ... @property def numerator(self) -> int: ... @property def denominator(self) -> int: ...
4,335
Python
.py
134
26.977612
78
0.555662
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)
29,099
nis.pyi
DamnWidget_anaconda/anaconda_lib/jedi/third_party/typeshed/stdlib/2and3/nis.pyi
import sys from typing import Dict, List if sys.platform != "win32": def cat(map: str, domain: str = ...) -> Dict[str, str]: ... def get_default_domain() -> str: ... def maps(domain: str = ...) -> List[str]: ... def match(key: str, map: str, domain: str = ...) -> str: ... class error(Exception): ...
322
Python
.py
8
36.625
64
0.56869
DamnWidget/anaconda
2,213
260
184
GPL-3.0
9/5/2024, 5:14:06 PM (Europe/Amsterdam)