From ff404d0e0e20637dcd1ec794c8270e4c6fa51933 Mon Sep 17 00:00:00 2001 From: niallsemple Date: Mon, 10 Aug 2026 08:41:27 +0100 Subject: [PATCH 1/3] [pony] Fix stubtest failures with pony 0.7.20 pony 0.7.20 renamed the first parameter of most methods from domain-specific names (translator, attr, wrapper, monad, ...) to `self` (and to `cls` on EntityMeta), which produced 924 stubtest errors on the daily run (#16175). - Rename first parameters to `self`/`cls` across the pony stubs - Add symbols new in 0.7.20: py23compat.PY313/PY314, Decompiler opcode handlers (CALL_KW, CONVERT_VALUE, FORMAT_SIMPLE, FORMAT_WITH_SPEC, LOAD_FAST_BORROW*, LOAD_FAST_LOAD_FAST, LOAD_SMALL_INT, POP_JUMP_IF_(NOT_)NONE, SET_FUNCTION_ATTRIBUTE, STORE_FAST_LOAD_FAST, STORE_FAST_STORE_FAST, TO_BOOL), decompiling.direct_jump_to_loop_ops / double_load_store_ops / slice_to_ast, QueryResultIterator.__iter__, utils.IntegerGenerator / PersistentPickler / PersistentUnpickler - Match runtime defaults for Decompiler.CALL_FUNCTION_EX(argc=1) and MAKE_FUNCTION(argc=0) Verified locally against pony==0.7.20: stubtest_third_party.py pony passes (was 924 errors), mypy_test.py stubs/pony and pyright pass, ruff check clean. --- stubs/pony/pony/orm/asttranslation.pyi | 202 ++++---- stubs/pony/pony/orm/core.pyi | 323 ++++++------ stubs/pony/pony/orm/dbapiprovider.pyi | 204 ++++---- stubs/pony/pony/orm/dbproviders/sqlite.pyi | 136 ++--- stubs/pony/pony/orm/dbschema.pyi | 58 +-- stubs/pony/pony/orm/decompiling.pyi | 182 ++++--- stubs/pony/pony/orm/serialization.pyi | 10 +- stubs/pony/pony/orm/sqlbuilding.pyi | 178 +++---- stubs/pony/pony/orm/sqltranslation.pyi | 548 ++++++++++----------- stubs/pony/pony/py23compat.pyi | 2 + stubs/pony/pony/utils/utils.pyi | 13 + 11 files changed, 945 insertions(+), 911 deletions(-) diff --git a/stubs/pony/pony/orm/asttranslation.pyi b/stubs/pony/pony/orm/asttranslation.pyi index 6b3cfcc0e7fe..ff6469b2cb23 100644 --- a/stubs/pony/pony/orm/asttranslation.pyi +++ b/stubs/pony/pony/orm/asttranslation.pyi @@ -13,11 +13,11 @@ post_method_caches: dict[type[ASTTranslator], dict[type[ast.AST], Callable[..., class ASTTranslator: tree: Incomplete - def __init__(translator, tree) -> None: ... - def dispatch(translator, node: ast.AST) -> None: ... - def call(translator, method: Callable[[ASTTranslator, ast.AST], _T], node: ast.AST) -> _T | None: ... - def default_pre(translator, node: ast.AST) -> None: ... - def default_post(translator, node: ast.AST) -> None: ... + def __init__(self, tree) -> None: ... + def dispatch(self, node: ast.AST) -> None: ... + def call(self, method: Callable[[ASTTranslator, ast.AST], _T], node: ast.AST) -> _T | None: ... + def default_pre(self, node: ast.AST) -> None: ... + def default_post(self, node: ast.AST) -> None: ... def priority(p: int): ... def binop_src(op: str, node) -> str: ... @@ -25,114 +25,114 @@ def ast2src(tree): ... def get_child_nodes(node: ast.AST) -> Generator[ast.AST]: ... class PythonTranslator(ASTTranslator): - def __init__(translator, tree) -> None: ... - def call(translator, method, node) -> None: ... - def default_pre(translator, node: ast.AST): ... - def default_post(translator, node: ast.AST) -> None: ... - def postGeneratorExp(translator, node: ast.GeneratorExp) -> str: ... - def postcomprehension(translator, node: ast.comprehension) -> str: ... - def postGenExprIf(translator, node) -> str: ... - def postExpr(translator, node: ast.Expr) -> str: ... - def postIfExp(translator, node: ast.IfExp) -> str: ... - def postLambda(translator, node: ast.Lambda) -> str: ... - def postarguments(translator, node: ast.arguments) -> str: ... - def postarg(translator, node: ast.arg) -> str: ... - def postOr(translator, node: ast.Or) -> str: ... - def postAnd(translator, node: ast.And) -> str: ... - def postNot(translator, node: ast.Not) -> str: ... - def postCompare(translator, node: ast.Compare) -> str: ... - def postEq(translator, node: ast.Eq) -> str: ... - def postNotEq(translator, node: ast.NotEq) -> str: ... - def postLt(translator, node: ast.Lt) -> str: ... - def postLtE(translator, node: ast.LtE) -> str: ... - def postGt(translator, node: ast.Gt) -> str: ... - def postGtE(translator, node: ast.GtE) -> str: ... - def postIs(translator, node: ast.Is) -> str: ... - def postIsNot(translator, node: ast.IsNot) -> str: ... - def postIn(translator, node: ast.In) -> str: ... - def postNotIn(translator, node: ast.NotIn) -> str: ... - def postBitOr(translator, node: ast.BitOr) -> str: ... - def postBitXor(translator, node: ast.BitXor) -> str: ... - def postBitAnd(translator, node: ast.BitAnd) -> str: ... - def postLShift(translator, node: ast.LShift) -> str: ... - def postRShift(translator, node: ast.RShift) -> str: ... - def postAdd(translator, node: ast.Add) -> str: ... - def postSub(translator, node: ast.Sub) -> str: ... - def postMult(translator, node: ast.Mult): ... - def postMatMult(translator, node: ast.MatMult) -> None: ... - def postDiv(translator, node: ast.Div) -> str: ... - def postFloorDiv(translator, node: ast.FloorDiv) -> str: ... - def postMod(translator, node: ast.Mod) -> str: ... - def postUSub(translator, node: ast.USub) -> str: ... - def postUAdd(translator, node: ast.UAdd) -> str: ... - def postInvert(translator, node: ast.Invert) -> str: ... - def postPow(translator, node: ast.Pow) -> str: ... - def postAttribute(translator, node: ast.Attribute) -> str: ... - def postCall(translator, node: ast.Call) -> str: ... - def postkeyword(translator, node: ast.keyword) -> str: ... - def postStarred(translator, node: ast.Starred) -> str: ... - def postSubscript(translator, node: ast.Subscript) -> str: ... - def postIndex(translator, node: ast.Index) -> str: ... - def postSlice(translator, node: ast.Slice) -> str: ... - def postConstant(translator, node: ast.Constant) -> str: ... + def __init__(self, tree) -> None: ... + def call(self, method, node) -> None: ... + def default_pre(self, node: ast.AST): ... + def default_post(self, node: ast.AST) -> None: ... + def postGeneratorExp(self, node: ast.GeneratorExp) -> str: ... + def postcomprehension(self, node: ast.comprehension) -> str: ... + def postGenExprIf(self, node) -> str: ... + def postExpr(self, node: ast.Expr) -> str: ... + def postIfExp(self, node: ast.IfExp) -> str: ... + def postLambda(self, node: ast.Lambda) -> str: ... + def postarguments(self, node: ast.arguments) -> str: ... + def postarg(self, node: ast.arg) -> str: ... + def postOr(self, node: ast.Or) -> str: ... + def postAnd(self, node: ast.And) -> str: ... + def postNot(self, node: ast.Not) -> str: ... + def postCompare(self, node: ast.Compare) -> str: ... + def postEq(self, node: ast.Eq) -> str: ... + def postNotEq(self, node: ast.NotEq) -> str: ... + def postLt(self, node: ast.Lt) -> str: ... + def postLtE(self, node: ast.LtE) -> str: ... + def postGt(self, node: ast.Gt) -> str: ... + def postGtE(self, node: ast.GtE) -> str: ... + def postIs(self, node: ast.Is) -> str: ... + def postIsNot(self, node: ast.IsNot) -> str: ... + def postIn(self, node: ast.In) -> str: ... + def postNotIn(self, node: ast.NotIn) -> str: ... + def postBitOr(self, node: ast.BitOr) -> str: ... + def postBitXor(self, node: ast.BitXor) -> str: ... + def postBitAnd(self, node: ast.BitAnd) -> str: ... + def postLShift(self, node: ast.LShift) -> str: ... + def postRShift(self, node: ast.RShift) -> str: ... + def postAdd(self, node: ast.Add) -> str: ... + def postSub(self, node: ast.Sub) -> str: ... + def postMult(self, node: ast.Mult): ... + def postMatMult(self, node: ast.MatMult) -> None: ... + def postDiv(self, node: ast.Div) -> str: ... + def postFloorDiv(self, node: ast.FloorDiv) -> str: ... + def postMod(self, node: ast.Mod) -> str: ... + def postUSub(self, node: ast.USub) -> str: ... + def postUAdd(self, node: ast.UAdd) -> str: ... + def postInvert(self, node: ast.Invert) -> str: ... + def postPow(self, node: ast.Pow) -> str: ... + def postAttribute(self, node: ast.Attribute) -> str: ... + def postCall(self, node: ast.Call) -> str: ... + def postkeyword(self, node: ast.keyword) -> str: ... + def postStarred(self, node: ast.Starred) -> str: ... + def postSubscript(self, node: ast.Subscript) -> str: ... + def postIndex(self, node: ast.Index) -> str: ... + def postSlice(self, node: ast.Slice) -> str: ... + def postConstant(self, node: ast.Constant) -> str: ... if sys.version_info >= (3, 14): - def postNameConstant(translator, node: ast.Constant) -> str: ... - def postNum(translator, node: ast.Constant) -> str: ... - def postStr(translator, node: ast.Constant) -> str: ... - def postBytes(translator, node: ast.Constant) -> str: ... + def postNameConstant(self, node: ast.Constant) -> str: ... + def postNum(self, node: ast.Constant) -> str: ... + def postStr(self, node: ast.Constant) -> str: ... + def postBytes(self, node: ast.Constant) -> str: ... else: - def postNameConstant(translator, node: ast.NameConstant) -> str: ... - def postNum(translator, node: ast.Num) -> str: ... - def postStr(translator, node: ast.Str) -> str: ... - def postBytes(translator, node: ast.Bytes) -> str: ... + def postNameConstant(self, node: ast.NameConstant) -> str: ... + def postNum(self, node: ast.Num) -> str: ... + def postStr(self, node: ast.Str) -> str: ... + def postBytes(self, node: ast.Bytes) -> str: ... - def postList(translator, node: ast.List) -> str: ... - def postTuple(translator, node: ast.Tuple) -> str: ... - def postDict(translator, node: ast.Dict) -> str: ... - def postSet(translator, node: ast.Set) -> str: ... - def postName(translator, node: ast.Name) -> str: ... + def postList(self, node: ast.List) -> str: ... + def postTuple(self, node: ast.Tuple) -> str: ... + def postDict(self, node: ast.Dict) -> str: ... + def postSet(self, node: ast.Set) -> str: ... + def postName(self, node: ast.Name) -> str: ... def postJoinedStr(self, node: ast.JoinedStr) -> str: ... def postFormattedValue(self, node: ast.FormattedValue) -> str: ... nonexternalizable_types: tuple[type[ast.AST], ...] class PreTranslator(ASTTranslator): - def __init__(translator, tree, globals, locals, special_functions, const_functions, outer_names=()) -> None: ... - def dispatch(translator, node) -> None: ... - def preGeneratorExp(translator, node: ast.GeneratorExp) -> bool: ... - def preLambda(translator, node: ast.Lambda) -> bool: ... - def postName(translator, node: ast.Name) -> None: ... - def postSlice(translator, node: ast.Slice) -> None: ... - def postStarred(translator, node: ast.Starred) -> None: ... - def postConstant(translator, node: ast.Constant) -> None: ... + def __init__(self, tree, globals, locals, special_functions, const_functions, outer_names=()) -> None: ... + def dispatch(self, node) -> None: ... + def preGeneratorExp(self, node: ast.GeneratorExp) -> bool: ... + def preLambda(self, node: ast.Lambda) -> bool: ... + def postName(self, node: ast.Name) -> None: ... + def postSlice(self, node: ast.Slice) -> None: ... + def postStarred(self, node: ast.Starred) -> None: ... + def postConstant(self, node: ast.Constant) -> None: ... if sys.version_info >= (3, 14): - def postNum(translator, node: ast.Constant) -> None: ... - def postStr(translator, node: ast.Constant) -> None: ... - def postBytes(translator, node: ast.Constant) -> None: ... + def postNum(self, node: ast.Constant) -> None: ... + def postStr(self, node: ast.Constant) -> None: ... + def postBytes(self, node: ast.Constant) -> None: ... else: - def postNum(translator, node: ast.Num) -> None: ... - def postStr(translator, node: ast.Str) -> None: ... - def postBytes(translator, node: ast.Bytes) -> None: ... + def postNum(self, node: ast.Num) -> None: ... + def postStr(self, node: ast.Str) -> None: ... + def postBytes(self, node: ast.Bytes) -> None: ... - def postDict(translator, node: ast.Dict) -> None: ... - def postList(translator, node: ast.List) -> None: ... - def postkeyword(translator, node: ast.keyword) -> None: ... - def postIndex(translator, node: ast.Index) -> None: ... - def postCall(translator, node: ast.Call) -> None: ... - def postCompare(translator, node: ast.Compare) -> None: ... - def post_binop(translator, node: ast.BinOp) -> None: ... - def postBitOr(translator, node: ast.BitOr) -> None: ... - def postBitXor(translator, node: ast.BitXor) -> None: ... - def postBitAnd(translator, node: ast.BitAnd) -> None: ... - def postLShift(translator, node: ast.LShift) -> None: ... - def postRShift(translator, node: ast.RShift) -> None: ... - def postAdd(translator, node: ast.Add) -> None: ... - def postSub(translator, node: ast.Sub) -> None: ... - def postMult(translator, node: ast.Mult) -> None: ... - def postMatMult(translator, node: ast.MatMult) -> None: ... - def postDiv(translator, node: ast.Div) -> None: ... - def postFloorDiv(translator, node: ast.FloorDiv) -> None: ... - def postMod(translator, node: ast.Mod) -> None: ... + def postDict(self, node: ast.Dict) -> None: ... + def postList(self, node: ast.List) -> None: ... + def postkeyword(self, node: ast.keyword) -> None: ... + def postIndex(self, node: ast.Index) -> None: ... + def postCall(self, node: ast.Call) -> None: ... + def postCompare(self, node: ast.Compare) -> None: ... + def post_binop(self, node: ast.BinOp) -> None: ... + def postBitOr(self, node: ast.BitOr) -> None: ... + def postBitXor(self, node: ast.BitXor) -> None: ... + def postBitAnd(self, node: ast.BitAnd) -> None: ... + def postLShift(self, node: ast.LShift) -> None: ... + def postRShift(self, node: ast.RShift) -> None: ... + def postAdd(self, node: ast.Add) -> None: ... + def postSub(self, node: ast.Sub) -> None: ... + def postMult(self, node: ast.Mult) -> None: ... + def postMatMult(self, node: ast.MatMult) -> None: ... + def postDiv(self, node: ast.Div) -> None: ... + def postFloorDiv(self, node: ast.FloorDiv) -> None: ... + def postMod(self, node: ast.Mod) -> None: ... extractors_cache: dict[str | int, tuple[Incomplete, dict[Incomplete, Incomplete]]] diff --git a/stubs/pony/pony/orm/core.pyi b/stubs/pony/pony/orm/core.pyi index d05d3104f456..eca1d4d6dbe3 100644 --- a/stubs/pony/pony/orm/core.pyi +++ b/stubs/pony/pony/orm/core.pyi @@ -170,7 +170,7 @@ class PermissionError(OrmError): ... class ObjectNotFound(OrmError): def __init__( - exc, entity: Entity, pkval: object | tuple[object, ...] | None = None # pkval passing to repr() builtins function + self, entity: Entity, pkval: object | tuple[object, ...] | None = None # pkval passing to repr() builtins function ) -> None: ... class MultipleObjectsFoundError(OrmError): ... @@ -180,16 +180,16 @@ class TransactionError(OrmError): ... class ConnectionClosedError(TransactionError): ... class TransactionIntegrityError(TransactionError): - def __init__(exc, msg, original_exc=None) -> None: ... + def __init__(self, msg, original_exc=None) -> None: ... class CommitException(TransactionError): - def __init__(exc, msg, exceptions) -> None: ... + def __init__(self, msg, exceptions) -> None: ... class PartialCommitException(TransactionError): - def __init__(exc, msg, exceptions) -> None: ... + def __init__(self, msg, exceptions) -> None: ... class RollbackException(TransactionError): - def __init__(exc, msg, exceptions) -> None: ... + def __init__(self, msg, exceptions) -> None: ... class DatabaseSessionIsOver(TransactionError): ... @@ -201,10 +201,10 @@ class OptimisticCheckError(IsolationError): ... class UnresolvableCyclicDependency(TransactionError): ... class UnexpectedError(TransactionError): - def __init__(exc, msg, original_exc) -> None: ... + def __init__(self, msg, original_exc) -> None: ... class ExprEvalError(TranslationError): - def __init__(exc, src, cause) -> None: ... + def __init__(self, src, cause) -> None: ... class PonyInternalException(Exception): ... class OptimizationFailed(PonyInternalException): ... @@ -232,11 +232,11 @@ class PrefetchContext: def get_relations_to_prefetch(self, entity): ... class Local(localbase): - def __init__(local) -> None: ... + def __init__(self) -> None: ... @property def prefetch_context(local): ... - def push_debug_state(local, debug, show_values) -> None: ... - def pop_debug_state(local) -> None: ... + def push_debug_state(self, debug, show_values) -> None: ... + def pop_debug_state(self) -> None: ... local: Local @@ -268,7 +268,7 @@ class DBSessionContextManager: sql_debug: bool | None show_values: bool | None def __init__( - db_session, + self, retry: int = 0, immediate: bool = False, ddl: bool = False, @@ -280,7 +280,7 @@ class DBSessionContextManager: sql_debug: bool | None = None, show_values: bool | None = None, ) -> None: ... - def __call__(db_session, *args, **kwargs): ... + def __call__(self, *args, **kwargs): ... def __enter__(db_session) -> None: ... def __exit__(db_session, exc_type=None, exc=None, tb=None) -> None: ... @@ -322,44 +322,44 @@ class Database: on_connect: OnConnectDecorator provider: Incomplete def __init__(self, *args, **kwargs) -> None: ... - def call_on_connect(database, con) -> None: ... + def call_on_connect(self, con) -> None: ... def bind(self, *args, **kwargs) -> None: ... @property def last_sql(database): ... @property def local_stats(database): ... - def merge_local_stats(database) -> None: ... + def merge_local_stats(self) -> None: ... @property def global_stats(database): ... @property @deprecated("global_stats_lock is deprecated, just use global_stats property without any locking.") def global_stats_lock(database): ... - def get_connection(database): ... - def disconnect(database) -> None: ... - def flush(database) -> None: ... - def commit(database) -> None: ... - def rollback(database) -> None: ... - def execute(database, sql, globals=None, locals=None): ... - def select(database, sql, globals=None, locals=None, frame_depth: int = 0): ... - def get(database, sql, globals=None, locals=None): ... - def exists(database, sql, globals=None, locals=None): ... - def insert(database, table_name, returning=None, **kwargs): ... - def generate_mapping(database, filename=None, check_tables: bool = True, create_tables: bool = False): ... - def drop_table(database, table_name, if_exists: bool = False, with_all_data: bool = False) -> None: ... - def drop_all_tables(database, with_all_data: bool = False) -> None: ... - def create_tables(database, check_tables: bool = False) -> None: ... - def check_tables(database) -> None: ... - def set_perms_for(database, *entities) -> Generator[None]: ... - def to_json(database, data, include=(), exclude=(), converter=None, with_schema: bool = True, schema_hash=None): ... - def from_json(database, changes, observer=None): ... + def get_connection(self): ... + def disconnect(self) -> None: ... + def flush(self) -> None: ... + def commit(self) -> None: ... + def rollback(self) -> None: ... + def execute(self, sql, globals=None, locals=None): ... + def select(self, sql, globals=None, locals=None, frame_depth: int = 0): ... + def get(self, sql, globals=None, locals=None): ... + def exists(self, sql, globals=None, locals=None): ... + def insert(self, table_name, returning=None, **kwargs): ... + def generate_mapping(self, filename=None, check_tables: bool = True, create_tables: bool = False): ... + def drop_table(self, table_name, if_exists: bool = False, with_all_data: bool = False) -> None: ... + def drop_all_tables(self, with_all_data: bool = False) -> None: ... + def create_tables(self, check_tables: bool = False) -> None: ... + def check_tables(self) -> None: ... + def set_perms_for(self, *entities) -> Generator[None]: ... + def to_json(self, data, include=(), exclude=(), converter=None, with_schema: bool = True, schema_hash=None): ... + def from_json(self, changes, observer=None): ... def basic_converter(x): ... def perm(*args, **kwargs) -> AccessRule: ... def pop_names_from_kwargs(typename, kwargs, *kwnames): ... class AccessRule: - def __init__(rule, database, entities, permissions, groups, roles, labels) -> None: ... - def exclude(rule, *args) -> None: ... + def __init__(self, database, entities, permissions, groups, roles, labels) -> None: ... + def exclude(self, *args) -> None: ... def has_perm(user, perm, x) -> bool: ... def can_view(user, x) -> bool: ... @@ -390,13 +390,13 @@ def obj_labels_getter(cls=None): ... class DbLocal(localbase): stats: Incomplete last_sql: Incomplete - def __init__(dblocal) -> None: ... + def __init__(self) -> None: ... class QueryStat: - def __init__(stat, sql, duration=None) -> None: ... - def copy(stat): ... - def query_executed(stat, duration) -> None: ... - def merge(stat, stat2) -> None: ... + def __init__(self, sql, duration=None) -> None: ... + def copy(self): ... + def query_executed(self, duration) -> None: ... + def merge(self, stat2) -> None: ... @property def avg_time(stat): ... @@ -427,22 +427,22 @@ class SessionCache: perm_cache: Incomplete user_roles_cache: defaultdict[Incomplete, dict[Incomplete, Incomplete]] | None obj_labels_cache: dict[Incomplete, Incomplete] | None - def __init__(cache, database: Database) -> None: ... - def connect(cache): ... - def reconnect(cache, exc): ... - def prepare_connection_for_query_execution(cache): ... - def flush_and_commit(cache) -> None: ... - def commit(cache) -> None: ... - def rollback(cache) -> None: ... - def release(cache) -> None: ... - def close(cache, rollback: bool = True) -> None: ... - def flush_disabled(cache) -> Generator[None]: ... - def flush(cache) -> None: ... - def call_after_save_hooks(cache) -> None: ... - def update_simple_index(cache, obj, attr, old_val, new_val, undo) -> None: ... - def db_update_simple_index(cache, obj, attr, old_dbval, new_dbval) -> None: ... - def update_composite_index(cache, obj, attrs, prev_vals, new_vals, undo) -> None: ... - def db_update_composite_index(cache, obj, attrs, prev_vals, new_vals) -> None: ... + def __init__(self, database: Database) -> None: ... + def connect(self): ... + def reconnect(self, exc): ... + def prepare_connection_for_query_execution(self): ... + def flush_and_commit(self) -> None: ... + def commit(self) -> None: ... + def rollback(self) -> None: ... + def release(self) -> None: ... + def close(self, rollback: bool = True) -> None: ... + def flush_disabled(self) -> Generator[None]: ... + def flush(self) -> None: ... + def call_after_save_hooks(self) -> None: ... + def update_simple_index(self, obj, attr, old_val, new_val, undo) -> None: ... + def db_update_simple_index(self, obj, attr, old_dbval, new_dbval) -> None: ... + def update_composite_index(self, obj, attrs, prev_vals, new_vals, undo) -> None: ... + def db_update_composite_index(self, obj, attrs, prev_vals, new_vals) -> None: ... class NotLoadedValueType: ... @@ -551,47 +551,47 @@ class Attribute: type_has_empty_value: bool interleave: bool | None def __deepcopy__(attr, memo): ... - def __init__(attr, py_type: type | str | types.FunctionType | Array, *args, **kwargs) -> None: ... - def linked(attr) -> None: ... + def __init__(self, py_type: type | str | types.FunctionType | Array, *args, **kwargs) -> None: ... + def linked(self) -> None: ... def __lt__(attr, other): ... - def validate(attr, val, obj=None, entity=None, from_db: bool = False): ... - def parse_value(attr, row, offsets, dbvals_deduplication_cache): ... - def load(attr, obj: Entity): ... + def validate(self, val, obj=None, entity=None, from_db: bool = False): ... + def parse_value(self, row, offsets, dbvals_deduplication_cache): ... + def load(self, obj: Entity): ... def __get__(attr, obj, cls=None): ... - def get(attr, obj): ... + def get(self, obj): ... def __set__(attr, obj, new_val, undo_funcs=None) -> None: ... - def db_set(attr, obj, new_dbval, is_reverse_call: bool = False) -> None: ... - def update_reverse(attr, obj, old_val, new_val, undo_funcs) -> None: ... - def db_update_reverse(attr, obj, old_dbval, new_dbval) -> None: ... + def db_set(self, obj, new_dbval, is_reverse_call: bool = False) -> None: ... + def update_reverse(self, obj, old_val, new_val, undo_funcs) -> None: ... + def db_update_reverse(self, obj, old_dbval, new_dbval) -> None: ... def __delete__(attr, obj) -> None: ... - def get_raw_values(attr, val): ... - def get_columns(attr) -> list[str] | tuple[str, ...]: ... + def get_raw_values(self, val): ... + def get_columns(self) -> list[str] | tuple[str, ...]: ... @property def asc(attr) -> Self: ... @property def desc(attr) -> DescWrapper: ... - def describe(attr) -> str: ... + def describe(self) -> str: ... class Optional(Attribute): __slots__: list[str] = [] class Required(Attribute): __slots__: list[str] = [] - def validate(attr, val, obj=None, entity=None, from_db: bool = False): ... + def validate(self, val, obj=None, entity=None, from_db: bool = False): ... class Discriminator(Required): __slots__ = ["code2cls"] code2cls: dict[Incomplete, Incomplete] - def __init__(attr, py_type, *args, **kwargs) -> None: ... + def __init__(self, py_type, *args, **kwargs) -> None: ... @staticmethod def create_default_attr(entity) -> None: ... - def process_entity_inheritance(attr, entity) -> None: ... - def validate(attr, val, obj=None, entity=None, from_db: bool = False): ... - def load(attr, obj) -> None: ... + def process_entity_inheritance(self, entity) -> None: ... + def validate(self, val, obj=None, entity=None, from_db: bool = False): ... + def load(self, obj) -> None: ... def __get__(attr, obj, cls=None): ... def __set__(attr, obj, new_val) -> None: ... # type: ignore[override] - def db_set(attr, obj, new_dbval) -> None: ... # type: ignore[override] - def update_reverse(attr, obj, old_val, new_val, undo_funcs) -> None: ... + def db_set(self, obj, new_dbval) -> None: ... # type: ignore[override] + def update_reverse(self, obj, old_val, new_val, undo_funcs) -> None: ... class Index: __slots__ = ("entity", "attrs", "is_pk", "is_unique") @@ -599,7 +599,7 @@ class Index: attrs: list[Incomplete] is_pk: bool is_unique: bool - def __init__(index, *attrs, **options) -> None: ... + def __init__(self, *attrs, **options) -> None: ... def composite_index(*attrs) -> None: ... def composite_key(*attrs) -> None: ... @@ -635,13 +635,13 @@ class Collection(Attribute): cached_count_sql: tuple[Incomplete, Incomplete] | None cached_empty_sql: tuple[Incomplete, Incomplete, Incomplete] | None reverse_fk_name: Incomplete - def __init__(attr, py_type, *args, **kwargs) -> None: ... - def load(attr, obj) -> None: ... + def __init__(self, py_type, *args, **kwargs) -> None: ... + def load(self, obj) -> None: ... def __get__(attr, obj, cls=None) -> None: ... def __set__(attr, obj, val) -> None: ... # type: ignore[override] def __delete__(attr, obj) -> None: ... - def prepare(attr, obj, val, fromdb: bool = False) -> None: ... - def set(attr, obj, val, fromdb: bool = False) -> None: ... + def prepare(self, obj, val, fromdb: bool = False) -> None: ... + def set(self, obj, val, fromdb: bool = False) -> None: ... class SetData(set[Incomplete]): __slots__ = ("is_fully_loaded", "added", "removed", "absent", "count") @@ -650,7 +650,7 @@ class SetData(set[Incomplete]): removed: Incomplete absent: Incomplete count: int | None - def __init__(setdata) -> None: ... + def __init__(self) -> None: ... def construct_batchload_criteria_list( alias, columns, converters, batch_size, row_value_syntax, start: int = 0, from_seeds: bool = True @@ -658,22 +658,22 @@ def construct_batchload_criteria_list( class Set(Collection): __slots__: list[str] = [] - def validate(attr, val, obj=None, entity=None, from_db: bool = False): ... - def prefetch_load_all(attr, objects): ... - def load(attr, obj, items=None): ... - def construct_sql_m2m(attr, batch_size: int = 1, items_count: int = 0): ... - def copy(attr, obj): ... + def validate(self, val, obj=None, entity=None, from_db: bool = False): ... + def prefetch_load_all(self, objects): ... + def load(self, obj, items=None): ... + def construct_sql_m2m(self, batch_size: int = 1, items_count: int = 0): ... + def copy(self, obj): ... def __get__(attr, obj, cls=None): ... def __set__(attr, obj, new_items, undo_funcs=None) -> None: ... def __delete__(attr, obj) -> None: ... - def reverse_add(attr, objects, item, undo_funcs) -> None: ... - def db_reverse_add(attr, objects, item) -> None: ... - def reverse_remove(attr, objects, item, undo_funcs) -> None: ... - def db_reverse_remove(attr, objects, item) -> None: ... - def get_m2m_columns(attr, is_reverse: bool = False): ... - def remove_m2m(attr, removed) -> None: ... - def add_m2m(attr, added) -> None: ... - def drop_table(attr, with_all_data: bool = False) -> None: ... + def reverse_add(self, objects, item, undo_funcs) -> None: ... + def db_reverse_add(self, objects, item) -> None: ... + def reverse_remove(self, objects, item, undo_funcs) -> None: ... + def db_reverse_remove(self, objects, item) -> None: ... + def get_m2m_columns(self, is_reverse: bool = False): ... + def remove_m2m(self, removed) -> None: ... + def add_m2m(self, added) -> None: ... + def drop_table(self, with_all_data: bool = False) -> None: ... def unpickle_setwrapper(obj, attrname, items): ... @@ -685,41 +685,41 @@ class SetIterator: class SetInstance: __slots__ = ("_obj_", "_attr_", "_attrnames_") - def __init__(wrapper, obj, attr) -> None: ... + def __init__(self, obj, attr) -> None: ... def __reduce__(wrapper): ... - def copy(wrapper): ... + def copy(self): ... def __nonzero__(wrapper): ... - def is_empty(wrapper): ... + def is_empty(self): ... def __len__(wrapper) -> int: ... - def count(wrapper): ... + def count(self): ... def __iter__(wrapper): ... def __eq__(wrapper, other): ... def __ne__(wrapper, other): ... def __add__(wrapper, new_items): ... def __sub__(wrapper, items): ... def __contains__(wrapper, item) -> bool: ... - def create(wrapper, **kwargs): ... - def add(wrapper, new_items) -> None: ... + def create(self, **kwargs): ... + def add(self, new_items) -> None: ... def __iadd__(wrapper, items): ... - def remove(wrapper, items) -> None: ... + def remove(self, items) -> None: ... def __isub__(wrapper, items): ... - def clear(wrapper) -> None: ... - def load(wrapper) -> None: ... - def select(wrapper, *args, **kwargs): ... + def clear(self) -> None: ... + def load(self) -> None: ... + def select(self, *args, **kwargs): ... filter = select - def limit(wrapper, limit=None, offset=None): ... - def page(wrapper, pagenum, pagesize: int = 10): ... - def order_by(wrapper, *args): ... - def sort_by(wrapper, *args): ... - def random(wrapper, limit): ... + def limit(self, limit=None, offset=None): ... + def page(self, pagenum, pagesize: int = 10): ... + def order_by(self, *args): ... + def sort_by(self, *args): ... + def random(self, limit): ... def unpickle_multiset(obj, attrnames, items): ... class Multiset: __slots__ = ["_obj_", "_attrnames_", "_items_"] - def __init__(multiset, obj, attrnames, items) -> None: ... + def __init__(self, obj, attrnames, items) -> None: ... def __reduce__(multiset): ... - def distinct(multiset): ... + def distinct(self): ... def __nonzero__(multiset): ... def __len__(multiset) -> int: ... def __iter__(multiset): ... @@ -740,18 +740,18 @@ lambda_re: re.Pattern[str] class EntityMeta(type): def __new__(meta, name, bases, cls_dict): ... - def __init__(entity, name, bases, cls_dict) -> None: ... + def __init__(cls, name, bases, cls_dict) -> None: ... def __iter__(entity): ... def __getitem__(entity, key): ... - def exists(entity, *args, **kwargs): ... - def get(entity, *args, **kwargs): ... - def get_for_update(entity, *args, **kwargs): ... - def get_by_sql(entity, sql, globals=None, locals=None): ... - def select(entity, *args, **kwargs): ... - def select_by_sql(entity, sql, globals=None, locals=None): ... - def select_random(entity, limit): ... - def describe(entity) -> str: ... - def drop_table(entity, with_all_data: bool = False) -> None: ... + def exists(cls, *args, **kwargs): ... + def get(cls, *args, **kwargs): ... + def get_for_update(cls, *args, **kwargs): ... + def get_by_sql(cls, sql, globals=None, locals=None): ... + def select(cls, *args, **kwargs): ... + def select_by_sql(cls, sql, globals=None, locals=None): ... + def select_random(cls, limit): ... + def describe(cls) -> str: ... + def drop_table(cls, with_all_data: bool = False) -> None: ... def populate_criteria_list( criteria_list, columns, converters, operations, params_count: int = 0, table_alias=None, optimistic: bool = False @@ -788,27 +788,27 @@ class Entity(metaclass=EntityMeta): "__weakref__", ) def __reduce__(obj): ... - def __init__(obj, *args, **kwargs) -> None: ... - def get_pk(obj): ... + def __init__(self, *args, **kwargs) -> None: ... + def get_pk(self): ... def __lt__(entity, other): ... def __le__(entity, other): ... def __gt__(entity, other): ... def __ge__(entity, other): ... - def load(obj, *attrs) -> None: ... - def delete(obj) -> None: ... - def set(obj, **kwargs) -> None: ... - def find_updated_attributes(obj): ... - def flush(obj) -> None: ... - def before_insert(obj) -> None: ... - def before_update(obj) -> None: ... - def before_delete(obj) -> None: ... - def after_insert(obj) -> None: ... - def after_update(obj) -> None: ... - def after_delete(obj) -> None: ... + def load(self, *attrs) -> None: ... + def delete(self) -> None: ... + def set(self, **kwargs) -> None: ... + def find_updated_attributes(self): ... + def flush(self) -> None: ... + def before_insert(self) -> None: ... + def before_update(self) -> None: ... + def before_delete(self) -> None: ... + def after_insert(self) -> None: ... + def after_update(self) -> None: ... + def after_delete(self) -> None: ... def to_dict( - obj, only=None, exclude=None, with_collections: bool = False, with_lazy: bool = False, related_objects: bool = False + self, only=None, exclude=None, with_collections: bool = False, with_lazy: bool = False, related_objects: bool = False ): ... - def to_json(obj, include=(), exclude=(), converter=None, with_schema: bool = True, schema_hash=None): ... + def to_json(self, include=(), exclude=(), converter=None, with_schema: bool = True, schema_hash=None): ... def string2ast(s: str) -> ast.Expr: ... def get_globals_and_locals(args, kwargs, frame_depth, from_generator=False): ... @@ -834,40 +834,41 @@ def extract_vars(code_key, filter_num, extractors, globals, locals, cells=None): def unpickle_query(query_result: _T) -> _T: ... class Query: - def __init__(query, code_key, tree, globals, locals, cells=None, left_join: bool = False) -> None: ... + def __init__(self, code_key, tree, globals, locals, cells=None, left_join: bool = False) -> None: ... def __reduce__(query): ... - def get_sql(query): ... - def prefetch(query, *args): ... - def show(query, width=None, stream=None) -> None: ... - def get(query): ... - def first(query): ... - def without_distinct(query): ... - def distinct(query): ... - def exists(query): ... - def delete(query, bulk=None): ... + def get_sql(self): ... + def prefetch(self, *args): ... + def show(self, width=None, stream=None) -> None: ... + def get(self): ... + def first(self): ... + def without_distinct(self): ... + def distinct(self): ... + def exists(self): ... + def delete(self, bulk=None): ... def __len__(query) -> int: ... def __iter__(query): ... - def order_by(query, *args): ... - def sort_by(query, *args): ... - def filter(query, *args, **kwargs): ... - def where(query, *args, **kwargs): ... + def order_by(self, *args): ... + def sort_by(self, *args): ... + def filter(self, *args, **kwargs): ... + def where(self, *args, **kwargs): ... def __getitem__(query, key): ... - def fetch(query, limit=None, offset=None): ... - def limit(query, limit=None, offset=None): ... - def page(query, pagenum, pagesize: int = 10): ... - def sum(query, distinct=None): ... - def avg(query, distinct=None): ... - def group_concat(query, sep=None, distinct=None): ... - def min(query): ... - def max(query): ... - def count(query, distinct=None): ... - def for_update(query, nowait: bool = False, skip_locked: bool = False): ... - def random(query, limit): ... - def to_json(query, include=(), exclude=(), converter=None, with_schema: bool = True, schema_hash=None): ... + def fetch(self, limit=None, offset=None): ... + def limit(self, limit=None, offset=None): ... + def page(self, pagenum, pagesize: int = 10): ... + def sum(self, distinct=None): ... + def avg(self, distinct=None): ... + def group_concat(self, sep=None, distinct=None): ... + def min(self): ... + def max(self): ... + def count(self, distinct=None): ... + def for_update(self, nowait: bool = False, skip_locked: bool = False): ... + def random(self, limit): ... + def to_json(self, include=(), exclude=(), converter=None, with_schema: bool = True, schema_hash=None): ... class QueryResultIterator: __slots__ = ("_query_result", "_position") def __init__(self, query_result) -> None: ... + def __iter__(self): ... def next(self): ... __next__ = next def __length_hint__(self) -> int: ... diff --git a/stubs/pony/pony/orm/dbapiprovider.pyi b/stubs/pony/pony/orm/dbapiprovider.pyi index ce0c0a5e3eff..700561338f34 100644 --- a/stubs/pony/pony/orm/dbapiprovider.pyi +++ b/stubs/pony/pony/orm/dbapiprovider.pyi @@ -8,7 +8,7 @@ from typing import ClassVar from pony.utils import localbase class DBException(Exception): - def __init__(exc, original_exc, *args) -> None: ... + def __init__(self, original_exc, *args) -> None: ... class Warning(DBException): ... class Error(DBException): ... @@ -49,42 +49,42 @@ class DBAPIProvider: default_schema_name: ClassVar[str | None] fk_types: ClassVar[dict[str, str]] converter_classes: Incomplete - def __init__(provider, _database, *args, **kwargs) -> None: ... - def inspect_connection(provider, connection) -> None: ... - def normalize_name(provider, name): ... - def get_default_entity_table_name(provider, entity): ... - def get_default_m2m_table_name(provider, attr, reverse): ... - def get_default_column_names(provider, attr, reverse_pk_columns=None): ... - def get_default_m2m_column_names(provider, entity): ... + def __init__(self, _database, *args, **kwargs) -> None: ... + def inspect_connection(self, connection) -> None: ... + def normalize_name(self, name): ... + def get_default_entity_table_name(self, entity): ... + def get_default_m2m_table_name(self, attr, reverse): ... + def get_default_column_names(self, attr, reverse_pk_columns=None): ... + def get_default_m2m_column_names(self, entity): ... def get_default_index_name( - provider, table_name, column_names, is_pk: bool = False, is_unique: bool = False, m2m: bool = False + self, table_name, column_names, is_pk: bool = False, is_unique: bool = False, m2m: bool = False ): ... - def get_default_fk_name(provider, child_table_name, parent_table_name, child_column_names): ... - def split_table_name(provider, table_name): ... - def base_name(provider, name): ... - def quote_name(provider, name: str | Iterable[str]) -> str: ... - def format_table_name(provider, name): ... - def normalize_vars(provider, vars, vartypes) -> None: ... - def ast2sql(provider, ast): ... - def should_reconnect(provider, exc): ... - def connect(provider): ... - def set_transaction_mode(provider, connection, cache) -> None: ... - def commit(provider, connection, cache=None) -> None: ... - def rollback(provider, connection, cache=None) -> None: ... - def release(provider, connection, cache=None) -> None: ... - def drop(provider, connection, cache=None) -> None: ... - def disconnect(provider) -> None: ... - def execute(provider, cursor, sql, arguments=None, returning_id: bool = False): ... - def get_converter_by_py_type(provider, py_type): ... - def get_converter_by_attr(provider, attr): ... - def get_pool(provider, *args, **kwargs): ... - def table_exists(provider, connection, table_name, case_sensitive: bool = True) -> None: ... - def index_exists(provider, connection, table_name, index_name, case_sensitive: bool = True) -> None: ... - def fk_exists(provider, connection, table_name, fk_name, case_sensitive: bool = True) -> None: ... - def table_has_data(provider, connection, table_name): ... - def disable_fk_checks(provider, connection) -> None: ... - def enable_fk_checks(provider, connection, prev_state) -> None: ... - def drop_table(provider, connection, table_name) -> None: ... + def get_default_fk_name(self, child_table_name, parent_table_name, child_column_names): ... + def split_table_name(self, table_name): ... + def base_name(self, name): ... + def quote_name(self, name: str | Iterable[str]) -> str: ... + def format_table_name(self, name): ... + def normalize_vars(self, vars, vartypes) -> None: ... + def ast2sql(self, ast): ... + def should_reconnect(self, exc): ... + def connect(self): ... + def set_transaction_mode(self, connection, cache) -> None: ... + def commit(self, connection, cache=None) -> None: ... + def rollback(self, connection, cache=None) -> None: ... + def release(self, connection, cache=None) -> None: ... + def drop(self, connection, cache=None) -> None: ... + def disconnect(self) -> None: ... + def execute(self, cursor, sql, arguments=None, returning_id: bool = False): ... + def get_converter_by_py_type(self, py_type): ... + def get_converter_by_attr(self, attr): ... + def get_pool(self, *args, **kwargs): ... + def table_exists(self, connection, table_name, case_sensitive: bool = True) -> None: ... + def index_exists(self, connection, table_name, index_name, case_sensitive: bool = True) -> None: ... + def fk_exists(self, connection, table_name, fk_name, case_sensitive: bool = True) -> None: ... + def table_has_data(self, connection, table_name): ... + def disable_fk_checks(self, connection) -> None: ... + def enable_fk_checks(self, connection, prev_state) -> None: ... + def drop_table(self, connection, table_name) -> None: ... class Pool(localbase): forked_connections: list[tuple[Incomplete, int | None]] @@ -93,124 +93,124 @@ class Pool(localbase): kwargs: dict[str, Incomplete] con: Incomplete pid: int | None - def __init__(pool, dbapi_module: types.ModuleType, *args, **kwargs) -> None: ... - def connect(pool) -> tuple[Incomplete, bool]: ... - def release(pool, con) -> None: ... - def drop(pool, con) -> None: ... - def disconnect(pool) -> None: ... + def __init__(self, dbapi_module: types.ModuleType, *args, **kwargs) -> None: ... + def connect(self) -> tuple[Incomplete, bool]: ... + def release(self, con) -> None: ... + def drop(self, con) -> None: ... + def disconnect(self) -> None: ... class Converter: EQ: str NE: str optimistic: bool def __deepcopy__(converter, memo): ... - def __init__(converter, provider, py_type, attr=None) -> None: ... - def init(converter, kwargs) -> None: ... - def validate(converter, val, obj=None): ... - def py2sql(converter, val): ... - def sql2py(converter, val): ... + def __init__(self, provider, py_type, attr=None) -> None: ... + def init(self, kwargs) -> None: ... + def validate(self, val, obj=None): ... + def py2sql(self, val): ... + def sql2py(self, val): ... def val2dbval(self, val, obj=None): ... def dbval2val(self, dbval, obj=None): ... def dbvals_equal(self, x, y): ... - def get_sql_type(converter, attr=None): ... - def get_fk_type(converter, sql_type): ... + def get_sql_type(self, attr=None): ... + def get_fk_type(self, sql_type): ... class NoneConverter(Converter): - def __init__(converter, provider, py_type, attr=None) -> None: ... - def get_sql_type(converter, attr=None) -> None: ... - def get_fk_type(converter, sql_type) -> None: ... + def __init__(self, provider, py_type, attr=None) -> None: ... + def get_sql_type(self, attr=None) -> None: ... + def get_fk_type(self, sql_type) -> None: ... class BoolConverter(Converter): - def validate(converter, val, obj=None): ... - def sql2py(converter, val): ... - def sql_type(converter): ... + def validate(self, val, obj=None): ... + def sql2py(self, val): ... + def sql_type(self): ... class StrConverter(Converter): - def __init__(converter, provider, py_type, attr=None) -> None: ... - def init(converter, kwargs) -> None: ... - def validate(converter, val, obj=None): ... - def sql_type(converter): ... + def __init__(self, provider, py_type, attr=None) -> None: ... + def init(self, kwargs) -> None: ... + def validate(self, val, obj=None): ... + def sql_type(self): ... class IntConverter(Converter): signed_types: Incomplete unsigned_types: Incomplete - def init(converter, kwargs) -> None: ... - def validate(converter, val, obj=None): ... - def sql2py(converter, val): ... - def sql_type(converter): ... + def init(self, kwargs) -> None: ... + def validate(self, val, obj=None): ... + def sql2py(self, val): ... + def sql_type(self): ... class RealConverter(Converter): EQ: str NE: str default_tolerance: float optimistic: bool - def init(converter, kwargs) -> None: ... - def validate(converter, val, obj=None): ... - def dbvals_equal(converter, x, y): ... - def sql2py(converter, val): ... - def sql_type(converter): ... + def init(self, kwargs) -> None: ... + def validate(self, val, obj=None): ... + def dbvals_equal(self, x, y): ... + def sql2py(self, val): ... + def sql_type(self): ... class DecimalConverter(Converter): - def __init__(converter, provider, py_type, attr=None) -> None: ... - def init(converter, kwargs) -> None: ... - def validate(converter, val, obj=None): ... - def sql2py(converter, val): ... - def sql_type(converter): ... + def __init__(self, provider, py_type, attr=None) -> None: ... + def init(self, kwargs) -> None: ... + def validate(self, val, obj=None): ... + def sql2py(self, val): ... + def sql_type(self): ... class BlobConverter(Converter): - def validate(converter, val, obj=None): ... - def sql2py(converter, val): ... - def sql_type(converter): ... + def validate(self, val, obj=None): ... + def sql2py(self, val): ... + def sql_type(self): ... class DateConverter(Converter): - def validate(converter, val, obj=None): ... - def sql2py(converter, val): ... - def sql_type(converter): ... + def validate(self, val, obj=None): ... + def sql2py(self, val): ... + def sql_type(self): ... class ConverterWithMicroseconds(Converter): - def __init__(converter, provider, py_type, attr=None) -> None: ... - def init(converter, kwargs) -> None: ... - def round_microseconds_to_precision(converter, microseconds, precision): ... - def sql_type(converter): ... + def __init__(self, provider, py_type, attr=None) -> None: ... + def init(self, kwargs) -> None: ... + def round_microseconds_to_precision(self, microseconds, precision): ... + def sql_type(self): ... class TimeConverter(ConverterWithMicroseconds): sql_type_name: ClassVar[str] - def validate(converter, val, obj=None): ... - def sql2py(converter, val): ... + def validate(self, val, obj=None): ... + def sql2py(self, val): ... class TimedeltaConverter(ConverterWithMicroseconds): sql_type_name: ClassVar[str] - def validate(converter, val, obj=None): ... - def sql2py(converter, val): ... + def validate(self, val, obj=None): ... + def sql2py(self, val): ... class DatetimeConverter(ConverterWithMicroseconds): sql_type_name: ClassVar[str] - def validate(converter, val, obj=None): ... - def sql2py(converter, val): ... + def validate(self, val, obj=None): ... + def sql2py(self, val): ... class UuidConverter(Converter): - def __init__(converter, provider, py_type, attr=None) -> None: ... - def validate(converter, val, obj=None): ... - def py2sql(converter, val): ... + def __init__(self, provider, py_type, attr=None) -> None: ... + def validate(self, val, obj=None): ... + def py2sql(self, val): ... sql2py = validate - def sql_type(converter): ... + def sql_type(self): ... class JsonConverter(Converter): json_kwargs: Incomplete class JsonEncoder(json.JSONEncoder): - def default(converter, obj): ... + def default(self, obj): ... - def validate(converter, val, obj=None): ... - def val2dbval(converter, val, obj=None): ... - def dbval2val(converter, dbval, obj=None): ... - def dbvals_equal(converter, x, y): ... - def sql_type(converter): ... + def validate(self, val, obj=None): ... + def val2dbval(self, val, obj=None): ... + def dbval2val(self, dbval, obj=None): ... + def dbvals_equal(self, x, y): ... + def sql_type(self): ... class ArrayConverter(Converter): array_types: Incomplete - def __init__(converter, provider, py_type, attr=None) -> None: ... - def validate(converter, val, obj=None): ... - def dbval2val(converter, dbval, obj=None): ... - def val2dbval(converter, val, obj=None): ... - def sql_type(converter): ... + def __init__(self, provider, py_type, attr=None) -> None: ... + def validate(self, val, obj=None): ... + def dbval2val(self, dbval, obj=None): ... + def val2dbval(self, val, obj=None): ... + def sql_type(self): ... diff --git a/stubs/pony/pony/orm/dbproviders/sqlite.pyi b/stubs/pony/pony/orm/dbproviders/sqlite.pyi index d7b984d30c5d..3c1e85a3546d 100644 --- a/stubs/pony/pony/orm/dbproviders/sqlite.pyi +++ b/stubs/pony/pony/orm/dbproviders/sqlite.pyi @@ -16,7 +16,7 @@ class SqliteExtensionUnavailable(Exception): ... NoneType: type[None] class SQLiteForeignKey(dbschema.ForeignKey): - def get_create_command(foreign_key) -> None: ... + def get_create_command(self) -> None: ... class SQLiteSchema(dbschema.DBSchema): dialect: ClassVar[str] @@ -38,70 +38,70 @@ class SQLiteBuilder(SQLBuilder): least_func_name: ClassVar[str] greatest_func_name: ClassVar[str] value_class: ClassVar[type[SQLiteValue]] - def __init__(builder, provider, ast) -> None: ... - def SELECT_FOR_UPDATE(builder, nowait, skip_locked, *sections): ... - def INSERT(builder, table_name, columns, values, returning=None): ... - def STRING_SLICE(builder, expr, start, stop): ... - def IN(builder, expr1, x): ... - def NOT_IN(builder, expr1, x): ... - def TODAY(builder): ... - def NOW(builder): ... - def YEAR(builder, expr): ... - def MONTH(builder, expr): ... - def DAY(builder, expr): ... - def HOUR(builder, expr): ... - def MINUTE(builder, expr): ... - def SECOND(builder, expr): ... - def datetime_add(builder, funcname, expr, td): ... - def DATE_ADD(builder, expr, delta): ... - def DATE_SUB(builder, expr, delta): ... - def DATE_DIFF(builder, expr1, expr2): ... - def DATETIME_ADD(builder, expr, delta): ... - def DATETIME_SUB(builder, expr, delta): ... - def DATETIME_DIFF(builder, expr1, expr2): ... - def RANDOM(builder): ... + def __init__(self, provider, ast) -> None: ... + def SELECT_FOR_UPDATE(self, nowait, skip_locked, *sections): ... + def INSERT(self, table_name, columns, values, returning=None): ... + def STRING_SLICE(self, expr, start, stop): ... + def IN(self, expr1, x): ... + def NOT_IN(self, expr1, x): ... + def TODAY(self): ... + def NOW(self): ... + def YEAR(self, expr): ... + def MONTH(self, expr): ... + def DAY(self, expr): ... + def HOUR(self, expr): ... + def MINUTE(self, expr): ... + def SECOND(self, expr): ... + def datetime_add(self, funcname, expr, td): ... + def DATE_ADD(self, expr, delta): ... + def DATE_SUB(self, expr, delta): ... + def DATE_DIFF(self, expr1, expr2): ... + def DATETIME_ADD(self, expr, delta): ... + def DATETIME_SUB(self, expr, delta): ... + def DATETIME_DIFF(self, expr1, expr2): ... + def RANDOM(self): ... PY_UPPER: Incomplete PY_LOWER: Incomplete - def FLOAT_EQ(builder, a, b): ... - def FLOAT_NE(builder, a, b): ... - def JSON_QUERY(builder, expr, path): ... + def FLOAT_EQ(self, a, b): ... + def FLOAT_NE(self, a, b): ... + def JSON_QUERY(self, expr, path): ... json_value_type_mapping: Incomplete - def JSON_VALUE(builder, expr, path, type): ... - def JSON_NONZERO(builder, expr): ... - def JSON_ARRAY_LENGTH(builder, value): ... - def JSON_CONTAINS(builder, expr, path, key): ... - def ARRAY_INDEX(builder, col, index): ... - def ARRAY_CONTAINS(builder, key, not_in, col): ... - def ARRAY_SUBSET(builder, array1, not_in, array2): ... - def ARRAY_LENGTH(builder, array): ... - def ARRAY_SLICE(builder, array, start, stop): ... - def MAKE_ARRAY(builder, *items): ... + def JSON_VALUE(self, expr, path, type): ... + def JSON_NONZERO(self, expr): ... + def JSON_ARRAY_LENGTH(self, value): ... + def JSON_CONTAINS(self, expr, path, key): ... + def ARRAY_INDEX(self, col, index): ... + def ARRAY_CONTAINS(self, key, not_in, col): ... + def ARRAY_SUBSET(self, array1, not_in, array2): ... + def ARRAY_LENGTH(self, array): ... + def ARRAY_SLICE(self, array, start, stop): ... + def MAKE_ARRAY(self, *items): ... class SQLiteIntConverter(dbapiprovider.IntConverter): - def sql_type(converter): ... + def sql_type(self): ... class SQLiteDecimalConverter(dbapiprovider.DecimalConverter): inf: Incomplete neg_inf: Incomplete NaN: Incomplete - def sql2py(converter, val): ... - def py2sql(converter, val): ... + def sql2py(self, val): ... + def py2sql(self, val): ... class SQLiteDateConverter(dbapiprovider.DateConverter): - def sql2py(converter, val): ... - def py2sql(converter, val): ... + def sql2py(self, val): ... + def py2sql(self, val): ... class SQLiteTimeConverter(dbapiprovider.TimeConverter): - def sql2py(converter, val): ... - def py2sql(converter, val): ... + def sql2py(self, val): ... + def py2sql(self, val): ... class SQLiteTimedeltaConverter(dbapiprovider.TimedeltaConverter): - def sql2py(converter, val): ... - def py2sql(converter, val): ... + def sql2py(self, val): ... + def py2sql(self, val): ... class SQLiteDatetimeConverter(dbapiprovider.DatetimeConverter): - def sql2py(converter, val): ... - def py2sql(converter, val): ... + def sql2py(self, val): ... + def py2sql(self, val): ... class SQLiteJsonConverter(dbapiprovider.JsonConverter): json_kwargs: Incomplete @@ -110,8 +110,8 @@ def dumps(items): ... class SQLiteArrayConverter(dbapiprovider.ArrayConverter): array_types: Incomplete - def dbval2val(converter, dbval, obj=None): ... - def val2dbval(converter, val, obj=None): ... + def dbval2val(self, dbval, obj=None): ... + def val2dbval(self, val, obj=None): ... class LocalExceptions(localbase): exc_info: Incomplete @@ -132,21 +132,21 @@ class SQLiteProvider(DBAPIProvider): array_converter_cls: ClassVar[type[SQLiteArrayConverter]] server_version: tuple[int, int, int] converter_classes: Incomplete - def __init__(provider, database, filename, **kwargs) -> None: ... - def inspect_connection(provider, conn) -> None: ... - def restore_exception(provider) -> None: ... - def acquire_lock(provider) -> None: ... - def release_lock(provider) -> None: ... - def set_transaction_mode(provider, connection: _Connection, cache) -> None: ... - def commit(provider, connection: _Connection, cache=None) -> None: ... - def rollback(provider, connection: _Connection, cache=None) -> None: ... - def drop(provider, connection: _Connection, cache=None) -> None: ... - def release(provider, connection: _Connection, cache=None) -> None: ... - def get_pool(provider, is_shared_memory_db, filename, create_db: bool = False, **kwargs): ... - def table_exists(provider, connection: _Connection, table_name: str, case_sensitive: bool = True): ... - def index_exists(provider, connection: _Connection, table_name: str, index_name, case_sensitive: bool = True): ... - def fk_exists(provider, connection: _Connection, table_name: str, fk_name) -> None: ... # type: ignore[override] - def check_json1(provider, connection: _Connection) -> bool: ... + def __init__(self, database, filename, **kwargs) -> None: ... + def inspect_connection(self, conn) -> None: ... + def restore_exception(self) -> None: ... + def acquire_lock(self) -> None: ... + def release_lock(self) -> None: ... + def set_transaction_mode(self, connection: _Connection, cache) -> None: ... + def commit(self, connection: _Connection, cache=None) -> None: ... + def rollback(self, connection: _Connection, cache=None) -> None: ... + def drop(self, connection: _Connection, cache=None) -> None: ... + def release(self, connection: _Connection, cache=None) -> None: ... + def get_pool(self, is_shared_memory_db, filename, create_db: bool = False, **kwargs): ... + def table_exists(self, connection: _Connection, table_name: str, case_sensitive: bool = True): ... + def index_exists(self, connection: _Connection, table_name: str, index_name, case_sensitive: bool = True): ... + def fk_exists(self, connection: _Connection, table_name: str, fk_name) -> None: ... # type: ignore[override] + def check_json1(self, connection: _Connection) -> bool: ... provider_cls = SQLiteProvider @@ -189,7 +189,7 @@ class SQLitePool(Pool): kwargs: dict[str, Incomplete] if sys.version_info >= (3, 12): def __init__( - pool, + self, is_shared_memory_db: bool | None, filename: StrOrBytesPath, create_db: bool | None, @@ -204,7 +204,7 @@ class SQLitePool(Pool): ) -> None: ... else: def __init__( - pool, + self, is_shared_memory_db: bool | None, filename: StrOrBytesPath, create_db: bool | None, @@ -217,5 +217,5 @@ class SQLitePool(Pool): uri: bool = False, ) -> None: ... - def disconnect(pool) -> None: ... - def drop(pool, con: _Connection) -> None: ... + def disconnect(self) -> None: ... + def drop(self, con: _Connection) -> None: ... diff --git a/stubs/pony/pony/orm/dbschema.pyi b/stubs/pony/pony/orm/dbschema.pyi index 686ca5f2dc7e..adadc93560b6 100644 --- a/stubs/pony/pony/orm/dbschema.pyi +++ b/stubs/pony/pony/orm/dbschema.pyi @@ -18,30 +18,30 @@ class DBSchema: command_separator: str uppercase: bool names: dict[Incomplete, Incomplete] - def __init__(schema, provider: DBAPIProvider, uppercase: bool = True) -> None: ... - def column_list(schema, columns): ... - def case(schema, s: str) -> str: ... - def add_table(schema, table_name, entity=None): ... - def order_tables_to_create(schema): ... - def generate_create_script(schema): ... - def create_tables(schema, provider: DBAPIProvider, connection) -> None: ... - def check_tables(schema, provider: DBAPIProvider, connection) -> None: ... + def __init__(self, provider: DBAPIProvider, uppercase: bool = True) -> None: ... + def column_list(self, columns): ... + def case(self, s: str) -> str: ... + def add_table(self, table_name, entity=None): ... + def order_tables_to_create(self): ... + def generate_create_script(self): ... + def create_tables(self, provider: DBAPIProvider, connection) -> None: ... + def check_tables(self, provider: DBAPIProvider, connection) -> None: ... class DBObject: - def create(table, provider, connection) -> None: ... + def create(self, provider, connection) -> None: ... class Table(DBObject): typename: ClassVar[str] - def __init__(table, name, schema, entity=None) -> None: ... - def add_entity(table, entity) -> None: ... - def exists(table, provider: DBAPIProvider, connection, case_sensitive: bool = True): ... - def get_create_command(table): ... - def format_option(table, name, value): ... - def get_objects_to_create(table, created_tables: set[Table] | None = None) -> list[Table]: ... - def add_column(table, column_name, sql_type, converter, is_not_null: bool | None = None, sql_default=None): ... - def add_index(table, index_name, columns, is_pk: bool = False, is_unique=None, m2m: bool = False): ... + def __init__(self, name, schema, entity=None) -> None: ... + def add_entity(self, entity) -> None: ... + def exists(self, provider: DBAPIProvider, connection, case_sensitive: bool = True): ... + def get_create_command(self): ... + def format_option(self, name, value): ... + def get_objects_to_create(self, created_tables: set[Table] | None = None) -> list[Table]: ... + def add_column(self, column_name, sql_type, converter, is_not_null: bool | None = None, sql_default=None): ... + def add_index(self, index_name, columns, is_pk: bool = False, is_unique=None, m2m: bool = False): ... def add_foreign_key( - table, + self, fk_name, child_columns, parent_table, @@ -53,25 +53,25 @@ class Table(DBObject): class Column: auto_template: ClassVar[str] - def __init__(column, name, table, sql_type, converter, is_not_null: bool | None = None, sql_default=None) -> None: ... - def get_sql(column) -> str: ... + def __init__(self, name, table, sql_type, converter, is_not_null: bool | None = None, sql_default=None) -> None: ... + def get_sql(self) -> str: ... class Constraint(DBObject): schema: DBSchema name: str | None - def __init__(constraint, name: str | None, schema: DBSchema) -> None: ... + def __init__(self, name: str | None, schema: DBSchema) -> None: ... class DBIndex(Constraint): typename: ClassVar[str] - def __init__(index, name: str | None, table, columns, is_pk: bool = False, is_unique=None) -> None: ... - def exists(index, provider, connection, case_sensitive: bool = True): ... - def get_sql(index) -> str: ... - def get_create_command(index): ... + def __init__(self, name: str | None, table, columns, is_pk: bool = False, is_unique=None) -> None: ... + def exists(self, provider, connection, case_sensitive: bool = True): ... + def get_sql(self) -> str: ... + def get_create_command(self): ... class ForeignKey(Constraint): typename: ClassVar[str] def __init__( - foreign_key, + self, name, child_table, child_columns, @@ -81,6 +81,6 @@ class ForeignKey(Constraint): on_delete, interleave: bool = False, ) -> None: ... - def exists(foreign_key, provider, connection, case_sensitive: bool = True): ... - def get_sql(foreign_key) -> str: ... - def get_create_command(foreign_key): ... + def exists(self, provider, connection, case_sensitive: bool = True): ... + def get_sql(self) -> str: ... + def get_create_command(self): ... diff --git a/stubs/pony/pony/orm/decompiling.pyi b/stubs/pony/pony/orm/decompiling.pyi index 4fe1eb5a6280..9755f2715761 100644 --- a/stubs/pony/pony/orm/decompiling.pyi +++ b/stubs/pony/pony/orm/decompiling.pyi @@ -14,18 +14,22 @@ def binop(node_type): ... operator_mapping: dict[str, type[ast.cmpop]] +double_load_store_ops: set[str] +direct_jump_to_loop_ops: dict[str, str] + def clean_assign(node): ... def make_const(value): ... def is_const(value) -> bool: ... def unwrap_str(key) -> str: ... +def slice_to_ast(value): ... class Decompiler: - def __init__(decompiler, code, start: int = 0, end=None) -> None: ... - def get_instructions(decompiler) -> None: ... - def analyze_jumps(decompiler) -> None: ... - def decompile(decompiler) -> None: ... - def pop_items(decompiler, size): ... - def store(decompiler, node) -> None: ... + def __init__(self, code, start: int = 0, end=None) -> None: ... + def get_instructions(self) -> None: ... + def analyze_jumps(self) -> None: ... + def decompile(self) -> None: ... + def pop_items(self, size): ... + def store(self, node) -> None: ... BINARY_POWER: Incomplete BINARY_MULTIPLY: Incomplete BINARY_DIVIDE: Incomplete @@ -39,96 +43,110 @@ class Decompiler: BINARY_OR: Incomplete BINARY_TRUE_DIVIDE = BINARY_DIVIDE # pyrefly: ignore [unknown-name] BINARY_MODULO: Incomplete - def BINARY_OP(decompiler, opcode): ... - def BINARY_SLICE(decompiler): ... - def BINARY_SUBSCR(decompiler): ... - def BUILD_CONST_KEY_MAP(decompiler, length): ... - def BUILD_LIST(decompiler, size): ... - def BUILD_MAP(decompiler, length): ... - def BUILD_SET(decompiler, size): ... - def BUILD_SLICE(decompiler, size): ... - def BUILD_TUPLE(decompiler, size): ... - def BUILD_STRING(decompiler, count): ... - def CALL_FUNCTION(decompiler, argc, star=None, star2=None): ... - def CACHE(decompiler) -> None: ... - def CALL(decompiler, argc): ... - def CALL_FUNCTION_VAR(decompiler, argc): ... - def CALL_FUNCTION_KW(decompiler, argc): ... - def CALL_FUNCTION_VAR_KW(decompiler, argc): ... - def CALL_FUNCTION_EX(decompiler, argc): ... - def CALL_METHOD(decompiler, argc): ... - def COMPARE_OP(decompiler, op): ... - def COPY(decompiler, _) -> None: ... - def COPY_FREE_VARS(decompiler, n) -> None: ... - def CONTAINS_OP(decompiler, invert): ... - def DUP_TOP(decompiler): ... - def FOR_ITER(decompiler, endpos): ... - def FORMAT_VALUE(decompiler, flags): ... - def GEN_START(decompiler, kind) -> None: ... - def GET_ITER(decompiler) -> None: ... - def JUMP_IF_FALSE(decompiler, endpos): ... + def BINARY_OP(self, opcode): ... + def BINARY_SLICE(self): ... + def BINARY_SUBSCR(self): ... + def BUILD_CONST_KEY_MAP(self, length): ... + def BUILD_LIST(self, size): ... + def BUILD_MAP(self, length): ... + def BUILD_SET(self, size): ... + def BUILD_SLICE(self, size): ... + def BUILD_TUPLE(self, size): ... + def BUILD_STRING(self, count): ... + def CALL_FUNCTION(self, argc, star=None, star2=None): ... + def CACHE(self) -> None: ... + def CALL(self, argc): ... + def CALL_FUNCTION_VAR(self, argc): ... + def CALL_FUNCTION_KW(self, argc): ... + def CALL_FUNCTION_VAR_KW(self, argc): ... + def CALL_FUNCTION_EX(self, argc=1): ... + def CALL_METHOD(self, argc): ... + def CALL_KW(self, argc): ... + def COMPARE_OP(self, op): ... + def COPY(self, _) -> None: ... + def COPY_FREE_VARS(self, n) -> None: ... + def CONTAINS_OP(self, invert): ... + def CONVERT_VALUE(self, conversion): ... + def DUP_TOP(self): ... + def FOR_ITER(self, endpos): ... + def FORMAT_VALUE(self, flags): ... + def FORMAT_SIMPLE(self): ... + def FORMAT_WITH_SPEC(self): ... + def GEN_START(self, kind) -> None: ... + def GET_ITER(self) -> None: ... + def JUMP_IF_FALSE(self, endpos): ... JUMP_IF_FALSE_OR_POP = JUMP_IF_FALSE - def JUMP_IF_NOT_EXC_MATCH(decompiler, endpos) -> None: ... - def JUMP_IF_TRUE(decompiler, endpos): ... + def JUMP_IF_NOT_EXC_MATCH(self, endpos) -> None: ... + def JUMP_IF_TRUE(self, endpos): ... JUMP_IF_TRUE_OR_POP = JUMP_IF_TRUE - def conditional_jump(decompiler, endpos, if_true): ... - def conditional_jump_old(decompiler, endpos, if_true): ... - def conditional_jump_new(decompiler, endpos, if_true): ... - def conditional_jump_none_impl(decompiler, endpos, negate): ... - def jump_if_none(decompiler, endpos): ... - def jump_if_not_none(decompiler, endpos): ... - def process_target(decompiler, pos, partial: bool = False) -> None: ... - def JUMP_FORWARD(decompiler, endpos): ... - def KW_NAMES(decompiler, kw_names) -> None: ... - def IS_OP(decompiler, invert): ... - def LIST_APPEND(decompiler, offset) -> None: ... - def LIST_EXTEND(decompiler, offset): ... - def LIST_TO_TUPLE(decompiler): ... - def LOAD_ATTR(decompiler, attr_name, push_null): ... - def LOAD_CLOSURE(decompiler, freevar): ... - def LOAD_CONST(decompiler, const_value): ... - def LOAD_DEREF(decompiler, freevar): ... - def LOAD_FAST(decompiler, varname): ... + def conditional_jump(self, endpos, if_true): ... + def conditional_jump_old(self, endpos, if_true): ... + def conditional_jump_new(self, endpos, if_true): ... + def conditional_jump_none_impl(self, endpos, negate): ... + def jump_if_none(self, endpos): ... + def jump_if_not_none(self, endpos): ... + def process_target(self, pos, partial: bool = False) -> None: ... + def JUMP_FORWARD(self, endpos): ... + def KW_NAMES(self, kw_names) -> None: ... + def IS_OP(self, invert): ... + def LIST_APPEND(self, offset) -> None: ... + def LIST_EXTEND(self, offset): ... + def LIST_TO_TUPLE(self): ... + def LOAD_ATTR(self, attr_name, push_null): ... + def LOAD_CLOSURE(self, freevar): ... + def LOAD_CONST(self, const_value): ... + def LOAD_DEREF(self, freevar): ... + def LOAD_FAST(self, varname): ... LOAD_FAST_AND_CLEAR = LOAD_FAST - def LOAD_GLOBAL(decompiler, varname, push_null): ... - def LOAD_METHOD(decompiler, methname): ... + def LOAD_FAST_BORROW(self, varname): ... + def LOAD_FAST_BORROW_LOAD_FAST_BORROW(self, varname1, varname2): ... + def LOAD_FAST_LOAD_FAST(self, varname1, varname2): ... + def LOAD_GLOBAL(self, varname, push_null): ... + def LOAD_METHOD(self, methname): ... LOOKUP_METHOD = LOAD_METHOD - def LOAD_NAME(decompiler, varname): ... - def MAKE_CELL(decompiler, freevar) -> None: ... - def MAKE_CLOSURE(decompiler, argc): ... - def MAKE_FUNCTION(decompiler, argc): ... + def LOAD_NAME(self, varname): ... + def LOAD_SMALL_INT(self, value): ... + def MAKE_CELL(self, freevar) -> None: ... + def MAKE_CLOSURE(self, argc): ... + def MAKE_FUNCTION(self, argc=0): ... POP_JUMP_BACKWARD_IF_FALSE = JUMP_IF_FALSE POP_JUMP_BACKWARD_IF_TRUE = JUMP_IF_TRUE POP_JUMP_FORWARD_IF_FALSE = JUMP_IF_FALSE POP_JUMP_FORWARD_IF_TRUE = JUMP_IF_TRUE POP_JUMP_IF_FALSE = JUMP_IF_FALSE POP_JUMP_IF_TRUE = JUMP_IF_TRUE + def POP_JUMP_IF_NONE(self, endpos): ... + def POP_JUMP_IF_NOT_NONE(self, endpos): ... POP_JUMP_BACKWARD_IF_NONE = jump_if_none POP_JUMP_BACKWARD_IF_NOT_NONE = jump_if_not_none POP_JUMP_FORWARD_IF_NONE = jump_if_none POP_JUMP_FORWARD_IF_NOT_NONE = jump_if_not_none - def POP_TOP(decompiler) -> None: ... - def PRECALL(decompiler, argc) -> None: ... - def PUSH_NULL(decompiler) -> None: ... - def RETURN_VALUE(decompiler): ... - def RETURN_CONST(decompiler, val): ... - def RETURN_GENERATOR(decompiler) -> None: ... - def RESUME(decompiler, where) -> None: ... - def ROT_TWO(decompiler) -> None: ... - def ROT_THREE(decompiler) -> None: ... - def SETUP_LOOP(decompiler, endpos) -> None: ... - def STORE_ATTR(decompiler, attrname) -> None: ... - def STORE_DEREF(decompiler, freevar) -> None: ... - def STORE_FAST(decompiler, varname) -> None: ... - def STORE_MAP(decompiler) -> None: ... - def STORE_SUBSCR(decompiler) -> None: ... - def SWAP(decompiler, _) -> None: ... - def UNARY_POSITIVE(decompiler): ... - def UNARY_NEGATIVE(decompiler): ... - def UNARY_NOT(decompiler): ... - def UNARY_INVERT(decompiler): ... - def UNPACK_SEQUENCE(decompiler, count): ... - def YIELD_VALUE(decompiler, _=None): ... + def POP_TOP(self) -> None: ... + def PRECALL(self, argc) -> None: ... + def PUSH_NULL(self) -> None: ... + def RETURN_VALUE(self): ... + def RETURN_CONST(self, val): ... + def RETURN_GENERATOR(self) -> None: ... + def RESUME(self, where) -> None: ... + def ROT_TWO(self) -> None: ... + def ROT_THREE(self) -> None: ... + def SET_FUNCTION_ATTRIBUTE(self, flag): ... + def SETUP_LOOP(self, endpos) -> None: ... + def STORE_ATTR(self, attrname) -> None: ... + def STORE_DEREF(self, freevar) -> None: ... + def STORE_FAST(self, varname) -> None: ... + def STORE_FAST_LOAD_FAST(self, varname1, varname2): ... + def STORE_FAST_STORE_FAST(self, varname1, varname2): ... + def STORE_MAP(self) -> None: ... + def STORE_SUBSCR(self) -> None: ... + def SWAP(self, _) -> None: ... + def TO_BOOL(self): ... + def UNARY_POSITIVE(self): ... + def UNARY_NEGATIVE(self): ... + def UNARY_NOT(self): ... + def UNARY_INVERT(self): ... + def UNPACK_SEQUENCE(self, count): ... + def YIELD_VALUE(self, _=None): ... test_lines: str diff --git a/stubs/pony/pony/orm/serialization.pyi b/stubs/pony/pony/orm/serialization.pyi index b8acc580ce37..9d3b953a0c05 100644 --- a/stubs/pony/pony/orm/serialization.pyi +++ b/stubs/pony/pony/orm/serialization.pyi @@ -13,9 +13,9 @@ class Bag: objects: defaultdict[type[Entity], set[Entity]] vars: dict[Incomplete, Incomplete] dicts: defaultdict[Incomplete, dict[Incomplete, Incomplete]] - def __init__(bag, database: Database) -> None: ... + def __init__(self, database: Database) -> None: ... def config( - bag, + self, entity: Entity, only=None, exclude=None, @@ -23,9 +23,9 @@ class Bag: with_lazy: bool = False, related_objects: bool = True, ) -> tuple[Incomplete, bool]: ... - def put(bag, x: Entity | Iterable[Entity]) -> None: ... - def to_dict(bag): ... - def to_json(bag) -> str: ... + def put(self, x: Entity | Iterable[Entity]) -> None: ... + def to_dict(self): ... + def to_json(self) -> str: ... def to_dict(objects): ... def to_json(objects) -> str: ... diff --git a/stubs/pony/pony/orm/sqlbuilding.pyi b/stubs/pony/pony/orm/sqlbuilding.pyi index e123d2be9993..8b17488758ed 100644 --- a/stubs/pony/pony/orm/sqlbuilding.pyi +++ b/stubs/pony/pony/orm/sqlbuilding.pyi @@ -12,15 +12,15 @@ class Param: paramkey: Incomplete converter: Incomplete optimistic: bool - def __init__(param, paramstyle, paramkey, converter=None, optimistic: bool = False) -> None: ... - def eval(param, values): ... + def __init__(self, paramstyle, paramkey, converter=None, optimistic: bool = False) -> None: ... + def eval(self, values): ... class CompositeParam(Param): __slots__ = ("items", "func") items: Iterable[Param | Value] func: Incomplete - def __init__(param, paramstyle, paramkey, items: Iterable[Param | Value], func) -> None: ... - def eval(param, values): ... + def __init__(self, paramstyle, paramkey, items: Iterable[Param | Value], func) -> None: ... + def eval(self, values): ... class Value: __slots__ = ("paramstyle", "value") @@ -45,45 +45,45 @@ class SQLBuilder: indent_spaces: ClassVar[str] least_func_name: ClassVar[str] greatest_func_name: ClassVar[str] - def __init__(builder, provider, ast) -> None: ... - def __call__(builder, ast): ... - def INSERT(builder, table_name, columns, values, returning=None): ... - def DEFAULT(builder): ... - def UPDATE(builder, table_name, pairs, where=None): ... - def DELETE(builder, alias, from_ast, where=None): ... - def SELECT(builder, *sections): ... - def SELECT_FOR_UPDATE(builder, nowait, skip_locked, *sections): ... - def EXISTS(builder, *sections): ... - def NOT_EXISTS(builder, *sections): ... + def __init__(self, provider, ast) -> None: ... + def __call__(self, ast): ... + def INSERT(self, table_name, columns, values, returning=None): ... + def DEFAULT(self): ... + def UPDATE(self, table_name, pairs, where=None): ... + def DELETE(self, alias, from_ast, where=None): ... + def SELECT(self, *sections): ... + def SELECT_FOR_UPDATE(self, nowait, skip_locked, *sections): ... + def EXISTS(self, *sections): ... + def NOT_EXISTS(self, *sections): ... def ALL(builder, *expr_list): ... def DISTINCT(builder, *expr_list): ... def AGGREGATES(builder, *expr_list): ... - def AS(builder, expr, alias): ... - def compound_name(builder, name_parts): ... - def sql_join(builder, join_type, sources): ... - def FROM(builder, *sources): ... - def INNER_JOIN(builder, *sources): ... + def AS(self, expr, alias): ... + def compound_name(self, name_parts): ... + def sql_join(self, join_type, sources): ... + def FROM(self, *sources): ... + def INNER_JOIN(self, *sources): ... def LEFT_JOIN(builder, *sources): ... - def WHERE(builder, *conditions): ... - def HAVING(builder, *conditions): ... + def WHERE(self, *conditions): ... + def HAVING(self, *conditions): ... def GROUP_BY(builder, *expr_list): ... def UNION(builder, kind, *sections): ... def INTERSECT(builder, *sections): ... def EXCEPT(builder, *sections): ... def ORDER_BY(builder, *order_list): ... - def DESC(builder, expr): ... + def DESC(self, expr): ... def LIMIT(builder, limit, offset=None): ... - def COLUMN(builder, table_alias, col_name): ... - def PARAM(builder, paramkey, converter=None, optimistic: bool = False): ... - def make_param(builder, param_class, paramkey, *args): ... - def make_composite_param(builder, paramkey, items, func): ... - def STAR(builder, table_alias): ... - def ROW(builder, *items): ... - def VALUE(builder, value): ... - def AND(builder, *cond_list): ... - def OR(builder, *cond_list): ... - def NOT(builder, condition): ... - def POW(builder, expr1, expr2): ... + def COLUMN(self, table_alias, col_name): ... + def PARAM(self, paramkey, converter=None, optimistic: bool = False): ... + def make_param(self, param_class, paramkey, *args): ... + def make_composite_param(self, paramkey, items, func): ... + def STAR(self, table_alias): ... + def ROW(self, *items): ... + def VALUE(self, value): ... + def AND(self, *cond_list): ... + def OR(self, *cond_list): ... + def NOT(self, condition): ... + def POW(self, expr1, expr2): ... EQ: Incomplete NE: Incomplete LT: Incomplete @@ -95,65 +95,65 @@ class SQLBuilder: MUL: Incomplete DIV: Incomplete FLOORDIV: Incomplete - def MOD(builder, a, b): ... - def FLOAT_EQ(builder, a, b): ... - def FLOAT_NE(builder, a, b): ... - def CONCAT(builder, *args): ... - def NEG(builder, expr): ... - def IS_NULL(builder, expr): ... - def IS_NOT_NULL(builder, expr): ... - def LIKE(builder, expr, template, escape=None): ... - def NOT_LIKE(builder, expr, template, escape=None): ... - def BETWEEN(builder, expr1, expr2, expr3): ... - def NOT_BETWEEN(builder, expr1, expr2, expr3): ... - def IN(builder, expr1, x): ... - def NOT_IN(builder, expr1, x): ... - def COUNT(builder, distinct, *expr_list): ... - def SUM(builder, distinct, expr): ... - def AVG(builder, distinct, expr): ... - def GROUP_CONCAT(builder, distinct, expr, sep=None): ... + def MOD(self, a, b): ... + def FLOAT_EQ(self, a, b): ... + def FLOAT_NE(self, a, b): ... + def CONCAT(self, *args): ... + def NEG(self, expr): ... + def IS_NULL(self, expr): ... + def IS_NOT_NULL(self, expr): ... + def LIKE(self, expr, template, escape=None): ... + def NOT_LIKE(self, expr, template, escape=None): ... + def BETWEEN(self, expr1, expr2, expr3): ... + def NOT_BETWEEN(self, expr1, expr2, expr3): ... + def IN(self, expr1, x): ... + def NOT_IN(self, expr1, x): ... + def COUNT(self, distinct, *expr_list): ... + def SUM(self, distinct, expr): ... + def AVG(self, distinct, expr): ... + def GROUP_CONCAT(self, distinct, expr, sep=None): ... UPPER: Incomplete LOWER: Incomplete LENGTH: Incomplete ABS: Incomplete - def COALESCE(builder, *args): ... - def MIN(builder, distinct, *args): ... - def MAX(builder, distinct, *args): ... - def SUBSTR(builder, expr, start, len=None): ... - def STRING_SLICE(builder, expr, start, stop): ... - def CASE(builder, expr, cases, default=None): ... - def IF(builder, cond, then, else_): ... - def TRIM(builder, expr, chars=None): ... - def LTRIM(builder, expr, chars=None): ... - def RTRIM(builder, expr, chars=None): ... - def REPLACE(builder, str, from_, to): ... - def TO_INT(builder, expr): ... - def TO_STR(builder, expr): ... - def TO_REAL(builder, expr): ... - def TODAY(builder): ... - def NOW(builder): ... - def DATE(builder, expr): ... - def YEAR(builder, expr): ... - def MONTH(builder, expr): ... - def DAY(builder, expr): ... - def HOUR(builder, expr): ... - def MINUTE(builder, expr): ... - def SECOND(builder, expr): ... - def RANDOM(builder): ... - def RAWSQL(builder, sql): ... - def build_json_path(builder, path): ... + def COALESCE(self, *args): ... + def MIN(self, distinct, *args): ... + def MAX(self, distinct, *args): ... + def SUBSTR(self, expr, start, len=None): ... + def STRING_SLICE(self, expr, start, stop): ... + def CASE(self, expr, cases, default=None): ... + def IF(self, cond, then, else_): ... + def TRIM(self, expr, chars=None): ... + def LTRIM(self, expr, chars=None): ... + def RTRIM(self, expr, chars=None): ... + def REPLACE(self, str, from_, to): ... + def TO_INT(self, expr): ... + def TO_STR(self, expr): ... + def TO_REAL(self, expr): ... + def TODAY(self): ... + def NOW(self): ... + def DATE(self, expr): ... + def YEAR(self, expr): ... + def MONTH(self, expr): ... + def DAY(self, expr): ... + def HOUR(self, expr): ... + def MINUTE(self, expr): ... + def SECOND(self, expr): ... + def RANDOM(self): ... + def RAWSQL(self, sql): ... + def build_json_path(self, path): ... @classmethod def eval_json_path(cls, values: Iterable[int | str | types.EllipsisType | slice]) -> str: ... - def JSON_QUERY(builder, expr, path) -> None: ... - def JSON_VALUE(builder, expr, path, type) -> None: ... - def JSON_NONZERO(builder, expr) -> None: ... - def JSON_CONCAT(builder, left, right) -> None: ... - def JSON_CONTAINS(builder, expr, path, key) -> None: ... - def JSON_ARRAY_LENGTH(builder, value) -> None: ... - def JSON_PARAM(builder, expr): ... - def ARRAY_INDEX(builder, col, index) -> None: ... - def ARRAY_CONTAINS(builder, key, not_in, col) -> None: ... - def ARRAY_SUBSET(builder, array1, not_in, array2) -> None: ... - def ARRAY_LENGTH(builder, array) -> None: ... - def ARRAY_SLICE(builder, array, start, stop) -> None: ... - def MAKE_ARRAY(builder, *items) -> None: ... + def JSON_QUERY(self, expr, path) -> None: ... + def JSON_VALUE(self, expr, path, type) -> None: ... + def JSON_NONZERO(self, expr) -> None: ... + def JSON_CONCAT(self, left, right) -> None: ... + def JSON_CONTAINS(self, expr, path, key) -> None: ... + def JSON_ARRAY_LENGTH(self, value) -> None: ... + def JSON_PARAM(self, expr): ... + def ARRAY_INDEX(self, col, index) -> None: ... + def ARRAY_CONTAINS(self, key, not_in, col) -> None: ... + def ARRAY_SUBSET(self, array1, not_in, array2) -> None: ... + def ARRAY_LENGTH(self, array) -> None: ... + def ARRAY_SLICE(self, array, start, stop) -> None: ... + def MAKE_ARRAY(self, *items) -> None: ... diff --git a/stubs/pony/pony/orm/sqltranslation.pyi b/stubs/pony/pony/orm/sqltranslation.pyi index e2454f8d81df..51d8030f0034 100644 --- a/stubs/pony/pony/orm/sqltranslation.pyi +++ b/stubs/pony/pony/orm/sqltranslation.pyi @@ -23,7 +23,7 @@ def check_comparable(left_monad: Monad, right_monad: Monad, op: str = "==") -> N class IncomparableTypesError(TypeError): type1: Incomplete type2: Incomplete - def __init__(exc, type1, type2) -> None: ... + def __init__(self, type1, type2) -> None: ... def sqland(items): ... def sqlor(items): ... @@ -32,7 +32,7 @@ def type2str(t) -> str: ... class Local(localbase): translators: list[SQLTranslator] - def __init__(local) -> None: ... + def __init__(self) -> None: ... @property def translator(self) -> SQLTranslator: ... @@ -48,13 +48,13 @@ class SQLTranslator(ASTTranslator): registered_functions: dict[types.FunctionType, type[FuncMonad]] def __enter__(translator) -> None: ... def __exit__(translator, exc_type, exc_val, exc_tb) -> None: ... - def default_post(translator, node) -> None: ... - def dispatch(translator, node): ... - def dispatch_external(translator, node) -> None: ... - def call(translator, method, node): ... - def deepcopy(translator): ... + def default_post(self, node) -> None: ... + def dispatch(self, node): ... + def dispatch_external(self, node) -> None: ... + def call(self, method, node): ... + def deepcopy(self): ... def __init__( - translator, + self, tree, parent_translator, code_key=None, @@ -66,7 +66,7 @@ class SQLTranslator(ASTTranslator): optimize=None, ) -> None: ... def init( - translator, + self, tree, parent_translator, code_key=None, @@ -79,15 +79,15 @@ class SQLTranslator(ASTTranslator): ): ... @property def namespace(translator): ... - def can_be_optimized(translator): ... + def can_be_optimized(self): ... def process_query_qual( - translator, prev_translator, prev_limit, prev_offset, names, try_extend_prev_query: bool = False + self, prev_translator, prev_limit, prev_offset, names, try_extend_prev_query: bool = False ) -> None: ... def construct_subquery_ast( - translator, limit=None, offset=None, aliases=None, star=None, distinct=None, is_not_null_checks: bool = False + self, limit=None, offset=None, aliases=None, star=None, distinct=None, is_not_null_checks: bool = False ): ... def construct_sql_ast( - translator, + self, limit=None, offset=None, distinct=None, @@ -99,61 +99,61 @@ class SQLTranslator(ASTTranslator): skip_locked: bool = False, is_not_null_checks: bool = False, ): ... - def construct_delete_sql_ast(translator): ... - def get_used_attrs(translator): ... - def without_order(translator) -> Self: ... - def order_by_numbers(translator, numbers: Iterable[int]) -> Self: ... - def order_by_attributes(translator, attrs: Iterable[core.DescWrapper | core.Attribute]) -> Self: ... - def apply_kwfilters(translator, filterattrs, original_names: bool = False) -> Self: ... + def construct_delete_sql_ast(self): ... + def get_used_attrs(self): ... + def without_order(self) -> Self: ... + def order_by_numbers(self, numbers: Iterable[int]) -> Self: ... + def order_by_attributes(self, attrs: Iterable[core.DescWrapper | core.Attribute]) -> Self: ... + def apply_kwfilters(self, filterattrs, original_names: bool = False) -> Self: ... def apply_lambda( - translator, func_id, filter_num, order_by, func_ast, argnames, original_names, extractors, vars, vartypes + self, func_id, filter_num, order_by, func_ast, argnames, original_names, extractors, vars, vartypes ) -> Self: ... - def preGeneratorExp(translator, node: ast.GeneratorExp) -> QuerySetMonad: ... - def postExpr(translator, node: ast.Expr): ... - def preCompare(translator, node: ast.Compare): ... - def postConstant(translator, node: ast.Constant) -> ConstMonad: ... + def preGeneratorExp(self, node: ast.GeneratorExp) -> QuerySetMonad: ... + def postExpr(self, node: ast.Expr): ... + def preCompare(self, node: ast.Compare): ... + def postConstant(self, node: ast.Constant) -> ConstMonad: ... if sys.version_info >= (3, 14): - def postNameConstant(translator, node: ast.Constant): ... - def postNum(translator, node: ast.Constant) -> ConstMonad: ... - def postStr(translator, node: ast.Constant) -> ConstMonad: ... - def postBytes(translator, node: ast.Constant) -> ConstMonad: ... + def postNameConstant(self, node: ast.Constant): ... + def postNum(self, node: ast.Constant) -> ConstMonad: ... + def postStr(self, node: ast.Constant) -> ConstMonad: ... + def postBytes(self, node: ast.Constant) -> ConstMonad: ... else: - def postNameConstant(translator, node: ast.NameConstant): ... - def postNum(translator, node: ast.Num) -> ConstMonad: ... - def postStr(translator, node: ast.Str) -> ConstMonad: ... - def postBytes(translator, node: ast.Bytes) -> ConstMonad: ... - - def postList(translator, node: ast.List) -> ListMonad: ... - def postTuple(translator, node: ast.Tuple) -> ListMonad: ... - def postName(translator, node: ast.Name) -> Monad: ... - def resolve_name(translator, name) -> Monad: ... - def postAdd(translator, node: ast.Add): ... - def postSub(translator, node: ast.Sub): ... - def postMult(translator, node: ast.Mult): ... - def postMatMult(translator, node: ast.MatMult) -> Never: ... - def postDiv(translator, node: ast.Div): ... - def postFloorDiv(translator, node: ast.FloorDiv): ... - def postMod(translator, node: ast.Mod): ... - def postLShift(translator, node: ast.LShift) -> Never: ... - def postRShift(translator, node: ast.RShift) -> Never: ... - def postPow(translator, node: ast.Pow): ... - def postUSub(translator, node: ast.USub): ... - def postAttribute(translator, node: ast.Attribute): ... - def postAnd(translator, node: ast.And) -> AndMonad: ... - def postOr(translator, node: ast.Or) -> OrMonad: ... - def postBitOr(translator, node: ast.BitOr): ... - def postBitAnd(translator, node: ast.BitAnd): ... - def postBitXor(translator, node: ast.BitXor): ... - def postNot(translator, node: ast.Not): ... - def preCall(translator, node: ast.Call): ... - def postCall(translator, node: ast.Call): ... - def postkeyword(translator, node: ast.keyword) -> None: ... - def postSubscript(translator, node: ast.Subscript): ... - def postSlice(translator, node: ast.Slice) -> None: ... - def postIndex(translator, node: ast.Index): ... - def postIfExp(translator, node: ast.IfExp) -> ExprMonad: ... - def postJoinedStr(translator, node: ast.JoinedStr) -> StringExprMonad: ... - def postFormattedValue(translator, node: ast.FormattedValue): ... + def postNameConstant(self, node: ast.NameConstant): ... + def postNum(self, node: ast.Num) -> ConstMonad: ... + def postStr(self, node: ast.Str) -> ConstMonad: ... + def postBytes(self, node: ast.Bytes) -> ConstMonad: ... + + def postList(self, node: ast.List) -> ListMonad: ... + def postTuple(self, node: ast.Tuple) -> ListMonad: ... + def postName(self, node: ast.Name) -> Monad: ... + def resolve_name(self, name) -> Monad: ... + def postAdd(self, node: ast.Add): ... + def postSub(self, node: ast.Sub): ... + def postMult(self, node: ast.Mult): ... + def postMatMult(self, node: ast.MatMult) -> Never: ... + def postDiv(self, node: ast.Div): ... + def postFloorDiv(self, node: ast.FloorDiv): ... + def postMod(self, node: ast.Mod): ... + def postLShift(self, node: ast.LShift) -> Never: ... + def postRShift(self, node: ast.RShift) -> Never: ... + def postPow(self, node: ast.Pow): ... + def postUSub(self, node: ast.USub): ... + def postAttribute(self, node: ast.Attribute): ... + def postAnd(self, node: ast.And) -> AndMonad: ... + def postOr(self, node: ast.Or) -> OrMonad: ... + def postBitOr(self, node: ast.BitOr): ... + def postBitAnd(self, node: ast.BitAnd): ... + def postBitXor(self, node: ast.BitXor): ... + def postNot(self, node: ast.Not): ... + def preCall(self, node: ast.Call): ... + def postCall(self, node: ast.Call): ... + def postkeyword(self, node: ast.keyword) -> None: ... + def postSubscript(self, node: ast.Subscript): ... + def postSlice(self, node: ast.Slice) -> None: ... + def postIndex(self, node: ast.Index): ... + def postIfExp(self, node: ast.IfExp) -> ExprMonad: ... + def postJoinedStr(self, node: ast.JoinedStr) -> StringExprMonad: ... + def postFormattedValue(self, node: ast.FormattedValue): ... def combine_limit_and_offset(limit, offset, limit2, offset2) -> tuple[Incomplete, Incomplete]: ... def coerce_monads(m1, m2, for_comparison: bool = False): ... @@ -171,11 +171,11 @@ class SqlQuery: alias_counters: dict[Incomplete, Incomplete] expr_counter: itertools.count[int] used_from_subquery: bool - def __init__(sqlquery, translator, parent_sqlquery: SqlQuery | None = None, left_join: bool = False) -> None: ... - def get_tableref(sqlquery, name_path): ... - def add_tableref(sqlquery, name_path, parent_tableref, attr) -> JoinedTableRef: ... - def make_alias(sqlquery, name: str) -> str: ... - def join_table(sqlquery, parent_alias, alias, table_name, join_cond) -> None: ... + def __init__(self, translator, parent_sqlquery: SqlQuery | None = None, left_join: bool = False) -> None: ... + def get_tableref(self, name_path): ... + def add_tableref(self, name_path, parent_tableref, attr) -> JoinedTableRef: ... + def make_alias(self, name: str) -> str: ... + def join_table(self, parent_alias, alias, table_name, join_cond) -> None: ... class TableRef: sqlquery: SqlQuery @@ -185,20 +185,20 @@ class TableRef: joined: bool can_affect_distinct: bool used_attrs: set[Incomplete] - def __init__(tableref, sqlquery: SqlQuery, name: str, entity) -> None: ... - def make_join(tableref, pk_only: bool = False) -> tuple[str, Incomplete]: ... + def __init__(self, sqlquery: SqlQuery, name: str, entity) -> None: ... + def make_join(self, pk_only: bool = False) -> tuple[str, Incomplete]: ... class ExprTableRef(TableRef): - def __init__(tableref, sqlquery: SqlQuery, name: str, subquery_ast, expr_names, expr_aliases) -> None: ... - def make_join(tableref, pk_only: bool = False) -> tuple[str, Incomplete]: ... + def __init__(self, sqlquery: SqlQuery, name: str, subquery_ast, expr_names, expr_aliases) -> None: ... + def make_join(self, pk_only: bool = False) -> tuple[str, Incomplete]: ... class StarTableRef(TableRef): - def __init__(tableref, sqlquery: SqlQuery, name: str, entity, subquery_ast) -> None: ... - def make_join(tableref, pk_only: bool = False) -> tuple[str, Incomplete]: ... + def __init__(self, sqlquery: SqlQuery, name: str, entity, subquery_ast) -> None: ... + def make_join(self, pk_only: bool = False) -> tuple[str, Incomplete]: ... class ExprJoinedTableRef: - def __init__(tableref, sqlquery: SqlQuery, parent_tableref, parent_columns, name, entity) -> None: ... - def make_join(tableref, pk_only: bool = False) -> tuple[str, Incomplete]: ... + def __init__(self, sqlquery: SqlQuery, parent_tableref, parent_columns, name, entity) -> None: ... + def make_join(self, pk_only: bool = False) -> tuple[str, Incomplete]: ... class JoinedTableRef: sqlquery: SqlQuery @@ -212,8 +212,8 @@ class JoinedTableRef: joined: bool can_affect_distinct: bool used_attrs: set[Incomplete] - def __init__(tableref, sqlquery: SqlQuery, name_path: str, parent_tableref, attr) -> None: ... - def make_join(tableref, pk_only: bool = False) -> tuple[str, Incomplete]: ... + def __init__(self, sqlquery: SqlQuery, name_path: str, parent_tableref, attr) -> None: ... + def make_join(self, pk_only: bool = False) -> tuple[str, Incomplete]: ... def wrap_monad_method(cls_name: str, func: types.FunctionType): ... @@ -229,18 +229,18 @@ class Monad(metaclass=MonadMeta): translator: SQLTranslator type: Incomplete nullable: bool - def __init__(monad, type, nullable: bool = True) -> None: ... - def mixin_init(monad) -> None: ... - def to_single_cell_value(monad): ... - def cmp(monad, op, monad2): ... - def contains(monad, item, not_in: bool = False) -> None: ... - def nonzero(monad): ... - def negate(monad): ... - def getattr(monad, attrname): ... - def len(monad) -> None: ... - def count(monad, distinct=None): ... - def aggregate(monad, func_name, distinct=None, sep=None): ... - def __call__(monad, *args, **kwargs) -> None: ... + def __init__(self, type, nullable: bool = True) -> None: ... + def mixin_init(self) -> None: ... + def to_single_cell_value(self): ... + def cmp(self, op, monad2): ... + def contains(self, item, not_in: bool = False) -> None: ... + def nonzero(self): ... + def negate(self): ... + def getattr(self, attrname): ... + def len(self) -> None: ... + def count(self, distinct=None): ... + def aggregate(self, func_name, distinct=None, sep=None): ... + def __call__(self, *args, **kwargs) -> None: ... def __getitem__(monad, key) -> None: ... def __add__(monad, monad2) -> None: ... def __sub__(monad, monad2) -> None: ... @@ -252,19 +252,19 @@ class Monad(metaclass=MonadMeta): def __or__(monad, monad2) -> None: ... def __and__(monad, monad2) -> None: ... def __xor__(monad, monad2) -> None: ... - def abs(monad) -> None: ... - def cast_from_json(monad, type) -> None: ... - def to_int(monad): ... - def to_str(monad): ... - def to_real(monad): ... + def abs(self) -> None: ... + def cast_from_json(self, type) -> None: ... + def to_int(self): ... + def to_str(self): ... + def to_real(self): ... def distinct_from_monad(distinct, default=None): ... class RawSQLMonad(Monad): - def __init__(monad, rawtype, varkey, nullable: bool = True) -> None: ... - def contains(monad, item, not_in: bool = False): ... - def nonzero(monad): ... - def getsql(monad, sqlquery=None): ... + def __init__(self, rawtype, varkey, nullable: bool = True) -> None: ... + def contains(self, item, not_in: bool = False): ... + def nonzero(self): ... + def getsql(self, sqlquery=None): ... typeerror_re_1: re.Pattern[str] typeerror_re_2: re.Pattern[str] @@ -273,13 +273,13 @@ def reraise_improved_typeerror(exc: Exception, func_name: str | tuple[str, ...], def raise_forgot_parentheses(monad: Monad) -> Never: ... class MethodMonad(Monad): - def __init__(monad, parent, attrname) -> None: ... - def getattr(monad, attrname) -> None: ... - def __call__(monad, *args, **kwargs): ... - def contains(monad, item, not_in: bool = False) -> None: ... - def nonzero(monad) -> None: ... - def negate(monad) -> None: ... - def aggregate(monad, func_name, distinct=None, sep=None) -> None: ... + def __init__(self, parent, attrname) -> None: ... + def getattr(self, attrname) -> None: ... + def __call__(self, *args, **kwargs): ... + def contains(self, item, not_in: bool = False) -> None: ... + def nonzero(self) -> None: ... + def negate(self) -> None: ... + def aggregate(self, func_name, distinct=None, sep=None) -> None: ... def __getitem__(monad, key) -> None: ... def __add__(monad, monad2) -> None: ... def __sub__(monad, monad2) -> None: ... @@ -288,16 +288,16 @@ class MethodMonad(Monad): def __floordiv__(monad, monad2) -> None: ... def __pow__(monad, monad2) -> None: ... def __neg__(monad) -> None: ... - def abs(monad) -> None: ... + def abs(self) -> None: ... class EntityMonad(Monad): - def __init__(monad, entity) -> None: ... + def __init__(self, entity) -> None: ... def __getitem__(monad, *args) -> None: ... class ListMonad(Monad): - def __init__(monad, items) -> None: ... - def contains(monad, x, not_in: bool = False): ... - def getsql(monad, sqlquery=None): ... + def __init__(self, items) -> None: ... + def contains(self, x, not_in: bool = False): ... + def getsql(self, sqlquery=None): ... class BufferMixin(MonadMixin): ... class UuidMixin(MonadMixin): ... @@ -305,7 +305,7 @@ class UuidMixin(MonadMixin): ... def make_numeric_binop(op, sqlop): ... class NumericMixin(MonadMixin): - def mixin_init(monad) -> None: ... + def mixin_init(self) -> None: ... __add__: Incomplete __sub__: Incomplete __mul__: Incomplete @@ -317,15 +317,15 @@ class NumericMixin(MonadMixin): __xor__: Incomplete def __pow__(monad, monad2): ... def __neg__(monad): ... - def abs(monad): ... - def nonzero(monad): ... - def negate(monad): ... + def abs(self): ... + def nonzero(self): ... + def negate(self): ... def numeric_attr_factory(name): ... def make_datetime_binop(op, sqlop): ... class DateMixin(MonadMixin): - def mixin_init(monad) -> None: ... + def mixin_init(self) -> None: ... attr_year: Incomplete attr_month: Incomplete attr_day: Incomplete @@ -333,17 +333,17 @@ class DateMixin(MonadMixin): def __sub__(monad, other): ... class TimeMixin(MonadMixin): - def mixin_init(monad) -> None: ... + def mixin_init(self) -> None: ... attr_hour: Incomplete attr_minute: Incomplete attr_second: Incomplete class TimedeltaMixin(MonadMixin): - def mixin_init(monad) -> None: ... + def mixin_init(self) -> None: ... class DatetimeMixin(DateMixin): - def mixin_init(monad) -> None: ... - def call_date(monad): ... + def mixin_init(self) -> None: ... + def call_date(self): ... attr_hour: Incomplete attr_minute: Incomplete attr_second: Incomplete @@ -354,61 +354,61 @@ def make_string_binop(op, sqlop): ... def make_string_func(sqlop): ... class StringMixin(MonadMixin): - def mixin_init(monad) -> None: ... + def mixin_init(self) -> None: ... __add__: Incomplete def __getitem__(monad, index): ... - def negate(monad): ... - def nonzero(monad): ... - def len(monad): ... - def contains(monad, item, not_in: bool = False): ... + def negate(self): ... + def nonzero(self): ... + def len(self): ... + def contains(self, item, not_in: bool = False): ... call_upper: Incomplete call_lower: Incomplete - def call_startswith(monad, arg): ... - def call_endswith(monad, arg): ... - def strip(monad, chars, strip_type): ... - def call_strip(monad, chars=None): ... - def call_lstrip(monad, chars=None): ... - def call_rstrip(monad, chars=None): ... + def call_startswith(self, arg): ... + def call_endswith(self, arg): ... + def strip(self, chars, strip_type): ... + def call_strip(self, chars=None): ... + def call_lstrip(self, chars=None): ... + def call_rstrip(self, chars=None): ... class JsonMixin: disable_distinct: ClassVar[bool] disable_ordering: ClassVar[bool] - def mixin_init(monad) -> None: ... - def get_path(monad): ... + def mixin_init(self) -> None: ... + def get_path(self): ... def __getitem__(monad, key): ... - def contains(monad, key, not_in: bool = False): ... + def contains(self, key, not_in: bool = False): ... def __or__(monad, other): ... - def len(monad): ... - def cast_from_json(monad, type): ... - def nonzero(monad): ... + def len(self): ... + def cast_from_json(self, type): ... + def nonzero(self): ... class ArrayMixin(MonadMixin): - def contains(monad, key, not_in: bool = False): ... - def len(monad): ... - def nonzero(monad): ... + def contains(self, key, not_in: bool = False): ... + def len(self): ... + def nonzero(self): ... def __getitem__(monad, index): ... class ObjectMixin(MonadMixin): - def mixin_init(monad) -> None: ... - def negate(monad): ... - def nonzero(monad): ... - def getattr(monad, attrname): ... - def requires_distinct(monad, joined: bool = False): ... + def mixin_init(self) -> None: ... + def negate(self): ... + def nonzero(self): ... + def getattr(self, attrname): ... + def requires_distinct(self, joined: bool = False): ... class ObjectIterMonad(ObjectMixin, Monad): - def __init__(monad, tableref, entity) -> None: ... - def getsql(monad, sqlquery=None): ... - def requires_distinct(monad, joined: bool = False): ... + def __init__(self, tableref, entity) -> None: ... + def getsql(self, sqlquery=None): ... + def requires_distinct(self, joined: bool = False): ... class AttrMonad(Monad): @staticmethod def new(parent, attr, *args, **kwargs) -> AttrMonad: ... def __new__(cls, parent, attr): ... - def __init__(monad, parent, attr) -> None: ... - def getsql(monad, sqlquery=None): ... + def __init__(self, parent, attr) -> None: ... + def getsql(self, sqlquery=None): ... class ObjectAttrMonad(ObjectMixin, AttrMonad): - def __init__(monad, parent, attr) -> None: ... + def __init__(self, parent, attr) -> None: ... class StringAttrMonad(StringMixin, AttrMonad): ... class NumericAttrMonad(NumericMixin, AttrMonad): ... @@ -425,13 +425,13 @@ class ParamMonad(Monad): @staticmethod def new(t, paramkey) -> ParamMonad: ... def __new__(cls, *args, **kwargs): ... - def __init__(monad, t, paramkey) -> None: ... - def getsql(monad, sqlquery=None): ... + def __init__(self, t, paramkey) -> None: ... + def getsql(self, sqlquery=None): ... class ObjectParamMonad(ObjectMixin, ParamMonad): - def __init__(monad, entity, paramkey) -> None: ... - def getsql(monad, sqlquery=None): ... - def requires_distinct(monad, joined: bool = False) -> None: ... + def __init__(self, entity, paramkey) -> None: ... + def getsql(self, sqlquery=None): ... + def requires_distinct(self, joined: bool = False) -> None: ... class StringParamMonad(StringMixin, ParamMonad): ... class NumericParamMonad(NumericMixin, ParamMonad): ... @@ -443,21 +443,21 @@ class BufferParamMonad(BufferMixin, ParamMonad): ... class UuidParamMonad(UuidMixin, ParamMonad): ... class ArrayParamMonad(ArrayMixin, ParamMonad): - def __init__(monad, t, paramkey, list_monad=None) -> None: ... - def contains(monad, key, not_in: bool = False): ... + def __init__(self, t, paramkey, list_monad=None) -> None: ... + def contains(self, key, not_in: bool = False): ... class JsonParamMonad(JsonMixin, ParamMonad): - def getsql(monad, sqlquery=None): ... + def getsql(self, sqlquery=None): ... class ExprMonad(Monad): @staticmethod def new(t, sql, nullable: bool = True) -> ExprMonad: ... def __new__(cls, *args, **kwargs): ... - def __init__(monad, type, sql, nullable: bool = True) -> None: ... - def getsql(monad, sqlquery=None): ... + def __init__(self, type, sql, nullable: bool = True) -> None: ... + def getsql(self, sqlquery=None): ... class ObjectExprMonad(ObjectMixin, ExprMonad): - def getsql(monad, sqlquery=None): ... + def getsql(self, sqlquery=None): ... class StringExprMonad(StringMixin, ExprMonad): ... class NumericExprMonad(NumericMixin, ExprMonad): ... @@ -469,34 +469,34 @@ class JsonExprMonad(JsonMixin, ExprMonad): ... class ArrayExprMonad(ArrayMixin, ExprMonad): ... class JsonItemMonad(JsonMixin, Monad): # pyrefly: ignore [inconsistent-inheritance] - def __init__(monad, parent, key) -> None: ... - def get_path(monad): ... - def to_int(monad): ... - def to_str(monad): ... - def to_real(monad): ... - def cast_from_json(monad, type): ... - def getsql(monad): ... + def __init__(self, parent, key) -> None: ... + def get_path(self): ... + def to_int(self): ... + def to_str(self): ... + def to_real(self): ... + def cast_from_json(self, type): ... + def getsql(self): ... class ConstMonad(Monad): @staticmethod def new(value) -> ConstMonad: ... def __new__(cls, value): ... - def __init__(monad, value) -> None: ... - def getsql(monad, sqlquery=None): ... + def __init__(self, value) -> None: ... + def getsql(self, sqlquery=None): ... class NoneMonad(ConstMonad): type = NoneType def __new__(cls, value=None): ... - def __init__(monad, value=None) -> None: ... - def cmp(monad, op, monad2): ... - def contains(monad, item, not_in: bool = False): ... - def nonzero(monad): ... - def negate(monad): ... - def getattr(monad, attrname): ... - def len(monad): ... - def count(monad, distinct=None): ... - def aggregate(monad, func_name, distinct=None, sep=None): ... - def __call__(monad, *args, **kwargs): ... + def __init__(self, value=None) -> None: ... + def cmp(self, op, monad2): ... + def contains(self, item, not_in: bool = False): ... + def nonzero(self): ... + def negate(self): ... + def getattr(self, attrname): ... + def len(self): ... + def count(self, distinct=None): ... + def aggregate(self, func_name, distinct=None, sep=None): ... + def __call__(self, *args, **kwargs): ... def __getitem__(monad, key): ... def __add__(monad, monad2): ... def __sub__(monad, monad2): ... @@ -508,15 +508,15 @@ class NoneMonad(ConstMonad): def __or__(monad, monad2): ... def __and__(monad, monad2): ... def __xor__(monad, monad2): ... - def abs(monad): ... - def to_int(monad): ... - def to_str(monad): ... - def to_real(monad): ... + def abs(self): ... + def to_int(self): ... + def to_str(self): ... + def to_real(self): ... class EllipsisMonad(ConstMonad): ... class StringConstMonad(StringMixin, ConstMonad): - def len(monad): ... + def len(self): ... class JsonConstMonad(JsonMixin, ConstMonad): ... class BufferConstMonad(BufferMixin, ConstMonad): ... @@ -527,15 +527,15 @@ class TimedeltaConstMonad(TimedeltaMixin, ConstMonad): ... class DatetimeConstMonad(DatetimeMixin, ConstMonad): ... class BoolMonad(Monad): - def __init__(monad, nullable: bool = True) -> None: ... - def nonzero(monad): ... + def __init__(self, nullable: bool = True) -> None: ... + def nonzero(self): ... sql_negation: dict[str, str] class BoolExprMonad(BoolMonad): - def __init__(monad, sql, nullable: bool = True) -> None: ... - def getsql(monad, sqlquery=None): ... - def negate(monad): ... + def __init__(self, sql, nullable: bool = True) -> None: ... + def getsql(self, sqlquery=None): ... + def negate(self): ... cmp_ops: dict[str, str] cmp_negate: dict[str, str] @@ -543,13 +543,13 @@ cmp_negate: dict[str, str] class CmpMonad(BoolMonad): EQ: str NE: str - def __init__(monad, op: str, left, right) -> None: ... - def negate(monad): ... - def getsql(monad, sqlquery=None): ... + def __init__(self, op: str, left, right) -> None: ... + def negate(self): ... + def getsql(self, sqlquery=None): ... class LogicalBinOpMonad(BoolMonad): - def __init__(monad, operands) -> None: ... - def getsql(monad, sqlquery=None): ... + def __init__(self, operands) -> None: ... + def getsql(self, sqlquery=None): ... class AndMonad(LogicalBinOpMonad): binop: str @@ -558,16 +558,16 @@ class OrMonad(LogicalBinOpMonad): binop: str class NotMonad(BoolMonad): - def __init__(monad, operand) -> None: ... - def negate(monad): ... - def getsql(monad, sqlquery=None): ... + def __init__(self, operand) -> None: ... + def negate(self): ... + def getsql(self, sqlquery=None): ... class HybridFuncMonad(Monad): - def __init__(monad, func_type, func_name, *params) -> None: ... - def __call__(monad, *args, **kwargs): ... + def __init__(self, func_type, func_name, *params) -> None: ... + def __call__(self, *args, **kwargs): ... class HybridMethodMonad(HybridFuncMonad): - def __init__(monad, parent, attrname, func) -> None: ... + def __init__(self, parent, attrname, func) -> None: ... registered_functions: dict[types.FunctionType, type[FuncMonad]] @@ -575,163 +575,163 @@ class FuncMonadMeta(MonadMeta): def __new__(meta, cls_name: str, bases: tuple[type, ...], cls_dict: dict[str, Any]): ... class FuncMonad(Monad, metaclass=FuncMonadMeta): - def __call__(monad, *args, **kwargs): ... + def __call__(self, *args, **kwargs): ... def get_classes(classinfo) -> Generator[Incomplete]: ... class FuncIsinstanceMonad(FuncMonad): func = isinstance - def call(monad, obj, classinfo): ... + def call(self, obj, classinfo): ... class FuncBufferMonad(FuncMonad): func: type[bytes] - def call(monad, source, encoding=None, errors=None): ... + def call(self, source, encoding=None, errors=None): ... class FuncBoolMonad(FuncMonad): func: type[bool] - def call(monad, x): ... + def call(self, x): ... class FuncIntMonad(FuncMonad): func: type[int] - def call(monad, x): ... + def call(self, x): ... class FuncStrMonad(FuncMonad): func: type[str] - def call(monad, x): ... + def call(self, x): ... class FuncFloatMonad(FuncMonad): func: type[float] - def call(monad, x): ... + def call(self, x): ... class FuncDecimalMonad(FuncMonad): func: type[Decimal] - def call(monad, x): ... + def call(self, x): ... class FuncDateMonad(FuncMonad): func: type[date] - def call(monad, year, month, day): ... - def call_today(monad): ... + def call(self, year, month, day): ... + def call_today(self): ... class FuncTimeMonad(FuncMonad): func: type[time] - def call(monad, *args): ... + def call(self, *args): ... class FuncTimedeltaMonad(FuncMonad): func: type[timedelta] - def call(monad, days=None, seconds=None, microseconds=None, milliseconds=None, minutes=None, hours=None, weeks=None): ... + def call(self, days=None, seconds=None, microseconds=None, milliseconds=None, minutes=None, hours=None, weeks=None): ... class FuncDatetimeMonad(FuncDateMonad): func: type[datetime] - def call(monad, year, month, day, hour=None, minute=None, second=None, microsecond=None): ... - def call_now(monad): ... + def call(self, year, month, day, hour=None, minute=None, second=None, microsecond=None): ... + def call_now(self): ... class FuncBetweenMonad(FuncMonad): func = between - def call(monad, x, a, b): ... + def call(self, x, a, b): ... class FuncConcatMonad(FuncMonad): func = concat - def call(monad, *args): ... + def call(self, *args): ... class FuncLenMonad(FuncMonad): func = len - def call(monad, x): ... + def call(self, x): ... class FuncGetattrMonad(FuncMonad): func = getattr - def call(monad, obj_monad, name_monad): ... + def call(self, obj_monad, name_monad): ... class FuncRawSQLMonad(FuncMonad): func = raw_sql - def call(monad, *args) -> None: ... + def call(self, *args) -> None: ... class FuncCountMonad(FuncMonad): func: Incomplete - def call(monad, x=None, distinct=None): ... + def call(self, x=None, distinct=None): ... class FuncAbsMonad(FuncMonad): func = abs - def call(monad, x): ... + def call(self, x): ... class FuncSumMonad(FuncMonad): func: Incomplete - def call(monad, x, distinct=None): ... + def call(self, x, distinct=None): ... class FuncAvgMonad(FuncMonad): func: Incomplete - def call(monad, x, distinct=None): ... + def call(self, x, distinct=None): ... class FuncGroupConcatMonad(FuncMonad): func: Incomplete - def call(monad, x, sep=None, distinct=None): ... + def call(self, x, sep=None, distinct=None): ... class FuncCoalesceMonad(FuncMonad): func = coalesce - def call(monad, *args): ... + def call(self, *args): ... class FuncDistinctMonad(FuncMonad): func: Incomplete - def call(monad, x): ... + def call(self, x): ... class FuncMinMonad(FuncMonad): func: Incomplete - def call(monad, *args): ... + def call(self, *args): ... class FuncMaxMonad(FuncMonad): func: Incomplete - def call(monad, *args): ... + def call(self, *args): ... def minmax(monad, sqlop, *args): ... class FuncSelectMonad(FuncMonad): func = core.select - def call(monad, queryset): ... + def call(self, queryset): ... class FuncExistsMonad(FuncMonad): func = core.exists - def call(monad, arg): ... + def call(self, arg): ... class FuncDescMonad(FuncMonad): func = core.desc - def call(monad, expr): ... + def call(self, expr): ... class DescMonad(Monad): - def __init__(monad, expr) -> None: ... - def getsql(monad): ... + def __init__(self, expr) -> None: ... + def getsql(self): ... class JoinMonad(Monad): - def __init__(monad, type) -> None: ... - def __call__(monad, x): ... + def __init__(self, type) -> None: ... + def __call__(self, x): ... class FuncRandomMonad(FuncMonad): func = random - def __init__(monad, type) -> None: ... - def __call__(monad): ... + def __init__(self, type) -> None: ... + def __call__(self): ... class SetMixin(MonadMixin): forced_distinct: bool - def call_distinct(monad): ... + def call_distinct(self): ... def make_attrset_binop(op, sqlop): ... class AttrSetMonad(SetMixin, Monad): - def __init__(monad, parent, attr) -> None: ... - def cmp(monad, op, monad2) -> None: ... - def contains(monad, item, not_in: bool = False): ... - def getattr(monad, name): ... - def call_select(monad): ... + def __init__(self, parent, attr) -> None: ... + def cmp(self, op, monad2) -> None: ... + def contains(self, item, not_in: bool = False): ... + def getattr(self, name): ... + def call_select(self): ... call_filter = call_select - def call_exists(monad): ... - def requires_distinct(monad, joined: bool = False, for_count: bool = False): ... - def count(monad, distinct=None): ... + def call_exists(self): ... + def requires_distinct(self, joined: bool = False, for_count: bool = False): ... + def count(self, distinct=None): ... len = count - def aggregate(monad, func_name, distinct=None, sep=None): ... - def nonzero(monad): ... - def negate(monad): ... + def aggregate(self, func_name, distinct=None, sep=None): ... + def nonzero(self): ... + def negate(self): ... call_is_empty = negate - def make_tableref(monad, sqlquery): ... - def make_expr_list(monad): ... - def getsql(monad, sqlquery=None): ... + def make_tableref(self, sqlquery): ... + def make_expr_list(self): ... + def getsql(self, sqlquery=None): ... __add__: Incomplete __sub__: Incomplete __mul__: Incomplete @@ -741,9 +741,9 @@ class AttrSetMonad(SetMixin, Monad): def make_numericset_binop(op, sqlop): ... class NumericSetExprMonad(SetMixin, Monad): - def __init__(monad, op, sqlop, left, right) -> None: ... - def aggregate(monad, func_name, distinct=None, sep=None): ... - def getsql(monad, sqlquery=None): ... + def __init__(self, op, sqlop, left, right) -> None: ... + def aggregate(self, func_name, distinct=None, sep=None): ... + def getsql(self, sqlquery=None): ... __add__: Incomplete __sub__: Incomplete __mul__: Incomplete @@ -752,22 +752,22 @@ class NumericSetExprMonad(SetMixin, Monad): class QuerySetMonad(SetMixin, Monad): nogroup: bool - def __init__(monad, subtranslator) -> None: ... - def to_single_cell_value(monad): ... - def requires_distinct(monad, joined: bool = False) -> None: ... - def call_limit(monad, limit=None, offset=None): ... - def contains(monad, item, not_in: bool = False): ... - def nonzero(monad): ... - def negate(monad): ... - def count(monad, distinct=None): ... + def __init__(self, subtranslator) -> None: ... + def to_single_cell_value(self): ... + def requires_distinct(self, joined: bool = False) -> None: ... + def call_limit(self, limit=None, offset=None): ... + def contains(self, item, not_in: bool = False): ... + def nonzero(self): ... + def negate(self): ... + def count(self, distinct=None): ... len = count - def aggregate(monad, func_name, distinct=None, sep=None): ... - def call_count(monad, distinct=None): ... - def call_sum(monad, distinct=None): ... - def call_min(monad): ... - def call_max(monad): ... - def call_avg(monad, distinct=None): ... - def call_group_concat(monad, sep=None, distinct=None): ... - def getsql(monad): ... + def aggregate(self, func_name, distinct=None, sep=None): ... + def call_count(self, distinct=None): ... + def call_sum(self, distinct=None): ... + def call_min(self): ... + def call_max(self): ... + def call_avg(self, distinct=None): ... + def call_group_concat(self, sep=None, distinct=None): ... + def getsql(self): ... def find_or_create_having_ast(sections: list[Sequence[str]]): ... diff --git a/stubs/pony/pony/py23compat.pyi b/stubs/pony/pony/py23compat.pyi index 0854571aa135..054c77b6c3e8 100644 --- a/stubs/pony/pony/py23compat.pyi +++ b/stubs/pony/pony/py23compat.pyi @@ -6,6 +6,8 @@ PY39: bool PY310: bool PY311: bool PY312: bool +PY313: bool +PY314: bool unicode = str buffer = bytes int_types: tuple[type[int]] diff --git a/stubs/pony/pony/utils/utils.pyi b/stubs/pony/pony/utils/utils.pyi index ffe7c493afff..b7fd74ffca7a 100644 --- a/stubs/pony/pony/utils/utils.pyi +++ b/stubs/pony/pony/utils/utils.pyi @@ -1,5 +1,6 @@ import ast import io +import pickle import re from _typeshed import Incomplete, Unused from collections.abc import Callable, Iterable @@ -75,6 +76,12 @@ def pickle_ast(val): ... def unpickle_ast(pickled: io.BytesIO): ... def copy_ast(tree): ... +class PersistentPickler(pickle.Pickler): + def persistent_id(self, obj): ... + +class PersistentUnpickler(pickle.Unpickler): + def persistent_load(self, persid): ... + class HashableDict(dict[Incomplete, Incomplete]): def __hash__(self) -> int: ... # type: ignore[override] def __deepcopy__(self, memo): ... @@ -86,5 +93,11 @@ class HashableDict(dict[Incomplete, Incomplete]): setdefault: Incomplete update: Incomplete +class IntegerGenerator: + val: int + def __init__(self, firstval: int = 0) -> None: ... + def __iter__(self): ... + def __next__(self) -> int: ... + def deref_proxy(value): ... def deduplicate(value, deduplication_cache): ... From d7d3f2af9fd35bfad143bb295e26aeae3870a8d5 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 10 Aug 2026 07:48:58 +0000 Subject: [PATCH 2/3] [pre-commit.ci] auto fixes from pre-commit.com hooks --- stubs/pony/pony/orm/dbschema.pyi | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/stubs/pony/pony/orm/dbschema.pyi b/stubs/pony/pony/orm/dbschema.pyi index adadc93560b6..928aeb88645e 100644 --- a/stubs/pony/pony/orm/dbschema.pyi +++ b/stubs/pony/pony/orm/dbschema.pyi @@ -71,15 +71,7 @@ class DBIndex(Constraint): class ForeignKey(Constraint): typename: ClassVar[str] def __init__( - self, - name, - child_table, - child_columns, - parent_table, - parent_columns, - index_name, - on_delete, - interleave: bool = False, + self, name, child_table, child_columns, parent_table, parent_columns, index_name, on_delete, interleave: bool = False ) -> None: ... def exists(self, provider, connection, case_sensitive: bool = True): ... def get_sql(self) -> str: ... From 2d027ad92c56d75bd030ae667f75489ecca6b7d8 Mon Sep 17 00:00:00 2001 From: niallsemple Date: Mon, 10 Aug 2026 13:23:21 +0100 Subject: [PATCH 3/3] [pony] Pin stub version to ~= 0.7.20 --- stubs/pony/METADATA.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stubs/pony/METADATA.toml b/stubs/pony/METADATA.toml index 517628fd01cf..e5e65e786651 100644 --- a/stubs/pony/METADATA.toml +++ b/stubs/pony/METADATA.toml @@ -1,3 +1,3 @@ -version = "0.7.*" +version = "~=0.7.20" upstream-repository = "https://github.com/ponyorm/pony" optional-dependencies = ["types-psycopg2", "types-PyMySQL"]