Skip to content

Instantly share code, notes, and snippets.

@Vizonex

Vizonex/ExprNodes.pyi

Created June 28, 2023 19:09
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save Vizonex/58f412067403975be3450bdd0b91298f to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save Vizonex/58f412067403975be3450bdd0b91298f to your computer and use it in GitHub Desktop.
Download ZIP
These are some typehints I'm having to work with the Cython Compiler because of how bad it is to access a hover list in VS Code... I'm also showing also this to act as a wake-up call...
Raw
ExprNodes.pyi
# NOTE "Some of these had to be manually added since stubgen in mypy doesn't even know that some of these items even exist." - Vizonex
# -- ExprNodes.pyi --
from Cython.Compiler import Builtin as Builtin, Future as Future, Naming as Naming, Nodes as Nodes, PyrexTypes as PyrexTypes, StringEncoding as StringEncoding, Symtab as Symtab, TypeSlots as TypeSlots
from Cython import Utils as Utils
from Cython.Debugging import print_call_chain as print_call_chain
from Cython.Compiler.Annotate import AnnotationItem as AnnotationItem
from Cython.Compiler.Builtin import basestring_type as basestring_type, bytearray_type as bytearray_type, bytes_type as bytes_type, dict_type as dict_type, list_type as list_type, set_type as set_type, slice_type as slice_type, str_type as str_type, tuple_type as tuple_type, type_type as type_type, unicode_type as unicode_type
from Cython.Compiler.Code import TempitaUtilityCode as TempitaUtilityCode, UtilityCode as UtilityCode
from Cython.Compiler.DebugFlags import debug_coercion as debug_coercion, debug_disposal_code as debug_disposal_code, debug_temp_alloc as debug_temp_alloc
from Cython.Compiler.Errors import CompileError as CompileError, InternalError as InternalError, error as error, local_errors as local_errors, report_error as report_error, warning as warning
from Cython.Compiler.Nodes import Node as Node, analyse_type_annotation as analyse_type_annotation, utility_code_for_imports as utility_code_for_imports
from Cython.Compiler.PyrexTypes import PythranExpr as PythranExpr, c_long_type as c_long_type, error_type as error_type, py_object_type as py_object_type, typecast as typecast, unspecified_type as unspecified_type
from Cython.Compiler.Pythran import has_np_pythran as has_np_pythran, is_pythran_expr as is_pythran_expr, is_pythran_supported_node_or_none as is_pythran_supported_node_or_none, is_pythran_supported_operation_type as is_pythran_supported_operation_type, is_pythran_supported_type as is_pythran_supported_type, pythran_binop_type as pythran_binop_type, pythran_func_type as pythran_func_type, pythran_functor as pythran_functor, pythran_get_func_include_file as pythran_get_func_include_file, pythran_indexing_code as pythran_indexing_code, pythran_indexing_type as pythran_indexing_type, pythran_is_numpy_func_supported as pythran_is_numpy_func_supported, pythran_type as pythran_type, pythran_unaryop_type as pythran_unaryop_type, to_pythran as to_pythran
from _typeshed import Incomplete
basestring = str
any_string_type: Incomplete
IS_PYTHON3: bool
class NotConstant:
def __new__(cls): ...
not_a_constant: Incomplete
constant_value_not_set: Incomplete
coercion_error_dict: Incomplete
def find_coercion_error(type_tuple, default, env): ...
def default_str_type(env): ...
def check_negative_indices(*nodes) -> None: ...
def infer_sequence_item_type(env, seq_node, index_node: Incomplete | None = ..., seq_type: Incomplete | None = ...): ...
def make_dedup_key(outer_type, item_nodes): ...
def get_exception_handler(exception_value): ...
def maybe_check_py_error(code, check_py_exception, pos, nogil) -> None: ...
def translate_cpp_exception(code, pos, inside, py_result, exception_value, nogil) -> None: ...
def translate_double_cpp_exception(code, pos, lhs_type, lhs_code, rhs_code, lhs_exc_val, assign_exc_val, nogil) -> None: ...
class ExprNode(Node):
name: str
result_ctype: str
type: PyrexTypes.PyrexType
annotation: ExprNode | None
temp_code: Incomplete
old_temp: Incomplete
use_managed_ref: bool
result_is_used: bool
is_numpy_attribute: bool
is_sequence_constructor: bool
is_dict_literal: bool
is_set_literal: bool
is_string_literal: bool
is_attribute: bool
is_subscript: bool
is_slice: bool
is_buffer_access: bool
is_memview_index: bool
is_memview_slice: bool
is_memview_broadcast: bool
is_memview_copy_assignment: bool
saved_subexpr_nodes: Incomplete
is_temp: bool
is_target: bool
is_starred: bool
constant_result = constant_value_not_set
@property
def child_attrs(self) -> list[str]:...
def not_implemented(self, method_name) -> None: ...
def is_lvalue(self): ...
def is_addressable(self): ...
def is_ephemeral(self): ...
def subexpr_nodes(self): ...
def result(self): ...
def pythran_result(self, type_: Incomplete | None = ...): ...
def is_c_result_required(self): ...
def result_as(self, type: Incomplete | None = ...): ...
def py_result(self): ...
def ctype(self): ...
def get_constant_c_result_code(self) -> None: ...
def calculate_constant_result(self) -> None: ...
def has_constant_result(self): ...
def compile_time_value(self, denv) -> None: ...
def compile_time_value_error(self, e) -> None: ...
def analyse_target_declaration(self, env) -> None: ...
def analyse_const_expression(self, env): ...
def analyse_expressions(self, env): ...
def analyse_target_expression(self, env, rhs): ...
def analyse_boolean_expression(self, env): ...
def analyse_temp_boolean_expression(self, env): ...
def type_dependencies(self, env): ...
def infer_type(self, env): ...
def nonlocally_immutable(self): ...
def inferable_item_node(self, index: int = ...): ...
def analyse_as_module(self, env) -> None: ...
def analyse_as_type(self, env) -> None: ...
def analyse_as_extension_type(self, env) -> None: ...
def analyse_types(self, env) -> None: ...
def analyse_target_types(self, env): ...
def nogil_check(self, env) -> None: ...
def gil_assignment_check(self, env) -> None: ...
def check_const(self): ...
def not_const(self) -> None: ...
def check_const_addr(self): ...
def addr_not_const(self) -> None: ...
def result_in_temp(self): ...
def target_code(self): ...
def calculate_result_code(self) -> None: ...
def allocate_temp_result(self, code) -> None: ...
def release_temp_result(self, code) -> None: ...
def make_owned_reference(self, code) -> None: ...
def make_owned_memoryviewslice(self, code) -> None: ...
def generate_evaluation_code(self, code) -> None: ...
def generate_subexpr_evaluation_code(self, code) -> None: ...
def generate_result_code(self, code) -> None: ...
def generate_disposal_code(self, code) -> None: ...
def generate_subexpr_disposal_code(self, code) -> None: ...
def generate_post_assignment_code(self, code) -> None: ...
def generate_assignment_code(self, rhs, code, overloaded_assignment: bool = ..., exception_check: Incomplete | None = ..., exception_value: Incomplete | None = ...) -> None: ...
def generate_deletion_code(self, code, ignore_nonexisting: bool = ...) -> None: ...
def free_temps(self, code) -> None: ...
def free_subexpr_temps(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
def coerce_to(self, dst_type, env): ...
def fail_assignment(self, dst_type) -> None: ...
def check_for_coercion_error(self, dst_type, env, fail: bool = ..., default: Incomplete | None = ...): ...
def coerce_to_pyobject(self, env): ...
def coerce_to_boolean(self, env): ...
def coerce_to_integer(self, env): ...
def coerce_to_temp(self, env): ...
def coerce_to_simple(self, env): ...
def is_simple(self): ...
def may_be_none(self): ...
def as_cython_attribute(self) -> None: ...
def as_none_safe_node(self, message, error: str = ..., format_args=...): ...
@classmethod
def from_node(cls, node, **kwargs): ...
class AtomicExprNode(ExprNode):
subexprs: Incomplete
def generate_subexpr_evaluation_code(self, code) -> None: ...
def generate_subexpr_disposal_code(self, code) -> None: ...
class PyConstNode(AtomicExprNode):
is_literal: int
type = py_object_type
def is_simple(self): ...
def may_be_none(self): ...
def analyse_types(self, env): ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
class NoneNode(PyConstNode):
is_none: int
value: str
constant_result: Incomplete
nogil_check: Incomplete
def compile_time_value(self, denv) -> None: ...
def may_be_none(self): ...
def coerce_to(self, dst_type, env): ...
class EllipsisNode(PyConstNode):
value: str
constant_result = Ellipsis
def compile_time_value(self, denv): ...
class ConstNode(AtomicExprNode):
is_literal: int
nogil_check: Incomplete
def is_simple(self): ...
def nonlocally_immutable(self): ...
def may_be_none(self): ...
def analyse_types(self, env): ...
def check_const(self): ...
def get_constant_c_result_code(self): ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
class BoolNode(ConstNode):
type: Incomplete
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def calculate_result_code(self): ...
def coerce_to(self, dst_type, env): ...
class NullNode(ConstNode):
type: Incomplete
value: str
constant_result: int
def get_constant_c_result_code(self): ...
class CharNode(ConstNode):
type: Incomplete
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def calculate_result_code(self): ...
class IntNode(ConstNode):
unsigned: str
longness: str
is_c_literal: Incomplete
type: Incomplete
def __init__(self, pos, **kwds) -> None: ...
def find_suitable_type_for_value(self): ...
def coerce_to(self, dst_type, env): ...
def coerce_to_boolean(self, env): ...
result_code: Incomplete
def generate_evaluation_code(self, code) -> None: ...
def get_constant_c_result_code(self): ...
def value_as_c_integer_string(self): ...
def calculate_result_code(self): ...
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
class FloatNode(ConstNode):
type: Incomplete
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def coerce_to(self, dst_type, env): ...
def calculate_result_code(self): ...
def get_constant_c_result_code(self): ...
result_code: Incomplete
def generate_evaluation_code(self, code) -> None: ...
class BytesNode(ConstNode):
is_string_literal: bool
type = bytes_type
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def as_sliced_node(self, start, stop, step: Incomplete | None = ...): ...
def compile_time_value(self, denv): ...
def analyse_as_type(self, env): ...
def can_coerce_to_char_literal(self): ...
def coerce_to_boolean(self, env): ...
def coerce_to(self, dst_type, env): ...
result_code: Incomplete
def generate_evaluation_code(self, code) -> None: ...
def get_constant_c_result_code(self) -> None: ...
def calculate_result_code(self): ...
class UnicodeNode(ConstNode):
is_string_literal: bool
bytes_value: Incomplete
type = unicode_type
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def analyse_as_type(self, env): ...
def as_sliced_node(self, start, stop, step: Incomplete | None = ...): ...
def coerce_to(self, dst_type, env): ...
def can_coerce_to_char_literal(self): ...
def coerce_to_boolean(self, env): ...
def contains_surrogates(self): ...
result_code: Incomplete
def generate_evaluation_code(self, code) -> None: ...
def calculate_result_code(self): ...
def compile_time_value(self, env): ...
class StringNode(PyConstNode):
type = str_type
is_string_literal: bool
is_identifier: Incomplete
unicode_value: Incomplete
value: str
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def analyse_as_type(self, env): ...
def as_sliced_node(self, start, stop, step: Incomplete | None = ...): ...
def coerce_to(self, dst_type, env): ...
def can_coerce_to_char_literal(self): ...
result_code: Incomplete
def generate_evaluation_code(self, code) -> None: ...
def get_constant_c_result_code(self) -> None: ...
def calculate_result_code(self): ...
def compile_time_value(self, env): ...
class IdentifierStringNode(StringNode):
is_identifier: bool
class ImagNode(AtomicExprNode):
type: Incomplete
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def analyse_types(self, env): ...
def may_be_none(self): ...
def coerce_to(self, dst_type, env): ...
gil_message: str
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
class NewExprNode(AtomicExprNode):
type: Incomplete
class_type: Incomplete
entry: Symtab.Entry
def infer_type(self, env): ...
def analyse_types(self, env): ...
def may_be_none(self): ...
def generate_result_code(self, code) -> None: ...
def calculate_result_code(self): ...
class NameNode(AtomicExprNode):
annotation:ExprNode
name:str
is_name: bool
is_cython_module: bool
cython_attribute: Incomplete
lhs_of_first_assignment: bool
is_used_as_rvalue: int
entry: Symtab.Entry
type_entry: Symtab.Entry
cf_maybe_null: bool
cf_is_null: bool
allow_null: bool
nogil: bool
inferred_type: Incomplete
def as_cython_attribute(self): ...
def type_dependencies(self, env): ...
def infer_type(self, env): ...
def compile_time_value(self, denv): ...
def get_constant_c_result_code(self): ...
def coerce_to(self, dst_type, env): ...
def declare_from_annotation(self, env, as_target: bool = ...) -> None: ...
def analyse_as_module(self, env): ...
def analyse_as_type(self, env): ...
def analyse_as_extension_type(self, env): ...
result_ctype: Incomplete
def analyse_target_declaration(self, env) -> None: ...
initialized_check: Incomplete
is_literal: bool
type: Incomplete
def analyse_types(self, env): ...
def analyse_target_types(self, env): ...
is_temp: int
use_managed_ref: bool
def analyse_rvalue_entry(self, env): ...
def nogil_check(self, env) -> None: ...
gil_message: str
def analyse_entry(self, env, is_target: bool = ...) -> None: ...
def check_identifier_kind(self) -> None: ...
def is_cimported_module_without_shadow(self, env): ...
def is_simple(self): ...
def may_be_none(self): ...
def nonlocally_immutable(self): ...
def calculate_target_results(self, env) -> None: ...
def check_const(self): ...
def check_const_addr(self): ...
def is_lvalue(self): ...
def is_addressable(self): ...
def is_ephemeral(self): ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
def generate_assignment_code(self, rhs, code, overloaded_assignment: bool = ..., exception_check: Incomplete | None = ..., exception_value: Incomplete | None = ...) -> None: ...
def generate_acquire_memoryviewslice(self, rhs, code) -> None: ...
def generate_acquire_buffer(self, rhs, code) -> None: ...
def generate_deletion_code(self, code, ignore_nonexisting: bool = ...) -> None: ...
def annotate(self, code) -> None: ...
class BackquoteNode(ExprNode):
type = py_object_type
subexprs: Incomplete
arg: Incomplete
is_temp: int
def analyse_types(self, env): ...
gil_message: str
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def generate_result_code(self, code) -> None: ...
class ImportNode(ExprNode):
type = py_object_type
module_name: StringNode
subexprs: Incomplete
level: int
name_list: Incomplete
is_temp: int
def analyse_types(self, env): ...
gil_message: str
def generate_result_code(self, code) -> None: ...
class IteratorNode(ExprNode):
type = py_object_type
iter_func_ptr: Incomplete
counter_cname: Incomplete
cpp_iterator_cname: Incomplete
reversed: bool
is_async: bool
subexprs: Incomplete
sequence: Incomplete
is_temp: int
def analyse_types(self, env): ...
gil_message: str
def type_dependencies(self, env): ...
def infer_type(self, env): ...
def analyse_cpp_types(self, env) -> None: ...
may_be_a_sequence: Incomplete
def generate_result_code(self, code) -> None: ...
def generate_next_sequence_item(self, test_name, result_name, code) -> None: ...
def generate_iter_next_result_code(self, result_name, code) -> None: ...
def free_temps(self, code) -> None: ...
class NextNode(AtomicExprNode):
iterator: Incomplete
def __init__(self, iterator) -> None: ...
def nogil_check(self, env) -> None: ...
def type_dependencies(self, env): ...
def infer_type(self, env, iterator_type: Incomplete | None = ...): ...
type: Incomplete
is_temp: int
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
class AsyncIteratorNode(ExprNode):
subexprs: Incomplete
is_async: bool
type = py_object_type
is_temp: int
def infer_type(self, env): ...
sequence: Incomplete
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
class AsyncNextNode(AtomicExprNode):
type = py_object_type
is_temp: int
iterator: Incomplete
def __init__(self, iterator) -> None: ...
def infer_type(self, env): ...
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
class WithExitCallNode(ExprNode):
subexprs: Incomplete
test_if_run: bool
await_expr: Incomplete
args: Incomplete
type: Incomplete
is_temp: bool
def analyse_types(self, env): ...
def generate_evaluation_code(self, code) -> None: ...
class ExcValueNode(AtomicExprNode):
type = py_object_type
def __init__(self, pos) -> None: ...
var: Incomplete
def set_var(self, var) -> None: ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
def analyse_types(self, env): ...
class TempNode(ExprNode):
subexprs: Incomplete
type: Incomplete
result_ctype: Incomplete
is_temp: int
def __init__(self, pos, type, env: Incomplete | None = ...) -> None: ...
def analyse_types(self, env): ...
def analyse_target_declaration(self, env) -> None: ...
def generate_result_code(self, code) -> None: ...
temp_cname: Incomplete
def allocate(self, code) -> None: ...
def release(self, code) -> None: ...
def result(self): ...
def allocate_temp_result(self, code) -> None: ...
def release_temp_result(self, code) -> None: ...
class PyTempNode(TempNode):
def __init__(self, pos, env) -> None: ...
class RawCNameExprNode(ExprNode):
subexprs: Incomplete
cname: Incomplete
def __init__(self, pos, type: Incomplete | None = ..., cname: Incomplete | None = ...) -> None: ...
def analyse_types(self, env): ...
def set_cname(self, cname) -> None: ...
def result(self): ...
def generate_result_code(self, code) -> None: ...
class JoinedStrNode(ExprNode):
type = unicode_type
is_temp: bool
subexprs: Incomplete
values: Incomplete
def analyse_types(self, env): ...
def may_be_none(self): ...
def generate_evaluation_code(self, code) -> None: ...
class FormattedValueNode(ExprNode):
subexprs: Incomplete
type = unicode_type
is_temp: bool
c_format_spec: Incomplete
find_conversion_func: Incomplete
def may_be_none(self): ...
value: Incomplete
format_spec: Incomplete
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
class ParallelThreadsAvailableNode(AtomicExprNode):
type: Incomplete
is_temp: bool
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
def result(self): ...
class ParallelThreadIdNode(AtomicExprNode):
type: Incomplete
is_temp: bool
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
def result(self): ...
class _IndexingBaseNode(ExprNode):
def is_ephemeral(self): ...
def check_const_addr(self): ...
def is_lvalue(self): ...
class IndexNode(_IndexingBaseNode):
subexprs: Incomplete
type_indices: Incomplete
is_subscript: bool
is_fused_index: bool
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def is_simple(self): ...
def may_be_none(self): ...
def analyse_target_declaration(self, env) -> None: ...
def analyse_as_type(self, env): ...
def type_dependencies(self, env): ...
def infer_type(self, env): ...
def analyse_types(self, env): ...
def analyse_target_types(self, env): ...
base: Incomplete
type: Incomplete
index: Incomplete
nogil: Incomplete
original_index_type: Incomplete
def analyse_base_and_index_types(self, env, getting: bool = ..., setting: bool = ..., analyse_base: bool = ...): ...
is_temp: int
def analyse_as_pyobject(self, env, is_slice, getting, setting): ...
def analyse_as_c_array(self, env, is_slice): ...
result_code: str
exception_check: Incomplete
exception_value: Incomplete
def analyse_as_cpp(self, env, setting): ...
def analyse_as_c_function(self, env): ...
def analyse_as_c_tuple(self, env, getting, setting): ...
def analyse_as_buffer_operation(self, env, getting): ...
def wrap_in_nonecheck_node(self, env, getting) -> None: ...
def parse_index_as_types(self, env, required: bool = ...): ...
entry: Incomplete
is_attribute: bool
obj: Incomplete
def parse_indexed_fused_cdef(self, env): ...
gil_message: str
def calculate_result_code(self): ...
def extra_index_params(self, code): ...
def generate_result_code(self, code) -> None: ...
def generate_setitem_code(self, value_code, code) -> None: ...
def generate_assignment_code(self, rhs, code, overloaded_assignment: bool = ..., exception_check: Incomplete | None = ..., exception_value: Incomplete | None = ...) -> None: ...
def generate_deletion_code(self, code, ignore_nonexisting: bool = ...) -> None: ...
class BufferIndexNode(_IndexingBaseNode):
subexprs: Incomplete
is_buffer_access: bool
writable_needed: bool
index_temps: Incomplete
def analyse_target_types(self, env) -> None: ...
type: Incomplete
none_error_message: str
def analyse_types(self, env, getting: bool = ...): ...
base: Incomplete
buffer_type: Incomplete
is_temp: bool
def analyse_buffer_index(self, env, getting) -> None: ...
def analyse_assignment(self, rhs) -> None: ...
def wrap_in_nonecheck_node(self, env) -> None: ...
def nogil_check(self, env) -> None: ...
def calculate_result_code(self): ...
def buffer_entry(self): ...
def get_index_in_temp(self, code, ivar): ...
def buffer_lookup_code(self, code): ...
def generate_assignment_code(self, rhs, code, overloaded_assignment: bool = ...) -> None: ...
def generate_buffer_setitem_code(self, rhs, code, op: str = ...) -> None: ...
def generate_result_code(self, code) -> None: ...
def free_subexpr_temps(self, code) -> None: ...
class MemoryViewIndexNode(BufferIndexNode):
is_memview_index: bool
is_buffer_access: bool
warned_untyped_idx: bool
is_pythran_mode: Incomplete
writable_needed: bool
memslice_index: Incomplete
type: Incomplete
is_memview_slice: bool
indices: Incomplete
original_indices: Incomplete
nogil: Incomplete
def analyse_types(self, env, getting: bool = ...): ...
none_error_message: str
def analyse_operation(self, env, getting, axes) -> None: ...
def analyse_broadcast_operation(self, rhs) -> None: ...
def analyse_as_memview_scalar_assignment(self, rhs): ...
class MemoryViewSliceNode(MemoryViewIndexNode):
is_memview_slice: bool
is_ellipsis_noop: bool
is_memview_scalar_assignment: bool
is_memview_index: bool
is_memview_broadcast: bool
type: Incomplete
def analyse_ellipsis_noop(self, env, getting) -> None: ...
none_error_message: str
index: Incomplete
is_temp: bool
use_managed_ref: bool
base: Incomplete
def analyse_operation(self, env, getting, axes) -> None: ...
def analyse_assignment(self, rhs): ...
def merged_indices(self, indices): ...
def is_simple(self): ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
def generate_assignment_code(self, rhs, code, overloaded_assignment: bool = ...) -> None: ...
class MemoryCopyNode(ExprNode):
subexprs: Incomplete
dst: Incomplete
type: Incomplete
def __init__(self, pos, dst) -> None: ...
def generate_assignment_code(self, rhs, code, overloaded_assignment: bool = ...) -> None: ...
class MemoryCopySlice(MemoryCopyNode):
is_memview_copy_assignment: bool
copy_slice_cname: str
class MemoryCopyScalar(MemoryCopyNode):
type: Incomplete
def __init__(self, pos, dst) -> None: ...
class SliceIndexNode(ExprNode):
subexprs: Incomplete
slice: Incomplete
def infer_type(self, env): ...
def inferable_item_node(self, index: int = ...): ...
def may_be_none(self): ...
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def analyse_target_declaration(self, env) -> None: ...
def analyse_target_types(self, env): ...
base: Incomplete
start: Incomplete
stop: Incomplete
type: Incomplete
is_temp: int
def analyse_types(self, env, getting: bool = ...): ...
def analyse_as_type(self, env): ...
nogil_check: Incomplete
gil_message: str
get_slice_utility_code: Incomplete
set_slice_utility_code: Incomplete
def coerce_to(self, dst_type, env): ...
def generate_result_code(self, code) -> None: ...
def generate_assignment_code(self, rhs, code, overloaded_assignment: bool = ..., exception_check: Incomplete | None = ..., exception_value: Incomplete | None = ...) -> None: ...
def generate_deletion_code(self, code, ignore_nonexisting: bool = ...) -> None: ...
def get_slice_config(self): ...
def generate_slice_guard_code(self, code, target_size) -> None: ...
def start_code(self): ...
def stop_code(self): ...
def calculate_result_code(self): ...
class SliceNode(ExprNode):
subexprs: Incomplete
is_slice: bool
type = slice_type
is_temp: int
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def may_be_none(self): ...
start: Incomplete
stop: Incomplete
step: Incomplete
is_literal: bool
def analyse_types(self, env): ...
gil_message: str
def calculate_result_code(self): ...
result_code: Incomplete
def generate_result_code(self, code) -> None: ...
class SliceIntNode(SliceNode):
is_temp: int
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def may_be_none(self): ...
start: Incomplete
stop: Incomplete
step: Incomplete
is_literal: bool
def analyse_types(self, env): ...
def calculate_result_code(self) -> None: ...
def generate_result_code(self, code) -> None: ...
class CallNode(ExprNode):
may_return_none: Incomplete
def infer_type(self, env): ...
def type_dependencies(self, env): ...
def is_simple(self): ...
def may_be_none(self): ...
type: Incomplete
result_ctype: Incomplete
def set_py_result_type(self, function, func_type: Incomplete | None = ...) -> None: ...
key_value_pairs: Incomplete
__class__: Incomplete
args: Incomplete
function: Incomplete
def analyse_as_type_constructor(self, env): ...
def is_lvalue(self): ...
def nogil_check(self, env) -> None: ...
gil_message: str
class SimpleCallNode(CallNode):
subexprs: Incomplete
self: Incomplete
coerced_self: Incomplete
arg_tuple: Incomplete
wrapper_call: bool
has_optional_args: bool
nogil: bool
analysed: bool
overflowcheck: bool
def compile_time_value(self, denv): ...
def analyse_as_type(self, env): ...
def explicit_args_kwds(self): ...
function: Incomplete
is_numpy_call_with_exprs: bool
args: Incomplete
is_temp: int
def analyse_types(self, env): ...
def function_type(self): ...
type: Incomplete
result_code: str
result_ctype: Incomplete
def analyse_c_function_call(self, env) -> None: ...
def calculate_result_code(self): ...
def c_call_code(self): ...
def is_c_result_required(self): ...
def generate_evaluation_code(self, code) -> None: ...
opt_arg_struct: Incomplete
def generate_result_code(self, code) -> None: ...
class NumPyMethodCallNode(ExprNode):
subexprs: Incomplete
is_temp: bool
may_return_none: bool
def generate_evaluation_code(self, code) -> None: ...
class PyMethodCallNode(SimpleCallNode):
subexprs: Incomplete
is_temp: bool
def generate_evaluation_code(self, code): ...
class InlinedDefNodeCallNode(CallNode):
subexprs: Incomplete
is_temp: int
type = py_object_type
function: Incomplete
function_name: Incomplete
def can_be_inlined(self): ...
args: Incomplete
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
class PythonCapiFunctionNode(ExprNode):
subexprs: Incomplete
def __init__(self, pos, py_name, cname, func_type, utility_code: Incomplete | None = ...) -> None: ...
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
def calculate_result_code(self): ...
class PythonCapiCallNode(SimpleCallNode):
may_return_none: bool
type: Incomplete
result_ctype: Incomplete
function: Incomplete
def __init__(self, pos, function_name, func_type, utility_code: Incomplete | None = ..., py_name: Incomplete | None = ..., **kwargs) -> None: ...
class CachedBuiltinMethodCallNode(CallNode):
subexprs: Incomplete
is_temp: bool
def __init__(self, call_node, obj, method_name, args) -> None: ...
def may_be_none(self): ...
def generate_result_code(self, code) -> None: ...
class GeneralCallNode(CallNode):
type = py_object_type
subexprs: Incomplete
nogil_check: Incomplete
def compile_time_value(self, denv): ...
def explicit_args_kwds(self): ...
function: Incomplete
keyword_args: Incomplete
positional_args: Incomplete
is_temp: int
def analyse_types(self, env): ...
def map_to_simple_call_node(self): ...
def generate_result_code(self, code) -> None: ...
class AsTupleNode(ExprNode):
subexprs: Incomplete
is_temp: int
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
arg: Incomplete
type: Incomplete
def analyse_types(self, env): ...
def may_be_none(self): ...
nogil_check: Incomplete
gil_message: str
def generate_result_code(self, code) -> None: ...
class MergedDictNode(ExprNode):
subexprs: Incomplete
is_temp: int
type = dict_type
reject_duplicates: bool
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def type_dependencies(self, env): ...
def infer_type(self, env): ...
keyword_args: Incomplete
def analyse_types(self, env): ...
def may_be_none(self): ...
gil_message: str
def generate_evaluation_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
class AttributeNode(ExprNode):
is_attribute: int
subexprs: Incomplete
type: Incomplete
entry: Incomplete
is_called: int
needs_none_check: bool
is_memslice_transpose: bool
is_special_lookup: bool
is_py_attr: int
def as_cython_attribute(self): ...
is_temp: int
def coerce_to(self, dst_type, env): ...
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def type_dependencies(self, env): ...
def infer_type(self, env): ...
def analyse_target_declaration(self, env) -> None: ...
def analyse_target_types(self, env): ...
initialized_check: Incomplete
def analyse_types(self, env, target: int = ...): ...
def analyse_as_cimported_attribute_node(self, env, target): ...
def analyse_as_type_attribute(self, env): ...
def analyse_as_type(self, env): ...
def analyse_as_extension_type(self, env): ...
def analyse_as_module(self, env): ...
def as_name_node(self, env, entry, target): ...
obj: ExprNode
result_ctype: Incomplete
def analyse_as_ordinary_attribute_node(self, env, target): ...
member: Incomplete
op: str
use_managed_ref: bool
def analyse_attribute(self, env, obj_type: Incomplete | None = ...) -> None: ...
attribute: str
def analyse_as_python_attribute(self, env, obj_type: Incomplete | None = ..., immutable_obj: bool = ...) -> None: ...
def wrap_obj_in_nonecheck(self, env) -> None: ...
def nogil_check(self, env) -> None: ...
gil_message: str
def is_cimported_module_without_shadow(self, env): ...
def is_simple(self): ...
def is_lvalue(self): ...
def is_ephemeral(self): ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
def generate_disposal_code(self, code) -> None: ...
def generate_assignment_code(self, rhs, code, overloaded_assignment: bool = ..., exception_check: Incomplete | None = ..., exception_value: Incomplete | None = ...) -> None: ...
def generate_deletion_code(self, code, ignore_nonexisting: bool = ...) -> None: ...
def annotate(self, code) -> None: ...
class StarredUnpackingNode(ExprNode):
subexprs: Incomplete
is_starred: int
type = py_object_type
is_temp: int
starred_expr_allowed_here: bool
def __init__(self, pos, target) -> None: ...
def analyse_declarations(self, env) -> None: ...
def infer_type(self, env): ...
target: Incomplete
def analyse_types(self, env): ...
def analyse_target_declaration(self, env) -> None: ...
def analyse_target_types(self, env): ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
class SequenceNode(ExprNode):
subexprs: Incomplete
is_sequence_constructor: int
unpacked_items: Incomplete
mult_factor: Incomplete
slow: bool
def compile_time_value_list(self, denv): ...
starred_assignment: bool
args: Incomplete
def replace_starred_target_node(self) -> None: ...
def analyse_target_declaration(self, env) -> None: ...
is_temp: int
def analyse_types(self, env, skip_children: bool = ...): ...
def coerce_to_ctuple(self, dst_type, env): ...
def may_be_none(self): ...
coerced_unpacked_items: Incomplete
any_coerced_items: bool
type: Incomplete
def analyse_target_types(self, env): ...
def generate_result_code(self, code) -> None: ...
def generate_sequence_packing_code(self, code, target: Incomplete | None = ..., plain: bool = ...) -> None: ...
def generate_subexpr_disposal_code(self, code) -> None: ...
def generate_assignment_code(self, rhs, code, overloaded_assignment: bool = ..., exception_check: Incomplete | None = ..., exception_value: Incomplete | None = ...) -> None: ...
def generate_parallel_assignment_code(self, rhs, code) -> None: ...
def generate_special_parallel_unpacking_code(self, code, rhs, use_loop) -> None: ...
def generate_generic_parallel_unpacking_code(self, code, rhs, unpacked_items, use_loop, terminate: bool = ...): ...
def generate_starred_assignment_code(self, rhs, code) -> None: ...
def annotate(self, code) -> None: ...
class TupleNode(SequenceNode):
type = tuple_type
is_partly_literal: bool
gil_message: str
def infer_type(self, env): ...
is_temp: bool
is_literal: bool
def analyse_types(self, env, skip_children: bool = ...): ...
def analyse_as_type(self, env): ...
def coerce_to(self, dst_type, env): ...
def as_list(self): ...
def is_simple(self): ...
def nonlocally_immutable(self): ...
def calculate_result_code(self): ...
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
result_code: Incomplete
def generate_operation_code(self, code) -> None: ...
class ListNode(SequenceNode):
obj_conversion_errors: Incomplete
type = list_type
in_module_scope: bool
gil_message: str
def type_dependencies(self, env): ...
def infer_type(self, env): ...
def analyse_expressions(self, env): ...
original_args: Incomplete
def analyse_types(self, env): ...
def coerce_to(self, dst_type, env): ...
def as_list(self): ...
def as_tuple(self): ...
temp_code: Incomplete
def allocate_temp_result(self, code) -> None: ...
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def generate_operation_code(self, code) -> None: ...
class ScopedExprNode(ExprNode):
subexprs: Incomplete
expr_scope: Incomplete
has_local_scope: bool
def init_scope(self, outer_scope, expr_scope: Incomplete | None = ...) -> None: ...
def analyse_declarations(self, env) -> None: ...
def analyse_scoped_declarations(self, env) -> None: ...
def analyse_types(self, env): ...
def analyse_scoped_expressions(self, env): ...
def generate_evaluation_code(self, code) -> None: ...
class ComprehensionNode(ScopedExprNode):
child_attrs: Incomplete
is_temp: bool
constant_result = not_a_constant
def infer_type(self, env): ...
def analyse_declarations(self, env) -> None: ...
def analyse_scoped_declarations(self, env) -> None: ...
loop: Incomplete
def analyse_types(self, env): ...
def analyse_scoped_expressions(self, env): ...
def may_be_none(self): ...
def generate_result_code(self, code) -> None: ...
def generate_operation_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
class ComprehensionAppendNode(Node):
child_attrs: Incomplete
target: Incomplete
type: Incomplete
expr: Incomplete
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class DictComprehensionAppendNode(ComprehensionAppendNode):
child_attrs: Incomplete
key_expr: Incomplete
value_expr: Incomplete
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class InlinedGeneratorExpressionNode(ExprNode):
subexprs: Incomplete
orig_func: Incomplete
target: Incomplete
is_temp: bool
type = py_object_type
def __init__(self, pos, gen, comprehension_type: Incomplete | None = ..., **kwargs) -> None: ...
def may_be_none(self): ...
def infer_type(self, env): ...
gen: Incomplete
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
class MergedSequenceNode(ExprNode):
subexprs: Incomplete
is_temp: bool
gil_message: str
def __init__(self, pos, args, type) -> None: ...
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def type_dependencies(self, env): ...
def infer_type(self, env): ...
args: Incomplete
def analyse_types(self, env): ...
def may_be_none(self): ...
def generate_evaluation_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
class SetNode(ExprNode):
subexprs: Incomplete
type = set_type
is_set_literal: bool
gil_message: str
is_temp: int
def analyse_types(self, env): ...
def may_be_none(self): ...
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def generate_evaluation_code(self, code) -> None: ...
class DictNode(ExprNode):
subexprs: Incomplete
is_temp: int
exclude_null_values: bool
type = dict_type
is_dict_literal: bool
reject_duplicates: bool
obj_conversion_errors: Incomplete
@classmethod
def from_pairs(cls, pos, pairs): ...
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def type_dependencies(self, env): ...
def infer_type(self, env): ...
key_value_pairs: Incomplete
def analyse_types(self, env): ...
def may_be_none(self): ...
def coerce_to(self, dst_type, env): ...
def release_errors(self) -> None: ...
gil_message: str
def generate_evaluation_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
class DictItemNode(ExprNode):
subexprs: Incomplete
nogil_check: Incomplete
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
key: Incomplete
value: Incomplete
def analyse_types(self, env): ...
def generate_evaluation_code(self, code) -> None: ...
def generate_disposal_code(self, code) -> None: ...
def free_temps(self, code) -> None: ...
def __iter__(self): ...
class SortedDictKeysNode(ExprNode):
subexprs: Incomplete
is_temp: bool
type: Incomplete
def __init__(self, arg) -> None: ...
arg: Incomplete
def analyse_types(self, env): ...
def may_be_none(self): ...
def generate_result_code(self, code) -> None: ...
class ModuleNameMixin:
def get_py_mod_name(self, code): ...
def get_py_qualified_name(self, code): ...
class ClassNode(ExprNode, ModuleNameMixin):
subexprs: Incomplete
type = py_object_type
is_temp: bool
def infer_type(self, env): ...
doc: Incomplete
def analyse_types(self, env): ...
def may_be_none(self): ...
gil_message: str
def generate_result_code(self, code) -> None: ...
class Py3ClassNode(ExprNode):
subexprs: Incomplete
type = py_object_type
is_temp: bool
def infer_type(self, env): ...
def analyse_types(self, env): ...
def may_be_none(self): ...
gil_message: str
def generate_result_code(self, code) -> None: ...
class PyClassMetaclassNode(ExprNode):
subexprs: Incomplete
type: Incomplete
is_temp: bool
def analyse_types(self, env): ...
def may_be_none(self): ...
def generate_result_code(self, code) -> None: ...
class PyClassNamespaceNode(ExprNode, ModuleNameMixin):
subexprs: Incomplete
doc: Incomplete
type: Incomplete
is_temp: int
def analyse_types(self, env): ...
def may_be_none(self): ...
def generate_result_code(self, code) -> None: ...
class ClassCellInjectorNode(ExprNode):
is_temp: bool
type = py_object_type
subexprs: Incomplete
is_active: bool
def analyse_expressions(self, env): ...
def generate_result_code(self, code) -> None: ...
def generate_injection_code(self, code, classobj_cname) -> None: ...
class ClassCellNode(ExprNode):
subexprs: Incomplete
is_temp: bool
is_generator: bool
type = py_object_type
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
class PyCFunctionNode(ExprNode, ModuleNameMixin):
subexprs: Incomplete
self_object: Incomplete
code_object: Incomplete
binding: bool
def_node: Incomplete
defaults: Incomplete
defaults_struct: Incomplete
defaults_pyobjects: int
defaults_tuple: Incomplete
defaults_kwdict: Incomplete
annotations_dict: Incomplete
type = py_object_type
is_temp: int
specialized_cpdefs: Incomplete
is_specialization: bool
@classmethod
def from_defnode(cls, node, binding): ...
def analyse_types(self, env): ...
def analyse_default_args(self, env) -> None: ...
def analyse_annotation(self, env, annotation): ...
def may_be_none(self): ...
gil_message: str
def self_result_code(self): ...
def generate_result_code(self, code) -> None: ...
def generate_pycfunction_code(self, code) -> None: ...
def generate_cyfunction_code(self, code) -> None: ...
class InnerFunctionNode(PyCFunctionNode):
binding: bool
needs_self_code: bool
def self_result_code(self): ...
class CodeObjectNode(ExprNode):
subexprs: Incomplete
is_temp: bool
result_code: Incomplete
varnames: Incomplete
def __init__(self, def_node) -> None: ...
def may_be_none(self): ...
def calculate_result_code(self, code: Incomplete | None = ...): ...
def generate_result_code(self, code) -> None: ...
class DefaultLiteralArgNode(ExprNode):
subexprs: Incomplete
is_literal: bool
is_temp: bool
arg: Incomplete
type: Incomplete
evaluated: bool
def __init__(self, pos, arg) -> None: ...
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
def generate_evaluation_code(self, code) -> None: ...
def result(self): ...
class DefaultNonLiteralArgNode(ExprNode):
subexprs: Incomplete
arg: Incomplete
defaults_struct: Incomplete
def __init__(self, pos, arg, defaults_struct) -> None: ...
type: Incomplete
is_temp: bool
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
def result(self): ...
class DefaultsTupleNode(TupleNode):
def __init__(self, pos, defaults, defaults_struct) -> None: ...
def analyse_types(self, env, skip_children: bool = ...): ...
class DefaultsKwDictNode(DictNode):
def __init__(self, pos, defaults, defaults_struct) -> None: ...
class LambdaNode(InnerFunctionNode):
child_attrs: Incomplete
name: Incomplete
lambda_name: Incomplete
pymethdef_cname: Incomplete
def analyse_declarations(self, env) -> None: ...
def_node: Incomplete
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
class GeneratorExpressionNode(LambdaNode):
name: Incomplete
binding: bool
genexpr_name: Incomplete
def analyse_declarations(self, env) -> None: ...
def generate_result_code(self, code) -> None: ...
class YieldExprNode(ExprNode):
subexprs: Incomplete
type = py_object_type
label_num: int
is_yield_from: bool
is_await: bool
in_async_gen: bool
expr_keyword: str
is_temp: int
arg: Incomplete
def analyse_types(self, env): ...
def coerce_yield_argument(self, env) -> None: ...
def generate_evaluation_code(self, code) -> None: ...
def generate_yield_code(self, code) -> None: ...
def generate_sent_value_handling_code(self, code, value_cname) -> None: ...
class _YieldDelegationExprNode(YieldExprNode):
def yield_from_func(self, code) -> None: ...
def generate_evaluation_code(self, code, source_cname: Incomplete | None = ..., decref_source: bool = ...) -> None: ...
def fetch_iteration_result(self, code) -> None: ...
def handle_iteration_exception(self, code) -> None: ...
class YieldFromExprNode(_YieldDelegationExprNode):
is_yield_from: bool
expr_keyword: str
arg: Incomplete
def coerce_yield_argument(self, env) -> None: ...
def yield_from_func(self, code): ...
class AwaitExprNode(_YieldDelegationExprNode):
is_await: bool
expr_keyword: str
arg: Incomplete
def coerce_yield_argument(self, env) -> None: ...
def yield_from_func(self, code): ...
class AwaitIterNextExprNode(AwaitExprNode):
def fetch_iteration_result(self, code) -> None: ...
def generate_sent_value_handling_code(self, code, value_cname) -> None: ...
class GlobalsExprNode(AtomicExprNode):
type = dict_type
is_temp: int
def analyse_types(self, env): ...
gil_message: str
def may_be_none(self): ...
def generate_result_code(self, code) -> None: ...
class LocalsDictItemNode(DictItemNode):
key: Incomplete
value: Incomplete
def analyse_types(self, env): ...
class FuncLocalsExprNode(DictNode):
def __init__(self, pos, env) -> None: ...
def analyse_types(self, env): ...
class PyClassLocalsExprNode(AtomicExprNode):
pyclass_dict: Incomplete
def __init__(self, pos, pyclass_dict) -> None: ...
type: Incomplete
is_temp: bool
def analyse_types(self, env): ...
def may_be_none(self): ...
def result(self): ...
def generate_result_code(self, code) -> None: ...
def LocalsExprNode(pos, scope_node, env): ...
compile_time_unary_operators: Incomplete
class UnopNode(ExprNode):
subexprs: Incomplete
infix: bool
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def infer_type(self, env): ...
def infer_unop_type(self, env, operand_type): ...
def may_be_none(self): ...
operand: Incomplete
type: Incomplete
is_temp: int
def analyse_types(self, env): ...
def check_const(self): ...
def is_py_operation(self): ...
def is_pythran_operation(self, env): ...
def nogil_check(self, env) -> None: ...
def is_cpp_operation(self): ...
def coerce_operand_to_pyobject(self, env) -> None: ...
def generate_result_code(self, code) -> None: ...
def generate_py_operation_code(self, code) -> None: ...
def type_error(self) -> None: ...
exception_check: Incomplete
exception_value: Incomplete
def analyse_cpp_operation(self, env, overload_check: bool = ...) -> None: ...
class NotNode(UnopNode):
operator: str
type: Incomplete
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def infer_unop_type(self, env, operand_type): ...
operand: Incomplete
def analyse_types(self, env): ...
def calculate_result_code(self): ...
class UnaryPlusNode(UnopNode):
operator: str
type: Incomplete
def analyse_c_operation(self, env) -> None: ...
def py_operation_function(self, code): ...
def calculate_result_code(self): ...
class UnaryMinusNode(UnopNode):
operator: str
type: Incomplete
infix: bool
def analyse_c_operation(self, env) -> None: ...
def py_operation_function(self, code): ...
def calculate_result_code(self): ...
def get_constant_c_result_code(self): ...
class TildeNode(UnopNode):
type: Incomplete
def analyse_c_operation(self, env) -> None: ...
def py_operation_function(self, code): ...
def calculate_result_code(self): ...
class CUnopNode(UnopNode):
def is_py_operation(self): ...
class DereferenceNode(CUnopNode):
operator: str
def infer_unop_type(self, env, operand_type): ...
type: Incomplete
def analyse_c_operation(self, env) -> None: ...
def calculate_result_code(self): ...
class DecrementIncrementNode(CUnopNode):
type: Incomplete
def analyse_c_operation(self, env) -> None: ...
def calculate_result_code(self): ...
def inc_dec_constructor(is_prefix, operator): ...
class AmpersandNode(CUnopNode):
operator: str
def infer_unop_type(self, env, operand_type): ...
operand: Incomplete
type: Incomplete
def analyse_types(self, env): ...
def check_const(self): ...
result_code: str
def error(self, mess) -> None: ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
unop_node_classes: Incomplete
def unop_node(pos, operator, operand): ...
class TypecastNode(ExprNode):
subexprs: Incomplete
base_type: Incomplete
declarator: Incomplete
type: Incomplete
def type_dependencies(self, env): ...
def infer_type(self, env): ...
operand: Incomplete
result_ctype: Incomplete
def analyse_types(self, env): ...
def is_simple(self): ...
def is_ephemeral(self): ...
def nonlocally_immutable(self): ...
def nogil_check(self, env) -> None: ...
def check_const(self): ...
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def calculate_result_code(self, operand_result: Incomplete | None = ...): ...
def get_constant_c_result_code(self): ...
def result_as(self, type): ...
def generate_result_code(self, code) -> None: ...
ERR_START: str
ERR_NOT_STOP: str
ERR_STEPS: str
ERR_NOT_POINTER: str
ERR_BASE_TYPE: str
class CythonArrayNode(ExprNode):
subexprs: Incomplete
shapes: Incomplete
is_temp: bool
mode: str
array_dtype: Incomplete
shape_type: Incomplete
operand: Incomplete
type: Incomplete
coercion_type: Incomplete
def analyse_types(self, env): ...
temp_code: Incomplete
def allocate_temp_result(self, code) -> None: ...
def infer_type(self, env): ...
def get_cython_array_type(self, env): ...
def generate_result_code(self, code) -> None: ...
@classmethod
def from_carray(cls, src_node, env): ...
class SizeofNode(ExprNode):
type: Incomplete
def check_const(self): ...
def generate_result_code(self, code) -> None: ...
class SizeofTypeNode(SizeofNode):
subexprs: Incomplete
arg_type: Incomplete
def analyse_types(self, env): ...
def check_type(self) -> None: ...
def calculate_result_code(self): ...
class SizeofVarNode(SizeofNode):
subexprs: Incomplete
arg_type: Incomplete
__class__: Incomplete
operand: Incomplete
def analyse_types(self, env): ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
class TypeidNode(ExprNode):
type: Incomplete
subexprs: Incomplete
arg_type: Incomplete
is_variable: Incomplete
is_temp: int
def get_type_info_type(self, env): ...
cpp_message: str
is_type: bool
def analyse_types(self, env): ...
result_code: str
def error(self, mess) -> None: ...
def check_const(self): ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
class TypeofNode(ExprNode):
literal: Incomplete
type = py_object_type
subexprs: Incomplete
operand: Incomplete
def analyse_types(self, env): ...
def analyse_as_type(self, env): ...
def may_be_none(self): ...
def generate_evaluation_code(self, code) -> None: ...
def calculate_result_code(self): ...
matmul_operator: Incomplete
compile_time_binary_operators: Incomplete
def get_compile_time_binop(node): ...
class BinopNode(ExprNode):
subexprs: Incomplete
inplace: bool
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def infer_type(self, env): ...
operand1: Incomplete
operand2: Incomplete
def analyse_types(self, env): ...
type: Incomplete
is_temp: int
def analyse_operation(self, env) -> None: ...
def is_py_operation(self): ...
def is_py_operation_types(self, type1, type2): ...
def is_pythran_operation(self, env): ...
def is_pythran_operation_types(self, type1, type2, env): ...
def is_cpp_operation(self): ...
exception_check: Incomplete
exception_value: Incomplete
def analyse_cpp_operation(self, env) -> None: ...
def result_type(self, type1, type2, env): ...
def infer_builtin_types_operation(self, type1, type2) -> None: ...
def nogil_check(self, env) -> None: ...
def coerce_operands_to_pyobjects(self, env) -> None: ...
def check_const(self): ...
def is_ephemeral(self): ...
def generate_result_code(self, code) -> None: ...
def type_error(self) -> None: ...
class CBinopNode(BinopNode):
def analyse_types(self, env): ...
def py_operation_function(self, code): ...
def calculate_result_code(self): ...
def compute_c_result_type(self, type1, type2): ...
def c_binop_constructor(operator): ...
class NumBinopNode(BinopNode):
infix: bool
overflow_check: bool
overflow_bit_node: Incomplete
type: Incomplete
overflow_fold: Incomplete
func: Incomplete
is_temp: bool
operand1: Incomplete
operand2: Incomplete
def analyse_c_operation(self, env) -> None: ...
def compute_c_result_type(self, type1, type2): ...
def may_be_none(self): ...
def get_constant_c_result_code(self): ...
def c_types_okay(self, type1, type2): ...
overflow_bit: Incomplete
def generate_evaluation_code(self, code) -> None: ...
def calculate_result_code(self): ...
def is_py_operation_types(self, type1, type2): ...
def py_operation_function(self, code): ...
py_functions: Incomplete
overflow_op_names: Incomplete
class IntBinopNode(NumBinopNode):
def c_types_okay(self, type1, type2): ...
class AddNode(NumBinopNode):
def is_py_operation_types(self, type1, type2): ...
def infer_builtin_types_operation(self, type1, type2): ...
def compute_c_result_type(self, type1, type2): ...
def py_operation_function(self, code): ...
class SubNode(NumBinopNode):
def compute_c_result_type(self, type1, type2): ...
class MulNode(NumBinopNode):
def is_py_operation_types(self, type1, type2): ...
def infer_builtin_types_operation(self, type1, type2): ...
class MatMultNode(NumBinopNode):
def is_py_operation_types(self, type1, type2): ...
def generate_evaluation_code(self, code) -> None: ...
class DivNode(NumBinopNode):
cdivision: Incomplete
truedivision: Incomplete
ctruedivision: bool
cdivision_warnings: bool
zerodivision_check: Incomplete
def find_compile_time_binary_operator(self, op1, op2): ...
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def infer_type(self, env): ...
operand1: Incomplete
operand2: Incomplete
def analyse_operation(self, env) -> None: ...
def compute_c_result_type(self, type1, type2): ...
def zero_division_message(self): ...
def generate_evaluation_code(self, code) -> None: ...
def generate_div_warning_code(self, code) -> None: ...
def calculate_result_code(self): ...
class ModNode(DivNode):
def is_py_operation_types(self, type1, type2): ...
def infer_builtin_types_operation(self, type1, type2): ...
def zero_division_message(self): ...
cdivision: Incomplete
def analyse_operation(self, env) -> None: ...
def generate_evaluation_code(self, code) -> None: ...
def calculate_result_code(self): ...
def py_operation_function(self, code): ...
class PowNode(NumBinopNode):
def analyse_types(self, env): ...
operand1: Incomplete
operand2: Incomplete
pow_func: Incomplete
def analyse_c_operation(self, env) -> None: ...
def calculate_result_code(self): ...
def py_operation_function(self, code): ...
class BoolBinopNode(ExprNode):
subexprs: Incomplete
is_temp: bool
operator: Incomplete
operand1: Incomplete
operand2: Incomplete
def infer_type(self, env): ...
def may_be_none(self): ...
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
def is_ephemeral(self): ...
type: Incomplete
def analyse_types(self, env): ...
def wrap_operands(self, env) -> None: ...
def coerce_to_boolean(self, env): ...
def coerce_to(self, dst_type, env): ...
def generate_bool_evaluation_code(self, code, final_result_temp, final_result_type, and_label, or_label, end_label, fall_through) -> None: ...
def generate_evaluation_code(self, code) -> None: ...
gil_message: str
def check_const(self): ...
def generate_subexpr_disposal_code(self, code) -> None: ...
def free_subexpr_temps(self, code) -> None: ...
def generate_operand1_test(self, code): ...
class BoolBinopResultNode(ExprNode):
subexprs: Incomplete
is_temp: bool
arg: Incomplete
value: Incomplete
def __init__(self, arg, result_type, env) -> None: ...
def coerce_to_boolean(self, env): ...
def coerce_to(self, dst_type, env): ...
def nogil_check(self, env) -> None: ...
def generate_operand_test(self, code): ...
def generate_bool_evaluation_code(self, code, final_result_temp, final_result_type, and_label, or_label, end_label, fall_through) -> None: ...
class CondExprNode(ExprNode):
true_val: Incomplete
false_val: Incomplete
is_temp: bool
subexprs: Incomplete
def type_dependencies(self, env): ...
def infer_type(self, env): ...
constant_result: Incomplete
def calculate_constant_result(self) -> None: ...
def is_ephemeral(self): ...
test: Incomplete
def analyse_types(self, env): ...
type: Incomplete
result_ctype: Incomplete
def analyse_result_type(self, env): ...
def coerce_to_integer(self, env): ...
def coerce_to(self, dst_type, env): ...
def type_error(self) -> None: ...
def check_const(self): ...
def generate_evaluation_code(self, code) -> None: ...
def eval_and_get(self, code, expr) -> None: ...
def generate_subexpr_disposal_code(self, code) -> None: ...
def free_subexpr_temps(self, code) -> None: ...
richcmp_constants: Incomplete
class CmpNode:
special_bool_cmp_function: Incomplete
special_bool_cmp_utility_code: Incomplete
def infer_type(self, env): ...
constant_result: Incomplete
operand2: Incomplete
def calculate_cascaded_constant_result(self, operand1_result) -> None: ...
def cascaded_compile_time_value(self, operand1, denv): ...
def is_cpp_comparison(self): ...
def find_common_int_type(self, env, op, operand1, operand2): ...
def find_common_type(self, env, op, operand1, common_type: Incomplete | None = ...): ...
def invalid_types_error(self, operand1, op, operand2) -> None: ...
def is_python_comparison(self): ...
def coerce_operands_to(self, dst_type, env) -> None: ...
def is_python_result(self): ...
def is_c_string_contains(self): ...
def is_ptr_contains(self): ...
def find_special_bool_compare_function(self, env, operand1, result_is_bool: bool = ...): ...
def generate_operation_code(self, code, result_code, operand1, op, operand2) -> None: ...
def c_operator(self, op): ...
class PrimaryCmpNode(ExprNode, CmpNode):
child_attrs: Incomplete
cascade: Incomplete
coerced_operand2: Incomplete
is_memslice_nonecheck: bool
def infer_type(self, env): ...
def type_dependencies(self, env): ...
def calculate_constant_result(self) -> None: ...
def compile_time_value(self, denv): ...
operand1: Incomplete
operand2: Incomplete
type: Incomplete
is_pycmp: bool
is_temp: int
def analyse_types(self, env): ...
result_code: str
exception_check: Incomplete
exception_value: Incomplete
def analyse_cpp_comparison(self, env) -> None: ...
def analyse_memoryviewslice_comparison(self, env): ...
def coerce_to_boolean(self, env): ...
def has_python_operands(self): ...
def check_const(self): ...
def calculate_result_code(self): ...
def generate_evaluation_code(self, code) -> None: ...
def generate_subexpr_disposal_code(self, code) -> None: ...
def free_subexpr_temps(self, code) -> None: ...
def annotate(self, code) -> None: ...
class CascadedCmpNode(Node, CmpNode):
child_attrs: Incomplete
cascade: Incomplete
coerced_operand2: Incomplete
constant_result = constant_value_not_set
def infer_type(self, env): ...
def type_dependencies(self, env): ...
def has_constant_result(self): ...
operand2: Incomplete
def analyse_types(self, env): ...
def has_python_operands(self): ...
def is_cpp_comparison(self): ...
is_pycmp: bool
type: Incomplete
def optimise_comparison(self, operand1, env, result_is_bool: bool = ...): ...
def coerce_operands_to_pyobjects(self, env) -> None: ...
def coerce_cascaded_operands_to_temp(self, env) -> None: ...
def generate_evaluation_code(self, code, result, operand1, needs_evaluation: bool = ...) -> None: ...
def annotate(self, code) -> None: ...
binop_node_classes: Incomplete
def binop_node(pos, operator, operand1, operand2, inplace: bool = ..., **kwargs): ...
class CoercionNode(ExprNode):
subexprs: Incomplete
constant_result = not_a_constant
arg: Incomplete
def __init__(self, arg) -> None: ...
def calculate_constant_result(self) -> None: ...
def annotate(self, code) -> None: ...
class CoerceToMemViewSliceNode(CoercionNode):
type: Incomplete
is_temp: int
use_managed_ref: bool
arg: Incomplete
def __init__(self, arg, dst_type, env) -> None: ...
def generate_result_code(self, code) -> None: ...
class CastNode(CoercionNode):
type: Incomplete
def __init__(self, arg, new_type) -> None: ...
def may_be_none(self): ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
class PyTypeTestNode(CoercionNode):
exact_builtin_type: bool
type: Incomplete
result_ctype: Incomplete
notnone: Incomplete
def __init__(self, arg, dst_type, env, notnone: bool = ...) -> None: ...
nogil_check: Incomplete
gil_message: str
def analyse_types(self, env): ...
def may_be_none(self): ...
def is_simple(self): ...
def result_in_temp(self): ...
def is_ephemeral(self): ...
def nonlocally_immutable(self): ...
def reanalyse(self): ...
def calculate_constant_result(self) -> None: ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
def generate_post_assignment_code(self, code) -> None: ...
def allocate_temp_result(self, code) -> None: ...
def release_temp_result(self, code) -> None: ...
def free_temps(self, code) -> None: ...
def free_subexpr_temps(self, code) -> None: ...
class NoneCheckNode(CoercionNode):
is_nonecheck: bool
type: Incomplete
result_ctype: Incomplete
exception_type_cname: Incomplete
exception_message: Incomplete
exception_format_args: Incomplete
def __init__(self, arg, exception_type_cname, exception_message, exception_format_args=...) -> None: ...
nogil_check: Incomplete
def analyse_types(self, env): ...
def may_be_none(self): ...
def is_simple(self): ...
def result_in_temp(self): ...
def nonlocally_immutable(self): ...
def calculate_result_code(self): ...
def condition(self): ...
@classmethod
def generate(cls, arg, code, exception_message, exception_type_cname: str = ..., exception_format_args=..., in_nogil_context: bool = ...) -> None: ...
@classmethod
def generate_if_needed(cls, arg, code, exception_message, exception_type_cname: str = ..., exception_format_args=..., in_nogil_context: bool = ...) -> None: ...
def put_nonecheck(self, code) -> None: ...
def generate_result_code(self, code) -> None: ...
def generate_post_assignment_code(self, code) -> None: ...
def free_temps(self, code) -> None: ...
class CoerceToPyTypeNode(CoercionNode):
type = py_object_type
target_type = py_object_type
is_temp: int
def __init__(self, arg, env, type=...) -> None: ...
gil_message: str
def may_be_none(self): ...
def coerce_to_boolean(self, env): ...
def coerce_to_integer(self, env): ...
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
class CoerceIntToBytesNode(CoerceToPyTypeNode):
is_temp: int
type: Incomplete
def __init__(self, arg, env) -> None: ...
def generate_result_code(self, code) -> None: ...
class CoerceFromPyTypeNode(CoercionNode):
type: Incomplete
is_temp: int
def __init__(self, result_type, arg, env) -> None: ...
def analyse_types(self, env): ...
def is_ephemeral(self): ...
def generate_result_code(self, code) -> None: ...
def nogil_check(self, env) -> None: ...
class CoerceToBooleanNode(CoercionNode):
type: Incomplete
is_temp: int
def __init__(self, arg, env) -> None: ...
def nogil_check(self, env) -> None: ...
gil_message: str
def check_const(self): ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
class CoerceToComplexNode(CoercionNode):
type: Incomplete
def __init__(self, arg, dst_type, env) -> None: ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
class CoerceToTempNode(CoercionNode):
type: Incomplete
constant_result: Incomplete
is_temp: int
result_ctype: Incomplete
def __init__(self, arg, env) -> None: ...
gil_message: str
def analyse_types(self, env): ...
arg: Incomplete
def coerce_to_boolean(self, env): ...
def generate_result_code(self, code) -> None: ...
class ProxyNode(CoercionNode):
nogil_check: Incomplete
constant_result: Incomplete
def __init__(self, arg) -> None: ...
arg: Incomplete
def analyse_types(self, env): ...
def infer_type(self, env): ...
def generate_result_code(self, code) -> None: ...
def result(self): ...
def is_simple(self): ...
def may_be_none(self): ...
def generate_evaluation_code(self, code) -> None: ...
def generate_disposal_code(self, code) -> None: ...
def free_temps(self, code) -> None: ...
class CloneNode(CoercionNode):
subexprs: Incomplete
nogil_check: Incomplete
constant_result: Incomplete
type: Incomplete
result_ctype: Incomplete
entry: Incomplete
def __init__(self, arg) -> None: ...
def result(self): ...
def may_be_none(self): ...
def type_dependencies(self, env): ...
def infer_type(self, env): ...
is_temp: int
def analyse_types(self, env): ...
def coerce_to(self, dest_type, env): ...
def is_simple(self): ...
def generate_evaluation_code(self, code) -> None: ...
def generate_result_code(self, code) -> None: ...
def generate_disposal_code(self, code) -> None: ...
def free_temps(self, code) -> None: ...
class CMethodSelfCloneNode(CloneNode):
def coerce_to(self, dst_type, env): ...
class ModuleRefNode(ExprNode):
type = py_object_type
is_temp: bool
subexprs: Incomplete
def analyse_types(self, env): ...
def may_be_none(self): ...
def calculate_result_code(self): ...
def generate_result_code(self, code) -> None: ...
class DocstringRefNode(ExprNode):
subexprs: Incomplete
type = py_object_type
is_temp: bool
body: Incomplete
def __init__(self, pos, body) -> None: ...
def analyse_types(self, env): ...
def generate_result_code(self, code) -> None: ...
pyerr_occurred_withgil_utility_code: Incomplete
raise_unbound_local_error_utility_code: Incomplete
raise_closure_name_error_utility_code: Incomplete
raise_unbound_memoryview_utility_code_nogil: Incomplete
raise_too_many_values_to_unpack: Incomplete
raise_need_more_values_to_unpack: Incomplete
tuple_unpacking_error_code: Incomplete
Raw
ModuleNode.pyi
from Cython.Compiler import Annotate as Annotate, Code as Code, Future as Future, Naming as Naming, Nodes as Nodes, Options as Options, PyrexTypes as PyrexTypes, Pythran as Pythran, TypeSlots as TypeSlots
from Cython.Utils import build_hex_version as build_hex_version, decode_filename as decode_filename, open_new_file as open_new_file, replace_suffix as replace_suffix
from Cython.Compiler.Code import IncludeCode as IncludeCode, UtilityCode as UtilityCode
from Cython.Compiler.Errors import error as error, warning as warning
from Cython.Compiler.PyrexTypes import CPtrType as CPtrType, py_object_type as py_object_type
from Cython.Compiler.Pythran import has_np_pythran as has_np_pythran
from Cython.Compiler.StringEncoding import EncodedString as EncodedString
from _typeshed import Incomplete
def check_c_declarations_pxd(module_node): ...
def check_c_declarations(module_node): ...
def generate_c_code_config(env, options): ...
class ModuleNode(Nodes.Node, Nodes.BlockNode):
child_attrs: Incomplete
directives: Incomplete
full_module_name: str
def merge_in(self, tree, scope, merge_scope: bool = ...) -> None: ...
def analyse_declarations(self, env) -> None: ...
def prepare_utility_code(self) -> None: ...
referenced_modules: Incomplete
def process_implementation(self, options, result) -> None: ...
def has_imported_c_functions(self): ...
def generate_h_code(self, env, options, result): ...
def generate_public_declaration(self, entry, h_code, i_code) -> None: ...
def api_name(self, env): ...
def generate_api_code(self, env, options, result): ...
def generate_cclass_header_code(self, type, h_code) -> None: ...
def generate_cclass_include_code(self, type, i_code) -> None: ...
def generate_c_code(self, env, options, result) -> None: ...
def find_referenced_modules(self, env, module_list, modules_seen) -> None: ...
def sort_types_by_inheritance(self, type_dict, type_order, getkey): ...
def sort_type_hierarchy(self, module_list, env): ...
def sort_cdef_classes(self, env) -> None: ...
def generate_type_definitions(self, env, modules, vtab_list, vtabslot_list, code) -> None: ...
def generate_declarations_for_modules(self, env, modules, globalstate) -> None: ...
def generate_module_preamble(self, env, options, cimported_modules, metadata, code) -> None: ...
def generate_extern_c_macro_definition(self, code) -> None: ...
def generate_dl_import_macro(self, code) -> None: ...
def generate_includes(self, env, cimported_modules, code, early: bool = ..., late: bool = ...) -> None: ...
def generate_filename_table(self, code) -> None: ...
def generate_type_predeclarations(self, env, code) -> None: ...
def generate_type_header_code(self, type_entries, code) -> None: ...
def generate_gcc33_hack(self, env, code) -> None: ...
def generate_typedef(self, entry, code) -> None: ...
def sue_predeclaration(self, type, kind, name): ...
def generate_struct_union_predeclaration(self, entry, code) -> None: ...
def sue_header_footer(self, type, kind, name): ...
def generate_struct_union_definition(self, entry, code) -> None: ...
def generate_cpp_class_definition(self, entry, code) -> None: ...
def generate_enum_definition(self, entry, code) -> None: ...
def generate_typeobj_predeclaration(self, entry, code) -> None: ...
def generate_exttype_vtable_struct(self, entry, code) -> None: ...
def generate_exttype_vtabptr_declaration(self, entry, code) -> None: ...
def generate_exttype_final_methods_declaration(self, entry, code) -> None: ...
def generate_objstruct_predeclaration(self, type, code) -> None: ...
def generate_objstruct_definition(self, type, code) -> None: ...
def generate_c_class_declarations(self, env, code, definition) -> None: ...
def generate_cvariable_declarations(self, env, code, definition) -> None: ...
def generate_cfunction_declarations(self, env, code, definition) -> None: ...
def generate_variable_definitions(self, env, code) -> None: ...
def generate_typeobj_definitions(self, env, code) -> None: ...
def generate_exttype_vtable(self, scope, code) -> None: ...
def generate_self_cast(self, scope, code) -> None: ...
def generate_new_function(self, scope, code, cclass_entry) -> None: ...
def generate_dealloc_function(self, scope, code) -> None: ...
def generate_usr_dealloc_call(self, scope, code) -> None: ...
def generate_traverse_function(self, scope, code, cclass_entry) -> None: ...
def generate_clear_function(self, scope, code, cclass_entry) -> None: ...
def generate_getitem_int_function(self, scope, code) -> None: ...
def generate_ass_subscript_function(self, scope, code) -> None: ...
def generate_guarded_basetype_call(self, base_type, substructure, slot, args, code) -> None: ...
def generate_ass_slice_function(self, scope, code) -> None: ...
def generate_richcmp_function(self, scope, code) -> None: ...
def generate_getattro_function(self, scope, code): ...
def generate_setattro_function(self, scope, code) -> None: ...
def generate_descr_get_function(self, scope, code) -> None: ...
def generate_descr_set_function(self, scope, code) -> None: ...
def generate_property_accessors(self, cclass_scope, code) -> None: ...
def generate_property_get_function(self, property_entry, code) -> None: ...
def generate_property_set_function(self, property_entry, code) -> None: ...
def generate_typeobj_definition(self, modname, entry, code) -> None: ...
def generate_method_table(self, env, code) -> None: ...
def generate_dict_getter_function(self, scope, code) -> None: ...
def generate_getset_table(self, env, code) -> None: ...
def create_import_star_conversion_utility_code(self, env) -> None: ...
def generate_import_star(self, env, code) -> None: ...
def generate_module_init_func(self, imported_modules, env, code) -> None: ...
cfunc_name: Incomplete
description: Incomplete
tempdecl_code: Incomplete
call_code: Incomplete
def mod_init_subfunction(self, pos, scope, orig_code): ...
def generate_module_import_setup(self, env, code) -> None: ...
def generate_module_cleanup_func(self, env, code) -> None: ...
def generate_main_method(self, env, code) -> None: ...
def mod_init_func_cname(self, prefix, env): ...
def generate_pymoduledef_struct(self, env, code) -> None: ...
def generate_module_creation_code(self, env, code) -> None: ...
def generate_global_init_code(self, env, code) -> None: ...
def generate_wrapped_entries_code(self, env, code) -> None: ...
def generate_c_variable_export_code(self, env, code) -> None: ...
def generate_c_function_export_code(self, env, code) -> None: ...
def generate_type_import_code_for_module(self, module, env, code) -> None: ...
def specialize_fused_types(self, pxd_env) -> None: ...
def generate_c_variable_import_code_for_module(self, module, env, code) -> None: ...
def generate_c_function_import_code_for_module(self, module, env, code) -> None: ...
def generate_type_init_code(self, env, code) -> None: ...
def generate_base_type_import_code(self, env, entry, code, import_generator) -> None: ...
def generate_type_import_code(self, env, type, pos, code, import_generator) -> None: ...
def generate_type_import_call(self, type, code, import_generator, error_code: Incomplete | None = ..., error_pos: Incomplete | None = ...) -> None: ...
def generate_type_ready_code(self, entry, code) -> None: ...
def generate_exttype_vtable_init_code(self, entry, code) -> None: ...
class ModuleImportGenerator:
code: Incomplete
imported: Incomplete
temps: Incomplete
def __init__(self, code, imported_modules: Incomplete | None = ...) -> None: ...
def imported_module(self, module_name_string, error_code): ...
def __enter__(self): ...
def __exit__(self, *exc) -> None: ...
def generate_cfunction_declaration(entry, env, code, definition) -> None: ...
refnanny_utility_code: Incomplete
packed_struct_utility_code: Incomplete
capsule_utility_code: Incomplete
Raw
Nodes.pyi
# NOTE I haven't gotten to everything yet but I will change these and resolve more variables
# as I go along with my project known as CyStub...
# see: https://github.com/Vizonex/CyStub
from Cython import Builtin as Builtin, DebugFlags as DebugFlags, Future as Future, Naming as Naming, Options as Options, PyrexTypes as PyrexTypes, TypeSlots as TypeSlots
from Cython.Utils import add_metaclass as add_metaclass
from Cython.Compiler.Code import UtilityCode as UtilityCode
from Cython.Compiler.Errors import CompileError as CompileError, InternalError as InternalError, error as error, warning as warning
from Cython.Compiler.PyrexTypes import error_type as error_type, py_object_type as py_object_type
from Cython.Compiler.Pythran import has_np_pythran as has_np_pythran, is_pythran_buffer as is_pythran_buffer, pythran_type as pythran_type
from Cython.Compiler.StringEncoding import EncodedString as EncodedString
from Cython.Compiler.Symtab import ClosureScope as ClosureScope, CppClassScope as CppClassScope, LocalScope as LocalScope, ModuleScope as ModuleScope, PyClassScope as PyClassScope, StructOrUnionScope as StructOrUnionScope, TemplateScope as TemplateScope
from Cython.Compiler.ExprNodes import *
from Cython.Compiler.Code import PyObjectConst
from _typeshed import Incomplete
from typing import Literal
def relative_position(pos): ...
def embed_position(pos, docstring): ...
def analyse_type_annotation(annotation, env, assigned_value: Incomplete | None = ...): ...
def write_func_call(func, codewriter_class): ...
class VerboseCodeWriter(type):
def __new__(cls, name, bases, attrs): ...
class CheckAnalysers(type):
methods: set[str]
def __new__(cls, name, bases, attrs): ...
class Node:
is_name: int
is_none: int
is_nonecheck: int
is_literal: int
is_terminator: int
is_wrapper: bool
temps: Incomplete
child_attrs: list[str] | None
outer_attrs: list | None
cf_state: Incomplete
coercion_type: Incomplete
pos: tuple[str, int, int]
def __init__(self, pos, **kw) -> None: ...
gil_message: str
nogil_check: Incomplete
in_nogil_context: bool
def gil_error(self, env: Incomplete | None = ...) -> None: ...
cpp_message: str
def cpp_check(self, env) -> None: ...
def cpp_error(self) -> None: ...
def clone_node(self): ...
def analyse_declarations(self, env) -> None: ...
def analyse_expressions(self, env) -> None: ...
def generate_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
def end_pos(self): ...
def dump(self, level: int = ..., filter_out=..., cutoff: int = ..., encountered: Incomplete | None = ...): ...
def dump_pos(self, mark_column: bool = ..., marker: str = ...): ...
class CompilerDirectivesNode(Node):
def analyse_declarations(self, env) -> None: ...
body: Incomplete
def analyse_expressions(self, env): ...
def generate_function_definitions(self, env, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
class BlockNode:
def generate_cached_builtins_decls(self, env, code) -> None: ...
def generate_lambda_definitions(self, env, code) -> None: ...
class StatListNode(Node):
@staticmethod
def create_analysed(pos, env, *args, **kw): ...
def analyse_declarations(self, env) -> None: ...
stats: Incomplete
def analyse_expressions(self, env): ...
def generate_function_definitions(self, env, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
class StatNode(Node):
def generate_function_definitions(self, env, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
class CDefExternNode(StatNode):
def analyse_declarations(self, env) -> None: ...
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
class CDeclaratorNode(Node):
name:str
calling_convention: str
def analyse_templates(self) -> None: ...
class CNameDeclaratorNode(CDeclaratorNode):
default: None | ExprNode
name: str
cname: str | None
type: Incomplete
def analyse(self, base_type, env, nonempty: int = ..., visibility: Incomplete | None = ..., in_pxd: bool = ...): ...
class CPtrDeclaratorNode(CDeclaratorNode):
def analyse_templates(self): ...
def analyse(self, base_type, env, nonempty: int = ..., visibility: Incomplete | None = ..., in_pxd: bool = ...): ...
class CReferenceDeclaratorNode(CDeclaratorNode):
def analyse_templates(self): ...
def analyse(self, base_type, env, nonempty: int = ..., visibility: Incomplete | None = ..., in_pxd: bool = ...): ...
class CArrayDeclaratorNode(CDeclaratorNode):
dimension: Incomplete
def analyse(self, base_type, env, nonempty: int = ..., visibility: Incomplete | None = ..., in_pxd: bool = ...): ...
class CFuncDeclaratorNode(CDeclaratorNode):
overridable: int
optional_arg_count: int
is_const_method: int
templates: Incomplete
base: Incomplete
def analyse_templates(self): ...
exception_value: Incomplete
def analyse(self, return_type, env, nonempty: int = ..., directive_locals: Incomplete | None = ..., visibility: Incomplete | None = ..., in_pxd: bool = ...): ...
def declare_optional_arg_struct(self, func_type, env, fused_cname: Incomplete | None = ...) -> None: ...
class CConstDeclaratorNode(CDeclaratorNode):
def analyse(self, base_type, env, nonempty: int = ..., visibility: Incomplete | None = ..., in_pxd: bool = ...): ...
class CArgDeclNode(Node):
outer_attrs: Incomplete
is_self_arg: int
is_type_arg: int
is_generic: int
declarator:CDeclaratorNode
kw_only: int
not_none: int
or_none: int
type: Incomplete
name_declarator: Incomplete
default_value: PyObjectConst | None
annotation: ExprNode | None
is_dynamic: int
def analyse(self, env, nonempty: int = ..., is_self_arg: bool = ...): ...
base_type:CBaseTypeNode
def inject_type_from_annotations(self, env): ...
def calculate_default_value_code(self, code): ...
def annotate(self, code) -> None: ...
def generate_assignment_code(self, code, target: Incomplete | None = ..., overloaded_assignment: bool = ...) -> None: ...
class CBaseTypeNode(Node):
def analyse_as_type(self, env): ...
class CAnalysedBaseTypeNode(Node):
def analyse(self, env, could_be_name: bool = ...): ...
class CSimpleBaseTypeNode(CBaseTypeNode):
arg_name: Incomplete
module_path: Incomplete
is_basic_c_type: bool
complex: bool
name:str
module_path:list
signed:int
def analyse(self, env, could_be_name: bool = ...): ...
class MemoryViewSliceTypeNode(CBaseTypeNode):
name: str
type: Incomplete
def analyse(self, env, could_be_name: bool = ...): ...
def use_memview_utilities(self, env) -> None: ...
class CNestedBaseTypeNode(CBaseTypeNode):
def analyse(self, env, could_be_name: Incomplete | None = ...): ...
class TemplatedTypeNode(CBaseTypeNode):
dtype_node: Incomplete
name: Incomplete
type: Incomplete
array_declarator: Incomplete
def analyse(self, env, could_be_name: bool = ..., base_type: Incomplete | None = ...): ...
class CComplexBaseTypeNode(CBaseTypeNode):
def analyse(self, env, could_be_name: bool = ...): ...
class CTupleBaseTypeNode(CBaseTypeNode):
def analyse(self, env, could_be_name: bool = ...): ...
class FusedTypeNode(CBaseTypeNode):
def analyse_declarations(self, env) -> None: ...
def analyse(self, env, could_be_name: bool = ...): ...
class CConstTypeNode(CBaseTypeNode):
def analyse(self, env, could_be_name: bool = ...): ...
class CVarDefNode(StatNode):
visibility: Literal["public" , "private" , "extern"]
base_type:CBaseTypeNode
decorators: Incomplete
declarators:list[CDeclaratorNode]
directive_locals: Incomplete
dest_scope: Incomplete
entry: Incomplete
overridable:bool
api:bool
in_pxd:bool
decorators:list
def analyse_declarations(self, env, dest_scope: Incomplete | None = ...): ...
class CStructOrUnionDefNode(StatNode):
entry: Incomplete
def declare(self, env, scope: Incomplete | None = ...) -> None: ...
def analyse_declarations(self, env) -> None: ...
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class CppClassNode(CStructOrUnionDefNode, BlockNode):
decorators: Incomplete
entry: Incomplete
def declare(self, env) -> None: ...
body: Incomplete
scope: Incomplete
def analyse_declarations(self, env): ...
def analyse_expressions(self, env): ...
def generate_function_definitions(self, env, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
class CEnumDefNode(StatNode):
name: str | None
cname : str | None
typedef_flag:bool
api:bool
in_pxd:bool
create_wrapper:bool
visibility:Literal["public" , "private" , "extern"]
entry: Symtab.Entry | None
def declare(self, env) -> None: ...
def analyse_declarations(self, env) -> None: ...
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class CEnumDefItemNode(StatNode):
value: Incomplete
def analyse_declarations(self, env, enum_entry) -> None: ...
class CTypeDefNode(StatNode):
def analyse_declarations(self, env) -> None: ...
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class FuncDefNode(StatNode, BlockNode):
py_func:PyClassDefNode | None
needs_closure: bool
needs_outer_scope: bool
pymethdef_required: bool
is_generator: bool
is_generator_body: bool
is_async_def: bool
modifiers: Incomplete
has_fused_arguments: bool
star_arg: Incomplete
starstar_arg: Incomplete
is_cyfunction: bool
code_object: Incomplete
def analyse_default_values(self, env) -> None: ...
def analyse_annotation(self, env, annotation): ...
def analyse_annotations(self, env) -> None: ...
def align_argument_type(self, env, arg): ...
def need_gil_acquisition(self, lenv): ...
local_scope: Incomplete
def create_local_scope(self, env): ...
def generate_function_body(self, env, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def declare_argument(self, env, arg): ...
def generate_arg_type_test(self, arg, code) -> None: ...
def generate_arg_none_check(self, arg, code) -> None: ...
def generate_wrapper_functions(self, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
def getbuffer_check(self, code) -> None: ...
def getbuffer_init(self, code) -> None: ...
def getbuffer_error_cleanup(self, code) -> None: ...
def getbuffer_normal_cleanup(self, code) -> None: ...
def get_preprocessor_guard(self): ...
class CFuncDefNode(FuncDefNode):
inline_in_pxd: bool
decorators: Incomplete
directive_locals: Incomplete
directive_returns: Incomplete
override: Incomplete
template_declaration: Incomplete
is_const_method: bool
py_func_stat: Incomplete
def unqualified_name(self): ...
@property
def code_object(self): ...
is_c_class_method: Incomplete
is_static_method: Incomplete
type: Incomplete
cfunc_declarator: Incomplete
args: Incomplete
has_fused_arguments: bool
entry: Incomplete
return_type: Incomplete
overridable: bool
def analyse_declarations(self, env) -> None: ...
py_func:FuncDefNode | None
body: StatListNode
def declare_cpdef_wrapper(self, env) -> None: ...
def call_self_node(self, omit_optional_args: int = ..., is_module_scope: int = ...): ...
def declare_arguments(self, env) -> None: ...
def need_gil_acquisition(self, lenv): ...
def nogil_check(self, env) -> None: ...
acquire_gil: bool
def analyse_expressions(self, env): ...
def needs_assignment_synthesis(self, env, code: Incomplete | None = ...): ...
def generate_function_header(self, code, with_pymethdef, with_opt_args: int = ..., with_dispatch: int = ..., cname: Incomplete | None = ...) -> None: ...
def generate_argument_declarations(self, env, code) -> None: ...
def generate_keyword_list(self, code) -> None: ...
def generate_argument_parsing_code(self, env, code) -> None: ...
def generate_argument_conversion_code(self, code) -> None: ...
def generate_argument_type_tests(self, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
def error_value(self): ...
def caller_will_check_exceptions(self): ...
def generate_wrapper_functions(self, code) -> None: ...
class PyArgDeclNode(Node):
is_self_arg: bool
is_type_arg: bool
def generate_function_definitions(self, env, code) -> None: ...
class DecoratorNode(Node):
decorator : NameNode | CallNode | AttributeNode
class DefNode(FuncDefNode):
name:str
lambda_name:str
outer_attrs: Incomplete
is_staticmethod: bool
args:list[CArgDeclNode]
is_classmethod: bool
reqd_kw_flags_cname: str
is_wrapper: int
no_assignment_synthesis: int
decorators: list[DecoratorNode]
return_type_annotation: ExprNode | None
entry: Symtab.Entry
acquire_gil: int
self_in_stararg: int
py_cfunc_node: Incomplete
requires_classobj: bool
defaults_struct: Incomplete
doc: EncodedString | None
body: StatListNode
fused_py_func: bool
specialized_cpdefs: Incomplete
py_wrapper: Incomplete
py_wrapper_required: bool
func_cname: Incomplete
defaults_getter: Incomplete
num_kwonly_args: int
num_required_kw_args: int
num_required_args: int
def __init__(self, pos, **kwds) -> None: ...
def as_cfunction(self, cfunc: Incomplete | None = ..., scope: Incomplete | None = ..., overridable: bool = ..., returns: Incomplete | None = ..., except_val: Incomplete | None = ..., modifiers: Incomplete | None = ..., nogil: bool = ..., with_gil: bool = ...): ...
def is_cdef_func_compatible(self): ...
return_type: Incomplete
def analyse_declarations(self, env) -> None: ...
directive_locals: Incomplete
has_fused_arguments: bool
np_args_idx: Incomplete
def analyse_argument_types(self, env) -> None: ...
def analyse_signature(self, env) -> None: ...
def bad_signature(self) -> None: ...
def declare_pyfunction(self, env) -> None: ...
def declare_lambda_function(self, env) -> None: ...
def declare_arguments(self, env) -> None: ...
def declare_python_arg(self, env, arg) -> None: ...
def analyse_expressions(self, env): ...
def needs_assignment_synthesis(self, env, code: Incomplete | None = ...): ...
def error_value(self): ...
def caller_will_check_exceptions(self): ...
def generate_function_definitions(self, env, code) -> None: ...
def generate_function_header(self, code, with_pymethdef, proto_only: int = ...): ...
def generate_argument_declarations(self, env, code) -> None: ...
def generate_keyword_list(self, code) -> None: ...
def generate_argument_parsing_code(self, env, code) -> None: ...
def generate_argument_type_tests(self, code) -> None: ...
class DefNodeWrapper(FuncDefNode):
defnode: Incomplete
target: Incomplete
num_kwonly_args: Incomplete
num_required_kw_args: Incomplete
num_required_args: Incomplete
self_in_stararg: Incomplete
signature: Incomplete
def __init__(self, *args, **kwargs) -> None: ...
np_args_idx: Incomplete
def analyse_declarations(self, env) -> None: ...
def prepare_argument_coercion(self, env) -> None: ...
def signature_has_nongeneric_args(self): ...
def signature_has_generic_args(self): ...
def generate_function_body(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def generate_function_header(self, code, with_pymethdef, proto_only: int = ...) -> None: ...
def generate_argument_declarations(self, env, code) -> None: ...
def generate_argument_parsing_code(self, env, code) -> None: ...
def generate_arg_xdecref(self, arg, code) -> None: ...
def generate_arg_decref(self, arg, code) -> None: ...
def generate_stararg_copy_code(self, code) -> None: ...
def generate_tuple_and_keyword_parsing_code(self, args, success_label, code) -> None: ...
def generate_arg_assignment(self, arg, item, code) -> None: ...
def generate_stararg_init_code(self, max_positional_args, code) -> None: ...
def generate_argument_values_setup_code(self, args, code) -> None: ...
def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args, has_fixed_positional_count, has_kw_only_args, all_args, argtuple_error_label, code) -> None: ...
def generate_optional_kwonly_args_unpacking_code(self, all_args, code) -> None: ...
def generate_argument_conversion_code(self, code) -> None: ...
def generate_arg_conversion(self, arg, code) -> None: ...
def generate_arg_conversion_from_pyobject(self, arg, code) -> None: ...
def generate_arg_conversion_to_pyobject(self, arg, code) -> None: ...
def generate_argument_type_tests(self, code) -> None: ...
def error_value(self): ...
class GeneratorDefNode(DefNode):
is_generator: bool
is_coroutine: bool
is_iterable_coroutine: bool
is_asyncgen: bool
gen_type_name: str
needs_closure: bool
def __init__(self, pos, **kwargs) -> None: ...
def analyse_declarations(self, env) -> None: ...
def generate_function_body(self, env, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
class AsyncDefNode(GeneratorDefNode):
gen_type_name: str
is_coroutine: bool
class IterableAsyncDefNode(AsyncDefNode):
gen_type_name: str
is_iterable_coroutine: bool
class AsyncGenNode(AsyncDefNode):
gen_type_name: str
is_asyncgen: bool
class GeneratorBodyDefNode(DefNode):
is_generator_body: bool
is_inlined: bool
is_async_gen_body: bool
inlined_comprehension_type: Incomplete
def __init__(self, pos: Incomplete | None = ..., name: Incomplete | None = ..., body: Incomplete | None = ..., is_async_gen_body: bool = ...) -> None: ...
entry: Incomplete
def declare_generator_body(self, env) -> None: ...
def analyse_declarations(self, env) -> None: ...
def generate_function_header(self, code, proto: bool = ...) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
class OverrideCheckNode(StatNode):
body: StatListNode | ReturnStatNode | None
args: Incomplete
func_node: Incomplete
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class ClassDefNode(StatNode, BlockNode):
class_name:str
class PyClassDefNode(ClassDefNode):
# A Python class definition.
#
# name EncodedString Name of the class
# doc string or None
# body StatNode Attribute definition code
# entry Symtab.Entry
# scope PyClassScope
# decorators [DecoratorNode] list of decorators or None
#
# The following subnodes are constructed internally:
#
# dict DictNode Class dictionary or Py3 namespace
# classobj ClassNode Class object
# target NameNode Variable to assign class object to
decorators: list[DecoratorNode]
class_result: Incomplete
is_py3_style_class: bool
metaclass: Incomplete
mkw: Incomplete
name: EncodedString
entry : Symtab.Entry
doc: str | None
scope : PyClassScope
body: StatNode
bases: Incomplete
dict: DictNode
classobj: ClassNode
target: NameNode
class_cell: Incomplete
def __init__(self, pos, name, bases, doc, body, decorators: Incomplete | None = ..., keyword_args: Incomplete | None = ..., force_py3_semantics: bool = ...) -> None: ...
def as_cclass(self): ...
def create_scope(self, env): ...
def analyse_declarations(self, env) -> None: ...
def analyse_expressions(self, env): ...
def generate_function_definitions(self, env, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
class CClassDefNode(ClassDefNode):
buffer_defaults_node: Incomplete
buffer_defaults_pos: Incomplete
typedef_flag: bool
api: bool
objstruct_name: Incomplete
typeobj_name: Incomplete
check_size: Incomplete
decorators: Incomplete
shadow: bool
def buffer_defaults(self, env): ...
entry: Incomplete
def declare(self, env) -> None: ...
base_type: Incomplete
module: Incomplete
scope: Incomplete
type_init_args: Incomplete
def analyse_declarations(self, env): ...
body: Incomplete
def analyse_expressions(self, env): ...
def generate_function_definitions(self, env, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
@staticmethod
def generate_type_ready_code(entry, code, heap_type_bases: bool = ...) -> None: ...
def annotate(self, code) -> None: ...
class PropertyNode(StatNode):
entry: Incomplete
def analyse_declarations(self, env) -> None: ...
body: Incomplete
def analyse_expressions(self, env): ...
def generate_function_definitions(self, env, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
class GlobalNode(StatNode):
def analyse_declarations(self, env) -> None: ...
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class NonlocalNode(StatNode):
def analyse_declarations(self, env) -> None: ...
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class ExprStatNode(StatNode):
__class__: Incomplete
def analyse_declarations(self, env) -> None: ...
expr: ExprNode
def analyse_expressions(self, env): ...
def nogil_check(self, env) -> None: ...
gil_message: str
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class AssignmentNode(StatNode):
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class SingleAssignmentNode(AssignmentNode):
first: bool
is_overloaded_assignment: bool
declaration_only: bool
rhs: Incomplete
def analyse_declarations(self, env) -> None: ...
lhs: Incomplete
exception_check: Incomplete
exception_value: Incomplete
def analyse_types(self, env, use_temp: int = ...): ...
def unroll(self, node, target_size, env): ...
def unroll_assignments(self, refs, check_node, lhs_list, rhs_list, env): ...
def unroll_rhs(self, env): ...
def unroll_lhs(self, env): ...
def generate_rhs_evaluation_code(self, code) -> None: ...
def generate_assignment_code(self, code, overloaded_assignment: bool = ...) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class CascadedAssignmentNode(AssignmentNode):
cloned_values: Incomplete
coerced_values: Incomplete
assignment_overloads: Incomplete
def analyse_declarations(self, env) -> None: ...
rhs: Incomplete
def analyse_types(self, env, use_temp: int = ...): ...
def generate_rhs_evaluation_code(self, code) -> None: ...
def generate_assignment_code(self, code, overloaded_assignment: bool = ...) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class ParallelAssignmentNode(AssignmentNode):
def analyse_declarations(self, env) -> None: ...
stats: Incomplete
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class InPlaceAssignmentNode(AssignmentNode):
def analyse_declarations(self, env) -> None: ...
rhs: Incomplete
lhs: Incomplete
def analyse_types(self, env): ...
def generate_execution_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
def create_binop_node(self): ...
class PrintStatNode(StatNode):
stream: Incomplete
arg_tuple: Incomplete
def analyse_expressions(self, env): ...
nogil_check: Incomplete
gil_message: str
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class ExecStatNode(StatNode):
def analyse_expressions(self, env): ...
nogil_check: Incomplete
gil_message: str
def generate_execution_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
class DelStatNode(StatNode):
ignore_nonexisting: bool
def analyse_declarations(self, env) -> None: ...
def analyse_expressions(self, env): ...
def nogil_check(self, env) -> None: ...
gil_message: str
def generate_execution_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
class PassStatNode(StatNode):
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class IndirectionNode(StatListNode):
def __init__(self, stats) -> None: ...
class BreakStatNode(StatNode):
is_terminator: bool
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class ContinueStatNode(StatNode):
is_terminator: bool
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class ReturnStatNode(StatNode):
is_terminator: bool
in_generator: bool
in_async_gen: bool
in_parallel: bool
return_type: Incomplete
value: Incomplete
def analyse_expressions(self, env): ...
def nogil_check(self, env) -> None: ...
gil_message: str
def generate_execution_code(self, code) -> None: ...
def put_return(self, code, value) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class RaiseStatNode(StatNode):
is_terminator: bool
exc_type: Incomplete
exc_value: Incomplete
exc_tb: Incomplete
cause: Incomplete
builtin_exc_name: Incomplete
def analyse_expressions(self, env): ...
nogil_check: Incomplete
gil_message: str
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class ReraiseStatNode(StatNode):
is_terminator: bool
def analyse_expressions(self, env): ...
nogil_check: Incomplete
gil_message: str
def generate_execution_code(self, code) -> None: ...
class AssertStatNode(StatNode):
cond: Incomplete
value: Incomplete
def analyse_expressions(self, env): ...
nogil_check: Incomplete
gil_message: str
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class IfStatNode(StatNode):
def analyse_declarations(self, env) -> None: ...
if_clauses: Incomplete
else_clause: Incomplete
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class IfClauseNode(Node):
branch_hint: Incomplete
def analyse_declarations(self, env) -> None: ...
condition: Incomplete
body: Incomplete
def analyse_expressions(self, env): ...
def generate_execution_code(self, code, end_label, is_last) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class SwitchCaseNode(StatNode):
def generate_condition_evaluation_code(self, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class SwitchStatNode(StatNode):
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class LoopNode: ...
class WhileStatNode(LoopNode, StatNode):
def analyse_declarations(self, env) -> None: ...
condition: Incomplete
body: Incomplete
else_clause: Incomplete
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class DictIterationNextNode(Node):
coerced_key_var: Incomplete
key_ref: Incomplete
coerced_value_var: Incomplete
value_ref: Incomplete
coerced_tuple_var: Incomplete
tuple_ref: Incomplete
def __init__(self, dict_obj, expected_size, pos_index_var, key_target, value_target, tuple_target, is_dict_flag) -> None: ...
dict_obj: Incomplete
expected_size: Incomplete
pos_index_var: Incomplete
key_target: Incomplete
value_target: Incomplete
tuple_target: Incomplete
is_dict_flag: Incomplete
def analyse_expressions(self, env): ...
def generate_function_definitions(self, env, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
class SetIterationNextNode(Node):
coerced_value_var: Incomplete
value_ref: Incomplete
def __init__(self, set_obj, expected_size, pos_index_var, value_target, is_set_flag) -> None: ...
set_obj: Incomplete
expected_size: Incomplete
pos_index_var: Incomplete
value_target: Incomplete
is_set_flag: Incomplete
def analyse_expressions(self, env): ...
def generate_function_definitions(self, env, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
def ForStatNode(pos, **kw): ...
class _ForInStatNode(LoopNode, StatNode):
item: Incomplete
is_async: bool
def analyse_declarations(self, env) -> None: ...
target: Incomplete
iterator: Incomplete
body: Incomplete
else_clause: Incomplete
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class ForInStatNode(_ForInStatNode):
is_async: bool
class AsyncForStatNode(_ForInStatNode):
is_async: bool
def __init__(self, pos, **kw) -> None: ...
class ForFromStatNode(LoopNode, StatNode):
is_py_target: bool
loopvar_node: Incomplete
py_loopvar_node: Incomplete
from_range: bool
gil_message: str
def nogil_check(self, env) -> None: ...
def analyse_declarations(self, env) -> None: ...
target: Incomplete
bound1: Incomplete
bound2: Incomplete
step: Incomplete
body: Incomplete
else_clause: Incomplete
def analyse_expressions(self, env): ...
def set_up_loop(self, env) -> None: ...
def generate_execution_code(self, code) -> None: ...
relation_table: Incomplete
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class WithStatNode(StatNode):
enter_call: Incomplete
target_temp: Incomplete
def analyse_declarations(self, env) -> None: ...
manager: Incomplete
body: Incomplete
def analyse_expressions(self, env): ...
def generate_function_definitions(self, env, code) -> None: ...
exit_var: Incomplete
def generate_execution_code(self, code) -> None: ...
class WithTargetAssignmentStatNode(AssignmentNode):
with_node: Incomplete
rhs: Incomplete
def analyse_declarations(self, env) -> None: ...
lhs: Incomplete
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
def annotate(self, code) -> None: ...
class TryExceptStatNode(StatNode):
in_generator: bool
def analyse_declarations(self, env) -> None: ...
body: Incomplete
has_default_clause: Incomplete
else_clause: Incomplete
def analyse_expressions(self, env): ...
nogil_check: Incomplete
gil_message: str
def generate_execution_code(self, code) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class ExceptClauseNode(Node):
exc_value: Incomplete
excinfo_target: Incomplete
is_except_as: bool
def analyse_declarations(self, env) -> None: ...
function_name: Incomplete
target: Incomplete
body: Incomplete
def analyse_expressions(self, env): ...
def generate_handling_code(self, code, end_label) -> None: ...
def generate_function_definitions(self, env, code) -> None: ...
def annotate(self, code) -> None: ...
class TryFinallyStatNode(StatNode):
preserve_exception: int
handle_error_case: bool
func_return_type: Incomplete
finally_except_clause: Incomplete
is_try_finally_in_nogil: bool
in_generator: bool
@staticmethod
def create_analysed(pos, env, body, finally_clause): ...
def analyse_declarations(self, env) -> None: ...
body: Incomplete
finally_clause: Incomplete
def analyse_expressions(self, env): ...
nogil_check: Incomplete
gil_message: str
def generate_execution_code(self, code): ...
def generate_function_definitions(self, env, code) -> None: ...
def put_error_catcher(self, code, temps_to_clean_up, exc_vars, exc_lineno_cnames: Incomplete | None = ..., exc_filename_cname: Incomplete | None = ...) -> None: ...
def put_error_uncatcher(self, code, exc_vars, exc_lineno_cnames: Incomplete | None = ..., exc_filename_cname: Incomplete | None = ...) -> None: ...
def put_error_cleaner(self, code, exc_vars) -> None: ...
def annotate(self, code) -> None: ...
class NogilTryFinallyStatNode(TryFinallyStatNode):
preserve_exception: bool
nogil_check: Incomplete
class GILStatNode(NogilTryFinallyStatNode):
state_temp: Incomplete
state: Incomplete
def __init__(self, pos, state, body) -> None: ...
def create_state_temp_if_needed(self, pos, state, body) -> None: ...
def analyse_declarations(self, env): ...
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class GILExitNode(StatNode):
state_temp: Incomplete
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class EnsureGILNode(GILExitNode):
def generate_execution_code(self, code) -> None: ...
def cython_view_utility_code(): ...
utility_code_for_cimports: Incomplete
utility_code_for_imports: Incomplete
class CImportStatNode(StatNode):
is_absolute: bool
def analyse_declarations(self, env) -> None: ...
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class FromCImportStatNode(StatNode):
module_name: Incomplete
relative_level: Incomplete
imported_names: Incomplete
def analyse_declarations(self, env) -> None: ...
def declaration_matches(self, entry, kind): ...
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class FromImportStatNode(StatNode):
import_star: int
def analyse_declarations(self, env) -> None: ...
module: Incomplete
item: Incomplete
interned_items: Incomplete
def analyse_expressions(self, env): ...
def generate_execution_code(self, code) -> None: ...
class ParallelNode(Node):
nogil_check: Incomplete
class ParallelStatNode(StatNode, ParallelNode):
body: Incomplete
is_prange: bool
is_nested_prange: bool
error_label_used: bool
num_threads: Incomplete
chunksize: Incomplete
parallel_exc: Incomplete
parallel_pos_info: Incomplete
pos_info: Incomplete
critical_section_counter: int
assignments: Incomplete
seen_closure_vars: Incomplete
privates: Incomplete
assigned_nodes: Incomplete
def __init__(self, pos, **kwargs) -> None: ...
kwargs: Incomplete
def analyse_declarations(self, env) -> None: ...
def analyse_expressions(self, env): ...
def analyse_sharing_attributes(self, env) -> None: ...
def propagate_var_privatization(self, entry, pos, op, lastprivate) -> None: ...
def initialize_privates_to_nan(self, code, exclude: Incomplete | None = ...) -> None: ...
def evaluate_before_block(self, code, expr): ...
def put_num_threads(self, code) -> None: ...
modified_entries: Incomplete
def declare_closure_privates(self, code) -> None: ...
def release_closure_privates(self, code) -> None: ...
privatization_insertion_point: Incomplete
temps: Incomplete
def privatize_temps(self, code, exclude_temps=...) -> None: ...
def cleanup_temps(self, code) -> None: ...
old_loop_labels: Incomplete
old_error_label: Incomplete
old_return_label: Incomplete
begin_of_parallel_control_block_point: Incomplete
begin_of_parallel_control_block_point_after_decls: Incomplete
def setup_parallel_control_flow_block(self, code) -> None: ...
begin_of_parallel_block: Incomplete
def begin_parallel_block(self, code) -> None: ...
def end_parallel_block(self, code) -> None: ...
any_label_used: bool
breaking_label_used: bool
parallel_private_temps: Incomplete
def trap_parallel_exit(self, code, should_flush: bool = ...) -> None: ...
def save_parallel_vars(self, code) -> None: ...
def fetch_parallel_exception(self, code) -> None: ...
def restore_parallel_exception(self, code) -> None: ...
def restore_labels(self, code) -> None: ...
def end_parallel_control_flow_block(self, code, break_: bool = ..., continue_: bool = ..., return_: bool = ...) -> None: ...
buggy_platform_macro_condition: str
have_expect_condition: str
redef_condition: Incomplete
def undef_builtin_expect_apple_gcc_bug(self, code) -> None: ...
def redef_builtin_expect_apple_gcc_bug(self, code) -> None: ...
class ParallelWithBlockNode(ParallelStatNode):
valid_keyword_arguments: Incomplete
num_threads: Incomplete
def analyse_declarations(self, env) -> None: ...
privatization_insertion_point: Incomplete
def generate_execution_code(self, code) -> None: ...
class ParallelRangeNode(ParallelStatNode):
body: Incomplete
target: Incomplete
else_clause: Incomplete
args: Incomplete
start: Incomplete
stop: Incomplete
step: Incomplete
is_prange: bool
nogil: Incomplete
schedule: Incomplete
valid_keyword_arguments: Incomplete
iterator: Incomplete
def __init__(self, pos, **kwds) -> None: ...
def analyse_declarations(self, env) -> None: ...
index_type: Incomplete
names: Incomplete
def analyse_expressions(self, env): ...
def nogil_check(self, env) -> None: ...
def generate_execution_code(self, code) -> None: ...
privatization_insertion_point: Incomplete
def generate_loop(self, code, fmt_dict) -> None: ...
class CnameDecoratorNode(StatNode):
is_function: Incomplete
def analyse_declarations(self, env) -> None: ...
def mangle(self, cname): ...
node: Incomplete
def analyse_expressions(self, env): ...
def generate_function_definitions(self, env, code) -> None: ...
def generate_execution_code(self, code) -> None: ...
branch_prediction_macros: str
printing_utility_code: Incomplete
printing_one_utility_code: Incomplete
restore_exception_utility_code: Incomplete
raise_utility_code: Incomplete
get_exception_utility_code: Incomplete
swap_exception_utility_code: Incomplete
reset_exception_utility_code: Incomplete
traceback_utility_code: Incomplete
get_exception_tuple_utility_code: Incomplete
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment