Index

Modules: errno, inspect, inspect_impl/isX, inspect_impl/members, inspect_impl/modulename, inspect_impl/sourcegetters, n_errno, n_inspect, n_os, n_string, n_sys, os, platform, platform_impl/dos, platform_impl/unameAny, private/platformInfo, string, string_impl/capwordsImpl, string_impl/consts, string_impl/n_chainmap, string_impl/substituteImpl, string_impl/templateImpl, string_impl/template_decl, sys, sys_impl/Python/envutils, sys_impl/Python/localeutils, sys_impl/auditImpl, sys_impl/cmdlineCompat, sys_impl/exits, sys_impl/fenvs, sys_impl/flagsImpl, sys_impl/flagsImpl/config_read_env, sys_impl/flagsImpl/ct, sys_impl/flagsImpl/values, sys_impl/genargs, sys_impl/geninfos, sys_impl/genplatform, sys_impl/getencodings, sys_impl/getwindows, sys_impl/sizes, sys_impl/stdio, sys_impl/util, types, typing_impl/optional_obj, typing_impl/str_optional_obj.

API symbols

`$`:

• members: proc `$`(t: MemberType): string
• template_decl: proc `$`(self: Template): string

`[]`:

• n_chainmap: proc `[]`[K, V](self: ChainMap[K, V]; k: K): V

addaudithook:

• sys: template addaudithook(hook: HookProc)

allTrue:

• members: template allTrue(_): bool

argv:

• n_sys: var argv
• sys: var argv

ascii_letters:

• string: const ascii_letters
• consts: const ascii_letters

ascii_lowercase:

• string: const ascii_lowercase
• consts: const ascii_lowercase

ascii_uppercase:

• string: const ascii_uppercase
• consts: const ascii_uppercase

audit:

• sys: template audit(event: string; args: varargs[typed])

byteorder:

• n_sys: const byteorder
• sys: const byteorder

bytes_warning:

• ct: const bytes_warning

capwords:

• n_string: proc capwords(a: string): string
• n_string: proc capwords(a: string; sep: string): string
• string: proc capwords(a: StringLike): PyStr
• string: proc capwords(a: StringLike; _: NoneType): PyStr
• string: proc capwords(a: StringLike; sep: StringLike): PyStr

c_getenv:

• envutils: proc c_getenv(v: cstring): cstring

ChainMap:

• n_chainmap: object ChainMap

cleandoc:

• inspect: template cleandoc(obj: PyStr): PyStr
• n_inspect: proc cleandoc(s: string): string

close:

• os: template close(p: DirEntry)

contains:

• n_chainmap: proc contains[K, V](self: ChainMap[K, V]; k: K): bool

copyright:

• n_sys: const copyright
• sys: const copyright

cpu_count:

• os: proc cpu_count(): OptionalObj[int]

c_setlocale:

• localeutils: proc c_setlocale(category: cint; v: cstring): cstring

debug:

• ct: const debug
• values: let debug

Delimiter:

• substituteImpl: const Delimiter

delimiter:

• template_decl: method delimiter(self: Template): char

dev_mode:

• ct: const dev_mode
• values: let dev_mode

digits:

• string: const digits
• consts: const digits

dont_write_bytecode:

• ct: const dont_write_bytecode
• values: let dont_write_bytecode

executable:

• n_sys: template executable(): string
• sys: template executable(): PyStr

exit:

• sys: proc exit(x: NoneType)
• sys: proc exit[T](obj: T)
• exits: proc exit(c: int)
• exits: proc exit(s: string)

expOptObjCvt:

• optional_obj: template expOptObjCvt()

fields:

• ct: var fields

flags:

• flagsImpl: let flags

float_info:

• fenvs: const float_info

float_repr_style:

• sys: const float_repr_style
• fenvs: const float_repr_style

genArgs:

• genargs: template genArgs(St, Ls; S; lsCopy, lsOfCap)

genCapwords:

• capwordsImpl: template genCapwords(Arg, Res, split, split2, capitalize, strip)

genFlagsObj:

• ct: macro genFlagsObj()

gen_getmembers_static:

• members: template gen_getmembers_static(prag): untyped

genImplementation:

• geninfos: template genImplementation(S; cache_tag_val)
• geninfos: template genImplementation(S; cache_tag_val; Major, Minor, Patch, ReleaseLevel, Serial: typed)

genInfos:

• geninfos: template genInfos(S)

genPlatform:

• genplatform: template genPlatform(S)

genSubstitute:

• templateImpl: template genSubstitute(M; Key; sym; doExc)

getdefaultencoding:

• sys: proc getdefaultencoding(): PyStr
• getencodings: proc getdefaultencoding(): string

getdoc:

• inspect: template getdoc(obj: untyped): OptionalObj[PyStr]
• n_inspect: macro getdoc(obj: typed): string

getdocNoDedentImpl:

• sourcegetters: proc getdocNoDedentImpl(obj: NimNode): string

getfile:

• inspect: template getfile(obj: untyped): PyStr
• sourcegetters: macro getfile(obj: typed): string

getfilesystemencoding:

• sys: proc getfilesystemencoding(): PyStr
• getencodings: proc getfilesystemencoding(): string

GetIdent:

• substituteImpl: type GetIdent

get_identifiers:

• n_string: proc get_identifiers(templ: Template): seq[string]
• string: proc get_identifiers(templ: Template): PyList[PyStr]

getIdentifiers:

• substituteImpl: iterator getIdentifiers(templ: string): string

get_identifiersMayDup:

• templateImpl: iterator get_identifiersMayDup(templ: Template): string

getline:

• sourcegetters: macro getline(obj: typed): int

getmembers:

• inspect: iterator getmembers[T](obj: T): GetMemberType
• inspect: iterator getmembers[T](obj: T; predict: GetMembersPredict): GetMemberType
• inspect: template getmembers(obj): PyList
• inspect: template getmembers(obj; predict: GetMembersPredict): PyList
• members: iterator getmembers[T](obj: var T): GetMemberType
• members: iterator getmembers[T](obj: var T; predict: GetMembersPredict): GetMemberType
• members: template getmembers(obj): seq
• members: template getmembers(obj; predict: GetMembersPredict): seq

getmembersImpl:

• members: template getmembersImpl[R](obj; predict; initResult): R

GetMembersPredict:

• members: type GetMembersPredict

getmembers_static:

• inspect: template getmembers_static(obj): untyped
• inspect: template getmembers_static(obj; predict: GetMembersPredict): untyped
• members: template getmembers_static(obj): untyped
• members: template getmembers_static(obj; predict: GetMembersPredict): untyped

GetMembersType:

• members: type GetMembersType

GetMemberType:

• members: type GetMemberType

getmodulename:

• inspect: template getmodulename(obj: PyStr): OptionalObj[PyStr]
• n_inspect: proc getmodulename(obj: string): string

getmodulenameImpl:

• modulename: proc getmodulenameImpl(path: string; res: var string): bool

getPlatform:

• genplatform: proc getPlatform(): string

getrandom:

• os: proc getrandom(size: int; flags = 0): PyBytes

getsizeof:

• sizes: template getsizeof(x): int
• sizes: template getsizeof(x; default: int): int

getsource:

• inspect: template getsource(obj: untyped): PyStr
• sourcegetters: macro getsource(obj: typed): string

getsourcefile:

• inspect: template getsourcefile(obj: untyped): OptionalObj[PyStr]
• sourcegetters: template getsourcefile(obj: typed): string

getsourcelines:

• inspect: template getsourcelines(obj: typed): (PyList[PyStr], int)
• n_inspect: macro getsourcelines(obj: typed): (seq[string], int)

getsourcelinesImpl:

• sourcegetters: template getsourcelinesImpl(obj: NimNode; splitlines): untyped

handle:

• substituteImpl: template handle[M](s: SubsCfg; formatstr: string; m: M; lookup)

hash_randomization:

• ct: const hash_randomization

hexdigits:

• string: const hexdigits
• consts: const hexdigits

hexversion:

• n_sys: const hexversion
• sys: const hexversion

ib_b:

• config_read_env: proc ib_b(name: string; flagInit: bool): bool
• config_read_env: proc ib_b(name: string; flagInit: int): int

ib_e:

• config_read_env: proc ib_e[T](name: string; flagInit: T): T

ib_i:

• config_read_env: proc ib_i[T](name: string; flagInit: T): T

ignore_environment:

• ct: const ignore_environment

initChainMap:

• n_chainmap: proc initChainMap[K, V](a, b: Table[K, V]): ChainMap[K, V]

initIgnoreExcHandle:

• substituteImpl: proc initIgnoreExcHandle(): ExcHandle

initRaisesExcHandle:

• substituteImpl: proc initRaisesExcHandle(): ExcHandle

initSubsCfg:

• substituteImpl: proc initSubsCfg(excHandle = initRaisesExcHandle(); delimiter = Delimiter): SubsCfg

inspect:

• ct: const inspect
• values: let inspect

interactive:

• ct: const interactive

int_max_str_digits:

• ct: const int_max_str_digits
• values: let int_max_str_digits

isawaitable:

• inspect: template isawaitable(obj: typed): bool
• isX: template isawaitable(obj: typed): bool

isbuiltin:

• isX: macro isbuiltin(obj: typed): bool

isclass:

• isX: macro isclass(obj: typed): bool

iscoroutine:

• isX: macro iscoroutine(obj: typed): bool

iscoroutinefunction:

• inspect: template iscoroutinefunction(obj: typed): bool
• isX: macro iscoroutinefunction(obj: typed): bool

isframe:

• isX: template isframe(obj: typed): bool

isfunction:

• isX: macro isfunction(obj: typed): bool

ismethod:

• isX: macro ismethod(obj: typed): bool

ismodule:

• isX: macro ismodule(obj: typed): bool

isolated:

• ct: const isolated

istraceback:

• isX: template istraceback(obj: typed): bool

is_valid:

• string: proc is_valid(templ: Template): bool

isValid:

• substituteImpl: proc isValid(templ: string): bool

is_valid:

• templateImpl: proc is_valid(templ: Template): bool

LC_ALL:

• localeutils: let LC_ALL

LC_CTYPE:

• localeutils: let LC_CTYPE

machine:

• platform: proc machine(): PyStr

markcoroutinefunction:

• inspect: template markcoroutinefunction[T](obj: T): T
• isX: macro markcoroutinefunction[T](obj: T): T

maxsize:

• n_sys: const maxsize
• sys: const maxsize

newStrOptionalObj:

• str_optional_obj: proc newStrOptionalObj(x: string): OptionalObj[PyStr]

node:

• platform: proc node(): PyStr

no_site:

• ct: const no_site

no_user_site:

• ct: const no_user_site
• values: let no_user_site

octdigits:

• string: const octdigits
• consts: const octdigits

optimize:

• ct: const optimize
• values: let optimize

orig_argv:

• n_sys: var orig_argv
• sys: var orig_argv

platform:

• n_sys: const platform
• sys: const platform

printable:

• string: const printable
• consts: const printable

private_syscmd_ver:

• dos: proc private_syscmd_ver(system, release, version = ""; supported_platforms = @["win32", "win16", "dos"]): tuple[ system, release, version: string]

process_cpu_count:

• os: proc process_cpu_count(): OptionalObj[int]

processor:

• platform: proc processor(): PyStr

punctuation:

• string: const punctuation
• consts: const punctuation

Py_SetLocaleFromEnv:

• envutils: proc Py_SetLocaleFromEnv(category: cint): cstring

python_implementation:

• platform: proc python_implementation(): PyStr

quiet:

• ct: const quiet

redefineFlags:

• ct: macro redefineFlags(kws: varargs[untyped])

release:

• platform: proc release(): PyStr

resetSubsCfg:

• substituteImpl: proc resetSubsCfg(cfg: SubsCfg; excHandle = initRaisesExcHandle(); delimiter = Delimiter)

rounds:

• fenvs: template rounds(fi: typeof(float_info)): int

safe_path:

• ct: const safe_path
• values: let safe_path

safe_substitute:

• n_string: macro safe_substitute(templ: Template; mapping: Table; kws: varargs[untyped]): string
• n_string: macro safe_substitute(templ: Template; kws: varargs[untyped]): string
• string: macro safe_substitute(templ: Template; mapping: Mapping; kws: varargs[untyped]): PyStr
• string: macro safe_substitute(templ: Template; kws: varargs[untyped]): PyStr

scandir:

• os: template scandir(): untyped
• os: template scandir(p: int): untyped
• os: template scandir[T](p: PathLike[T]): untyped

setenvOverwrite:

• envutils: proc setenvOverwrite(key, val: string): bool

setlocale:

• localeutils: template setlocale(category; v: string): cstring

Subs:

• substituteImpl: type Subs

SubsCfg:

• substituteImpl: type SubsCfg

substitute:

• n_string: macro substitute(templ: Template; mapping: Table; kws: varargs[untyped]): string
• n_string: macro substitute(templ: Template; kws: varargs[untyped]): string
• string: macro substitute(templ: Template; mapping: Mapping; kws: varargs[untyped]): PyStr
• string: macro substitute(templ: Template; kws: varargs[untyped]): PyStr

substituteAux:

• substituteImpl: proc substituteAux[M](templ: string; m: M; excHandle = initRaisesExcHandle(); delimiter = Delimiter): string

system:

• platform: proc system(): PyStr

Template:

• template_decl: type Template
• templateImpl: proc Template(s: string): Template

toPyEnv:

• config_read_env: proc toPyEnv(name: string): string

uname:

• os: proc uname(): uname_result
• unameAny: proc uname(): UnameResult

uname_result:

• os: tuple uname_result

urandom:

• os: proc urandom(size: int): PyBytes

utf8_mode:

• ct: const utf8_mode
• values: let utf8_mode

verbose:

• ct: const verbose
• values: let verbose

version:

• n_sys: const version
• platform: proc version(): PyStr
• sys: const version

version_info:

• n_sys: const version_info
• sys: const version_info

warn_default_encoding:

• ct: const warn_default_encoding
• values: let warn_default_encoding

weirdTarget:

• util: const weirdTarget

whitespace:

• string: const whitespace
• consts: const whitespace