sqlalchemy.exc.OperationalError: (pymysql.err.OperationalError) (2013, 'Lost connection to MySQL server during query') [SQL: SELECT live_config.id AS live_config_id, live_config.api_key AS live_config_api_key, live_config.api_secret_hash AS live_config_api_secret_hash, live_config.ip_whitelist AS live_config_ip_whitelist, live_config.enabled AS live_config_enabled, live_config.updated_at AS live_config_updated_at FROM live_config WHERE live_config.id = %(pk_1)s] [parameters: {'pk_1': 1}] (Background on this error at: https://sqlalche.me/e/20/e3q8)
_exec_single_context context,
):
evt_handled = True
break
if not evt_handled:
self.dialect.do_execute( ^
cursor, str_statement, effective_parameters, context
)
if self._has_events or self.engine._has_events:
self.dispatch.after_cursor_execute(do_execute def do_executemany(self, cursor, statement, parameters, context=None):
cursor.executemany(statement, parameters)
def do_execute(self, cursor, statement, parameters, context=None):
cursor.execute(statement, parameters) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
def do_execute_no_params(self, cursor, statement, context=None):
cursor.execute(statement)
def is_disconnect(execute while self.nextset():
pass
query = self.mogrify(query, args)
result = self._query(query) ^^^^^^^^^^^^^^^^^^
self._executed = query
return result
def executemany(self, query, args):
"""Run several data against one query._query self.rownumber = r
def _query(self, q):
conn = self._get_db()
self._clear_result()
conn.query(q) ^^^^^^^^^^^^^
self._do_get_result()
return self.rowcount
def _clear_result(self):
self.rownumber = 0query # if DEBUG:
# print("DEBUG: sending query:", sql)
if isinstance(sql, str):
sql = sql.encode(self.encoding, "surrogateescape")
self._execute_command(COMMAND.COM_QUERY, sql)
self._affected_rows = self._read_query_result(unbuffered=unbuffered) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return self._affected_rows
def next_result(self, unbuffered=False):
self._affected_rows = self._read_query_result(unbuffered=unbuffered)
return self._affected_rows_read_query_result self._result = None
result = MySQLResult(self)
if unbuffered:
result.init_unbuffered_query()
else:
result.read() ^^^^^^^^^^^^^
self._result = result
if result.server_status is not None:
self.server_status = result.server_status
return result.affected_rows
read if self.unbuffered_active:
self._finish_unbuffered_query()
def read(self):
try:
first_packet = self.connection._read_packet() ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
if first_packet.is_ok_packet():
self._read_ok_packet(first_packet)
elif first_packet.is_load_local_packet():
self._read_load_local_packet(first_packet)_read_packet bytes_to_read = btrl + (btrh << 16)
if packet_number != self._next_seq_id:
self._force_close()
if packet_number == 0:
# MariaDB sends error packet with seqno==0 when shutdown
raise err.OperationalError( ^
CR.CR_SERVER_LOST,
"Lost connection to MySQL server during query",
)
raise err.InternalError(
"Packet sequence number wrong - got %d expected %d"__call__ ) -> cabc.Iterable[bytes]:
"""The WSGI server calls the Flask application object as the
WSGI application. This calls :meth:`wsgi_app`, which can be
wrapped to apply middleware.
"""
return self.wsgi_app(environ, start_response) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
wsgi_app try:
ctx.push()
response = self.full_dispatch_request()
except Exception as e:
error = e
response = self.handle_exception(e) ^^^^^^^^^^^^^^^^^^^^^^^^
except:
error = sys.exc_info()[1]
raise
return response(environ, start_response)
finally:wrapped_function if options.intercept_exceptions and hasattr(app, "handle_exception"):
app_any: Any = app
def _after_request_decorator(f: Callable[..., Any]) -> Callable[..., Response]:
def wrapped_function(*args: Any, **kwargs: Any) -> Response:
return cors_after_request(app_any.make_response(f(*args, **kwargs))) ^^^^^^^^^^^^^^^^^^
return wrapped_function
app_any.handle_exception = _after_request_decorator(app_any.handle_exception)
app_any.handle_user_exception = _after_request_decorator(app_any.handle_user_exception)wsgi_app ctx = self.request_context(environ)
error: BaseException | None = None
try:
try:
ctx.push()
response = self.full_dispatch_request() ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
except Exception as e:
error = e
response = self.handle_exception(e)
except:
error = sys.exc_info()[1]full_dispatch_request request_started.send(self, _async_wrapper=self.ensure_sync)
rv = self.preprocess_request()
if rv is None:
rv = self.dispatch_request()
except Exception as e:
rv = self.handle_user_exception(e) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return self.finalize_request(rv)
def finalize_request(
self,
rv: ft.ResponseReturnValue | HTTPException,wrapped_function if options.intercept_exceptions and hasattr(app, "handle_exception"):
app_any: Any = app
def _after_request_decorator(f: Callable[..., Any]) -> Callable[..., Response]:
def wrapped_function(*args: Any, **kwargs: Any) -> Response:
return cors_after_request(app_any.make_response(f(*args, **kwargs))) ^^^^^^^^^^^^^^^^^^
return wrapped_function
app_any.handle_exception = _after_request_decorator(app_any.handle_exception)
app_any.handle_user_exception = _after_request_decorator(app_any.handle_user_exception)full_dispatch_request try:
request_started.send(self, _async_wrapper=self.ensure_sync)
rv = self.preprocess_request()
if rv is None:
rv = self.dispatch_request() ^^^^^^^^^^^^^^^^^^^^^^^
except Exception as e:
rv = self.handle_user_exception(e)
return self.finalize_request(rv)
def finalize_request(dispatch_request and req.method == "OPTIONS"
):
return self.make_default_options_response()
# otherwise dispatch to the handler for that endpoint
view_args: dict[str, t.Any] = req.view_args # type: ignore[assignment]
return self.ensure_sync(self.view_functions[rule.endpoint])(**view_args) # type: ignore[no-any-return] ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
def full_dispatch_request(self) -> Response:
"""Dispatches the request and on top of that performs request
pre and postprocessing as well as HTTP exception catching and
error handling.get_live_policy# ---- public read endpoint ----
@bp.route('/api/live/policy/<policy_id>', methods=['GET'])
def get_live_policy(policy_id):
config = _get_or_create_config() ^^^^^^^^^^^^^^^^^^^^^^^
ip = _client_ip()
if not coerce_bool(config.enabled):
_log(policy_id, ip, 503, "Live API disabled")
return jsonify({"error": "Service disabled", "message": "Live API is disabled"}), 503_get_or_create_config# ---- helpers ----
def _get_or_create_config():
config = LiveConfig.query.get(1) ^^^^^^^^^^^^^^^^^^^^^^^
if not config:
config = LiveConfig(id=1, enabled=False)
db.session.add(config)
db.session.commit()
return configgetwarned skip_warning = not enable_warnings or kwargs.pop(
"_sa_skip_warning", False
)
if not skip_warning:
_warn_with_version(message, version, wtype, stacklevel=3)
return fn(*args, **kwargs) # type: ignore[no-any-return] ^^^^^^^^^^^^^^^^^^^
doc = func.__doc__ is not None and func.__doc__ or ""
if docstring_header is not None:
docstring_header %= dict(func=func.__name__)
get """ # noqa: E501
self._no_criterion_assertion("get", order_by=False, distinct=False)
# we still implement _get_impl() so that baked query can override
# it
return self._get_impl(ident, loading.load_on_pk_identity) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
def _get_impl(
self,
primary_key_identity: _PKIdentityArgument,
db_load_fn: Callable[..., Any],_get_impl primary_key_identity: _PKIdentityArgument,
db_load_fn: Callable[..., Any],
identity_token: Optional[Any] = None,
) -> Optional[Any]:
mapper = self._only_full_mapper_zero("get")
return self.session._get_impl(
mapper,
primary_key_identity,
db_load_fn,
populate_existing=self.load_options._populate_existing,
with_for_update=self._for_update_arg,_get_impl if for_update_arg is not None:
statement._for_update_arg = for_update_arg
if options:
statement = statement.options(*options)
return db_load_fn(
self,
statement,
primary_key_identity,
load_options=load_options,
identity_token=identity_token,load_on_pk_identity execution_options = util.EMPTY_DICT.merge_with(
execution_options, {"_sa_orm_load_options": load_options}
)
result = (
session.execute( ^
q,
params=params,
execution_options=execution_options,
bind_arguments=bind_arguments,
)execute :return: a :class:`_engine.Result` object.
"""
return self._execute_internal(
statement,
params,
execution_options=execution_options,
bind_arguments=bind_arguments,
_parent_execute_state=_parent_execute_state,_execute_internal return conn.scalar(
statement, params or {}, execution_options=execution_options
)
if compile_state_cls:
result: Result[Any] = compile_state_cls.orm_execute_statement(
self,
statement,
params or {},
execution_options,
bind_arguments,orm_execute_statement params,
execution_options,
bind_arguments,
conn,
) -> Result:
result = conn.execute(
statement, params or {}, execution_options=execution_options
)
return cls.orm_setup_cursor_result(
session,
statement,execute try:
meth = statement._execute_on_connection
except AttributeError as err:
raise exc.ObjectNotExecutableError(statement) from err
else:
return meth(
self,
distilled_parameters,
execution_options or NO_OPTIONS,
)
_execute_on_connection execution_options: CoreExecuteOptionsParameter,
) -> Result[Any]:
if self.supports_execution:
if TYPE_CHECKING:
assert isinstance(self, Executable)
return connection._execute_clauseelement(
self, distilled_params, execution_options
)
else:
raise exc.ObjectNotExecutableError(self)
_execute_clauseelement column_keys=keys,
for_executemany=for_executemany,
schema_translate_map=schema_translate_map,
linting=self.dialect.compiler_linting | compiler.WARN_LINTING,
)
ret = self._execute_context(
dialect,
dialect.execution_ctx_cls._init_compiled,
compiled_sql,
distilled_parameters,
execution_options,_execute_context context.pre_exec()
if context.execute_style is ExecuteStyle.INSERTMANYVALUES:
return self._exec_insertmany_context(dialect, context)
else:
return self._exec_single_context(
dialect, context, statement, parameters
)
def _exec_single_context(
self,_exec_single_context context.post_exec()
result = context._setup_result_proxy()
except BaseException as e:
self._handle_dbapi_exception( ^
e, str_statement, effective_parameters, cursor, context
)
return result
_handle_dbapi_exception if newraise:
raise newraise.with_traceback(exc_info[2]) from e
elif should_wrap:
assert sqlalchemy_exception is not None
raise sqlalchemy_exception.with_traceback(exc_info[2]) from e ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
else:
assert exc_info[1] is not None
raise exc_info[1].with_traceback(exc_info[2])
finally:
del self._reentrant_error_exec_single_context context,
):
evt_handled = True
break
if not evt_handled:
self.dialect.do_execute( ^
cursor, str_statement, effective_parameters, context
)
if self._has_events or self.engine._has_events:
self.dispatch.after_cursor_execute(do_execute def do_executemany(self, cursor, statement, parameters, context=None):
cursor.executemany(statement, parameters)
def do_execute(self, cursor, statement, parameters, context=None):
cursor.execute(statement, parameters) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
def do_execute_no_params(self, cursor, statement, context=None):
cursor.execute(statement)
def is_disconnect(execute while self.nextset():
pass
query = self.mogrify(query, args)
result = self._query(query) ^^^^^^^^^^^^^^^^^^
self._executed = query
return result
def executemany(self, query, args):
"""Run several data against one query._query self.rownumber = r
def _query(self, q):
conn = self._get_db()
self._clear_result()
conn.query(q) ^^^^^^^^^^^^^
self._do_get_result()
return self.rowcount
def _clear_result(self):
self.rownumber = 0query # if DEBUG:
# print("DEBUG: sending query:", sql)
if isinstance(sql, str):
sql = sql.encode(self.encoding, "surrogateescape")
self._execute_command(COMMAND.COM_QUERY, sql)
self._affected_rows = self._read_query_result(unbuffered=unbuffered) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return self._affected_rows
def next_result(self, unbuffered=False):
self._affected_rows = self._read_query_result(unbuffered=unbuffered)
return self._affected_rows_read_query_result self._result = None
result = MySQLResult(self)
if unbuffered:
result.init_unbuffered_query()
else:
result.read() ^^^^^^^^^^^^^
self._result = result
if result.server_status is not None:
self.server_status = result.server_status
return result.affected_rows
read if self.unbuffered_active:
self._finish_unbuffered_query()
def read(self):
try:
first_packet = self.connection._read_packet() ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
if first_packet.is_ok_packet():
self._read_ok_packet(first_packet)
elif first_packet.is_load_local_packet():
self._read_load_local_packet(first_packet)_read_packet bytes_to_read = btrl + (btrh << 16)
if packet_number != self._next_seq_id:
self._force_close()
if packet_number == 0:
# MariaDB sends error packet with seqno==0 when shutdown
raise err.OperationalError( ^
CR.CR_SERVER_LOST,
"Lost connection to MySQL server during query",
)
raise err.InternalError(
"Packet sequence number wrong - got %d expected %d"sqlalchemy.exc.OperationalError: (pymysql.err.OperationalError) (2013, 'Lost connection to MySQL server during query') [SQL: SELECT live_config.id AS live_config_id, live_config.api_key AS live_config_api_key, live_config.api_secret_hash AS live_config_api_secret_hash, live_config.ip_whitelist AS live_config_ip_whitelist, live_config.enabled AS live_config_enabled, live_config.updated_at AS live_config_updated_at FROM live_config WHERE live_config.id = %(pk_1)s] [parameters: {'pk_1': 1}] (Background on this error at: https://sqlalche.me/e/20/e3q8)
This is the Copy/Paste friendly version of the traceback.
The console is locked and needs to be unlocked by entering the PIN. You can find the PIN printed out on the standard output of your shell that runs the server.
sqlalchemy.exc.OperationalError: (pymysql.err.OperationalError) (2013, 'Lost connection to MySQL server during query') [SQL: SELECT live_config.id AS live_config_id, live_config.api_key AS live_config_api_key, live_config.api_secret_hash AS live_config_api_secret_hash, live_config.ip_whitelist AS live_config_ip_whitelist, live_config.enabled AS live_config_enabled, live_config.updated_at AS live_config_updated_at FROM live_config WHERE live_config.id = %(pk_1)s] [parameters: {'pk_1': 1}] (Background on this error at: https://sqlalche.me/e/20/e3q8)
_exec_single_context context,
):
evt_handled = True
break
if not evt_handled:
self.dialect.do_execute( ^
cursor, str_statement, effective_parameters, context
)
if self._has_events or self.engine._has_events:
self.dispatch.after_cursor_execute(do_execute def do_executemany(self, cursor, statement, parameters, context=None):
cursor.executemany(statement, parameters)
def do_execute(self, cursor, statement, parameters, context=None):
cursor.execute(statement, parameters) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
def do_execute_no_params(self, cursor, statement, context=None):
cursor.execute(statement)
def is_disconnect(execute while self.nextset():
pass
query = self.mogrify(query, args)
result = self._query(query) ^^^^^^^^^^^^^^^^^^
self._executed = query
return result
def executemany(self, query, args):
"""Run several data against one query._query self.rownumber = r
def _query(self, q):
conn = self._get_db()
self._clear_result()
conn.query(q) ^^^^^^^^^^^^^
self._do_get_result()
return self.rowcount
def _clear_result(self):
self.rownumber = 0query # if DEBUG:
# print("DEBUG: sending query:", sql)
if isinstance(sql, str):
sql = sql.encode(self.encoding, "surrogateescape")
self._execute_command(COMMAND.COM_QUERY, sql)
self._affected_rows = self._read_query_result(unbuffered=unbuffered) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return self._affected_rows
def next_result(self, unbuffered=False):
self._affected_rows = self._read_query_result(unbuffered=unbuffered)
return self._affected_rows_read_query_result self._result = None
result = MySQLResult(self)
if unbuffered:
result.init_unbuffered_query()
else:
result.read() ^^^^^^^^^^^^^
self._result = result
if result.server_status is not None:
self.server_status = result.server_status
return result.affected_rows
read if self.unbuffered_active:
self._finish_unbuffered_query()
def read(self):
try:
first_packet = self.connection._read_packet() ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
if first_packet.is_ok_packet():
self._read_ok_packet(first_packet)
elif first_packet.is_load_local_packet():
self._read_load_local_packet(first_packet)_read_packet bytes_to_read = btrl + (btrh << 16)
if packet_number != self._next_seq_id:
self._force_close()
if packet_number == 0:
# MariaDB sends error packet with seqno==0 when shutdown
raise err.OperationalError( ^
CR.CR_SERVER_LOST,
"Lost connection to MySQL server during query",
)
raise err.InternalError(
"Packet sequence number wrong - got %d expected %d"__call__ ) -> cabc.Iterable[bytes]:
"""The WSGI server calls the Flask application object as the
WSGI application. This calls :meth:`wsgi_app`, which can be
wrapped to apply middleware.
"""
return self.wsgi_app(environ, start_response) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
wsgi_app try:
ctx.push()
response = self.full_dispatch_request()
except Exception as e:
error = e
response = self.handle_exception(e) ^^^^^^^^^^^^^^^^^^^^^^^^
except:
error = sys.exc_info()[1]
raise
return response(environ, start_response)
finally:wrapped_function if options.intercept_exceptions and hasattr(app, "handle_exception"):
app_any: Any = app
def _after_request_decorator(f: Callable[..., Any]) -> Callable[..., Response]:
def wrapped_function(*args: Any, **kwargs: Any) -> Response:
return cors_after_request(app_any.make_response(f(*args, **kwargs))) ^^^^^^^^^^^^^^^^^^
return wrapped_function
app_any.handle_exception = _after_request_decorator(app_any.handle_exception)
app_any.handle_user_exception = _after_request_decorator(app_any.handle_user_exception)wsgi_app ctx = self.request_context(environ)
error: BaseException | None = None
try:
try:
ctx.push()
response = self.full_dispatch_request() ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
except Exception as e:
error = e
response = self.handle_exception(e)
except:
error = sys.exc_info()[1]full_dispatch_request request_started.send(self, _async_wrapper=self.ensure_sync)
rv = self.preprocess_request()
if rv is None:
rv = self.dispatch_request()
except Exception as e:
rv = self.handle_user_exception(e) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return self.finalize_request(rv)
def finalize_request(
self,
rv: ft.ResponseReturnValue | HTTPException,wrapped_function if options.intercept_exceptions and hasattr(app, "handle_exception"):
app_any: Any = app
def _after_request_decorator(f: Callable[..., Any]) -> Callable[..., Response]:
def wrapped_function(*args: Any, **kwargs: Any) -> Response:
return cors_after_request(app_any.make_response(f(*args, **kwargs))) ^^^^^^^^^^^^^^^^^^
return wrapped_function
app_any.handle_exception = _after_request_decorator(app_any.handle_exception)
app_any.handle_user_exception = _after_request_decorator(app_any.handle_user_exception)full_dispatch_request try:
request_started.send(self, _async_wrapper=self.ensure_sync)
rv = self.preprocess_request()
if rv is None:
rv = self.dispatch_request() ^^^^^^^^^^^^^^^^^^^^^^^
except Exception as e:
rv = self.handle_user_exception(e)
return self.finalize_request(rv)
def finalize_request(dispatch_request and req.method == "OPTIONS"
):
return self.make_default_options_response()
# otherwise dispatch to the handler for that endpoint
view_args: dict[str, t.Any] = req.view_args # type: ignore[assignment]
return self.ensure_sync(self.view_functions[rule.endpoint])(**view_args) # type: ignore[no-any-return] ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
def full_dispatch_request(self) -> Response:
"""Dispatches the request and on top of that performs request
pre and postprocessing as well as HTTP exception catching and
error handling.get_live_policy# ---- public read endpoint ----
@bp.route('/api/live/policy/<policy_id>', methods=['GET'])
def get_live_policy(policy_id):
config = _get_or_create_config() ^^^^^^^^^^^^^^^^^^^^^^^
ip = _client_ip()
if not coerce_bool(config.enabled):
_log(policy_id, ip, 503, "Live API disabled")
return jsonify({"error": "Service disabled", "message": "Live API is disabled"}), 503_get_or_create_config# ---- helpers ----
def _get_or_create_config():
config = LiveConfig.query.get(1) ^^^^^^^^^^^^^^^^^^^^^^^
if not config:
config = LiveConfig(id=1, enabled=False)
db.session.add(config)
db.session.commit()
return configgetwarned skip_warning = not enable_warnings or kwargs.pop(
"_sa_skip_warning", False
)
if not skip_warning:
_warn_with_version(message, version, wtype, stacklevel=3)
return fn(*args, **kwargs) # type: ignore[no-any-return] ^^^^^^^^^^^^^^^^^^^
doc = func.__doc__ is not None and func.__doc__ or ""
if docstring_header is not None:
docstring_header %= dict(func=func.__name__)
get """ # noqa: E501
self._no_criterion_assertion("get", order_by=False, distinct=False)
# we still implement _get_impl() so that baked query can override
# it
return self._get_impl(ident, loading.load_on_pk_identity) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
def _get_impl(
self,
primary_key_identity: _PKIdentityArgument,
db_load_fn: Callable[..., Any],_get_impl primary_key_identity: _PKIdentityArgument,
db_load_fn: Callable[..., Any],
identity_token: Optional[Any] = None,
) -> Optional[Any]:
mapper = self._only_full_mapper_zero("get")
return self.session._get_impl(
mapper,
primary_key_identity,
db_load_fn,
populate_existing=self.load_options._populate_existing,
with_for_update=self._for_update_arg,_get_impl if for_update_arg is not None:
statement._for_update_arg = for_update_arg
if options:
statement = statement.options(*options)
return db_load_fn(
self,
statement,
primary_key_identity,
load_options=load_options,
identity_token=identity_token,load_on_pk_identity execution_options = util.EMPTY_DICT.merge_with(
execution_options, {"_sa_orm_load_options": load_options}
)
result = (
session.execute( ^
q,
params=params,
execution_options=execution_options,
bind_arguments=bind_arguments,
)execute :return: a :class:`_engine.Result` object.
"""
return self._execute_internal(
statement,
params,
execution_options=execution_options,
bind_arguments=bind_arguments,
_parent_execute_state=_parent_execute_state,_execute_internal return conn.scalar(
statement, params or {}, execution_options=execution_options
)
if compile_state_cls:
result: Result[Any] = compile_state_cls.orm_execute_statement(
self,
statement,
params or {},
execution_options,
bind_arguments,orm_execute_statement params,
execution_options,
bind_arguments,
conn,
) -> Result:
result = conn.execute(
statement, params or {}, execution_options=execution_options
)
return cls.orm_setup_cursor_result(
session,
statement,execute try:
meth = statement._execute_on_connection
except AttributeError as err:
raise exc.ObjectNotExecutableError(statement) from err
else:
return meth(
self,
distilled_parameters,
execution_options or NO_OPTIONS,
)
_execute_on_connection execution_options: CoreExecuteOptionsParameter,
) -> Result[Any]:
if self.supports_execution:
if TYPE_CHECKING:
assert isinstance(self, Executable)
return connection._execute_clauseelement(
self, distilled_params, execution_options
)
else:
raise exc.ObjectNotExecutableError(self)
_execute_clauseelement column_keys=keys,
for_executemany=for_executemany,
schema_translate_map=schema_translate_map,
linting=self.dialect.compiler_linting | compiler.WARN_LINTING,
)
ret = self._execute_context(
dialect,
dialect.execution_ctx_cls._init_compiled,
compiled_sql,
distilled_parameters,
execution_options,_execute_context context.pre_exec()
if context.execute_style is ExecuteStyle.INSERTMANYVALUES:
return self._exec_insertmany_context(dialect, context)
else:
return self._exec_single_context(
dialect, context, statement, parameters
)
def _exec_single_context(
self,_exec_single_context context.post_exec()
result = context._setup_result_proxy()
except BaseException as e:
self._handle_dbapi_exception( ^
e, str_statement, effective_parameters, cursor, context
)
return result
_handle_dbapi_exception if newraise:
raise newraise.with_traceback(exc_info[2]) from e
elif should_wrap:
assert sqlalchemy_exception is not None
raise sqlalchemy_exception.with_traceback(exc_info[2]) from e ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
else:
assert exc_info[1] is not None
raise exc_info[1].with_traceback(exc_info[2])
finally:
del self._reentrant_error_exec_single_context context,
):
evt_handled = True
break
if not evt_handled:
self.dialect.do_execute( ^
cursor, str_statement, effective_parameters, context
)
if self._has_events or self.engine._has_events:
self.dispatch.after_cursor_execute(do_execute def do_executemany(self, cursor, statement, parameters, context=None):
cursor.executemany(statement, parameters)
def do_execute(self, cursor, statement, parameters, context=None):
cursor.execute(statement, parameters) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
def do_execute_no_params(self, cursor, statement, context=None):
cursor.execute(statement)
def is_disconnect(execute while self.nextset():
pass
query = self.mogrify(query, args)
result = self._query(query) ^^^^^^^^^^^^^^^^^^
self._executed = query
return result
def executemany(self, query, args):
"""Run several data against one query._query self.rownumber = r
def _query(self, q):
conn = self._get_db()
self._clear_result()
conn.query(q) ^^^^^^^^^^^^^
self._do_get_result()
return self.rowcount
def _clear_result(self):
self.rownumber = 0query # if DEBUG:
# print("DEBUG: sending query:", sql)
if isinstance(sql, str):
sql = sql.encode(self.encoding, "surrogateescape")
self._execute_command(COMMAND.COM_QUERY, sql)
self._affected_rows = self._read_query_result(unbuffered=unbuffered) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return self._affected_rows
def next_result(self, unbuffered=False):
self._affected_rows = self._read_query_result(unbuffered=unbuffered)
return self._affected_rows_read_query_result self._result = None
result = MySQLResult(self)
if unbuffered:
result.init_unbuffered_query()
else:
result.read() ^^^^^^^^^^^^^
self._result = result
if result.server_status is not None:
self.server_status = result.server_status
return result.affected_rows
read if self.unbuffered_active:
self._finish_unbuffered_query()
def read(self):
try:
first_packet = self.connection._read_packet() ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
if first_packet.is_ok_packet():
self._read_ok_packet(first_packet)
elif first_packet.is_load_local_packet():
self._read_load_local_packet(first_packet)_read_packet bytes_to_read = btrl + (btrh << 16)
if packet_number != self._next_seq_id:
self._force_close()
if packet_number == 0:
# MariaDB sends error packet with seqno==0 when shutdown
raise err.OperationalError( ^
CR.CR_SERVER_LOST,
"Lost connection to MySQL server during query",
)
raise err.InternalError(
"Packet sequence number wrong - got %d expected %d"sqlalchemy.exc.OperationalError: (pymysql.err.OperationalError) (2013, 'Lost connection to MySQL server during query') [SQL: SELECT live_config.id AS live_config_id, live_config.api_key AS live_config_api_key, live_config.api_secret_hash AS live_config_api_secret_hash, live_config.ip_whitelist AS live_config_ip_whitelist, live_config.enabled AS live_config_enabled, live_config.updated_at AS live_config_updated_at FROM live_config WHERE live_config.id = %(pk_1)s] [parameters: {'pk_1': 1}] (Background on this error at: https://sqlalche.me/e/20/e3q8)
This is the Copy/Paste friendly version of the traceback.
The console is locked and needs to be unlocked by entering the PIN. You can find the PIN printed out on the standard output of your shell that runs the server.
sqlalchemy.exc.OperationalError: (pymysql.err.OperationalError) (2013, 'Lost connection to MySQL server during query') [SQL: SELECT live_config.id AS live_config_id, live_config.api_key AS live_config_api_key, live_config.api_secret_hash AS live_config_api_secret_hash, live_config.ip_whitelist AS live_config_ip_whitelist, live_config.enabled AS live_config_enabled, live_config.updated_at AS live_config_updated_at FROM live_config WHERE live_config.id = %(pk_1)s] [parameters: {'pk_1': 1}] (Background on this error at: https://sqlalche.me/e/20/e3q8)
_exec_single_context context,
):
evt_handled = True
break
if not evt_handled:
self.dialect.do_execute( ^
cursor, str_statement, effective_parameters, context
)
if self._has_events or self.engine._has_events:
self.dispatch.after_cursor_execute(do_execute def do_executemany(self, cursor, statement, parameters, context=None):
cursor.executemany(statement, parameters)
def do_execute(self, cursor, statement, parameters, context=None):
cursor.execute(statement, parameters) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
def do_execute_no_params(self, cursor, statement, context=None):
cursor.execute(statement)
def is_disconnect(execute while self.nextset():
pass
query = self.mogrify(query, args)
result = self._query(query) ^^^^^^^^^^^^^^^^^^
self._executed = query
return result
def executemany(self, query, args):
"""Run several data against one query._query self.rownumber = r
def _query(self, q):
conn = self._get_db()
self._clear_result()
conn.query(q) ^^^^^^^^^^^^^
self._do_get_result()
return self.rowcount
def _clear_result(self):
self.rownumber = 0query # if DEBUG:
# print("DEBUG: sending query:", sql)
if isinstance(sql, str):
sql = sql.encode(self.encoding, "surrogateescape")
self._execute_command(COMMAND.COM_QUERY, sql)
self._affected_rows = self._read_query_result(unbuffered=unbuffered) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return self._affected_rows
def next_result(self, unbuffered=False):
self._affected_rows = self._read_query_result(unbuffered=unbuffered)
return self._affected_rows_read_query_result self._result = None
result = MySQLResult(self)
if unbuffered:
result.init_unbuffered_query()
else:
result.read() ^^^^^^^^^^^^^
self._result = result
if result.server_status is not None:
self.server_status = result.server_status
return result.affected_rows
read if self.unbuffered_active:
self._finish_unbuffered_query()
def read(self):
try:
first_packet = self.connection._read_packet() ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
if first_packet.is_ok_packet():
self._read_ok_packet(first_packet)
elif first_packet.is_load_local_packet():
self._read_load_local_packet(first_packet)_read_packet bytes_to_read = btrl + (btrh << 16)
if packet_number != self._next_seq_id:
self._force_close()
if packet_number == 0:
# MariaDB sends error packet with seqno==0 when shutdown
raise err.OperationalError( ^
CR.CR_SERVER_LOST,
"Lost connection to MySQL server during query",
)
raise err.InternalError(
"Packet sequence number wrong - got %d expected %d"__call__ ) -> cabc.Iterable[bytes]:
"""The WSGI server calls the Flask application object as the
WSGI application. This calls :meth:`wsgi_app`, which can be
wrapped to apply middleware.
"""
return self.wsgi_app(environ, start_response) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
wsgi_app try:
ctx.push()
response = self.full_dispatch_request()
except Exception as e:
error = e
response = self.handle_exception(e) ^^^^^^^^^^^^^^^^^^^^^^^^
except:
error = sys.exc_info()[1]
raise
return response(environ, start_response)
finally:wrapped_function if options.intercept_exceptions and hasattr(app, "handle_exception"):
app_any: Any = app
def _after_request_decorator(f: Callable[..., Any]) -> Callable[..., Response]:
def wrapped_function(*args: Any, **kwargs: Any) -> Response:
return cors_after_request(app_any.make_response(f(*args, **kwargs))) ^^^^^^^^^^^^^^^^^^
return wrapped_function
app_any.handle_exception = _after_request_decorator(app_any.handle_exception)
app_any.handle_user_exception = _after_request_decorator(app_any.handle_user_exception)wsgi_app ctx = self.request_context(environ)
error: BaseException | None = None
try:
try:
ctx.push()
response = self.full_dispatch_request() ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
except Exception as e:
error = e
response = self.handle_exception(e)
except:
error = sys.exc_info()[1]full_dispatch_request request_started.send(self, _async_wrapper=self.ensure_sync)
rv = self.preprocess_request()
if rv is None:
rv = self.dispatch_request()
except Exception as e:
rv = self.handle_user_exception(e) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return self.finalize_request(rv)
def finalize_request(
self,
rv: ft.ResponseReturnValue | HTTPException,wrapped_function if options.intercept_exceptions and hasattr(app, "handle_exception"):
app_any: Any = app
def _after_request_decorator(f: Callable[..., Any]) -> Callable[..., Response]:
def wrapped_function(*args: Any, **kwargs: Any) -> Response:
return cors_after_request(app_any.make_response(f(*args, **kwargs))) ^^^^^^^^^^^^^^^^^^
return wrapped_function
app_any.handle_exception = _after_request_decorator(app_any.handle_exception)
app_any.handle_user_exception = _after_request_decorator(app_any.handle_user_exception)full_dispatch_request try:
request_started.send(self, _async_wrapper=self.ensure_sync)
rv = self.preprocess_request()
if rv is None:
rv = self.dispatch_request() ^^^^^^^^^^^^^^^^^^^^^^^
except Exception as e:
rv = self.handle_user_exception(e)
return self.finalize_request(rv)
def finalize_request(dispatch_request and req.method == "OPTIONS"
):
return self.make_default_options_response()
# otherwise dispatch to the handler for that endpoint
view_args: dict[str, t.Any] = req.view_args # type: ignore[assignment]
return self.ensure_sync(self.view_functions[rule.endpoint])(**view_args) # type: ignore[no-any-return] ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
def full_dispatch_request(self) -> Response:
"""Dispatches the request and on top of that performs request
pre and postprocessing as well as HTTP exception catching and
error handling.get_live_policy# ---- public read endpoint ----
@bp.route('/api/live/policy/<policy_id>', methods=['GET'])
def get_live_policy(policy_id):
config = _get_or_create_config() ^^^^^^^^^^^^^^^^^^^^^^^
ip = _client_ip()
if not coerce_bool(config.enabled):
_log(policy_id, ip, 503, "Live API disabled")
return jsonify({"error": "Service disabled", "message": "Live API is disabled"}), 503_get_or_create_config# ---- helpers ----
def _get_or_create_config():
config = LiveConfig.query.get(1) ^^^^^^^^^^^^^^^^^^^^^^^
if not config:
config = LiveConfig(id=1, enabled=False)
db.session.add(config)
db.session.commit()
return configgetwarned skip_warning = not enable_warnings or kwargs.pop(
"_sa_skip_warning", False
)
if not skip_warning:
_warn_with_version(message, version, wtype, stacklevel=3)
return fn(*args, **kwargs) # type: ignore[no-any-return] ^^^^^^^^^^^^^^^^^^^
doc = func.__doc__ is not None and func.__doc__ or ""
if docstring_header is not None:
docstring_header %= dict(func=func.__name__)
get """ # noqa: E501
self._no_criterion_assertion("get", order_by=False, distinct=False)
# we still implement _get_impl() so that baked query can override
# it
return self._get_impl(ident, loading.load_on_pk_identity) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
def _get_impl(
self,
primary_key_identity: _PKIdentityArgument,
db_load_fn: Callable[..., Any],_get_impl primary_key_identity: _PKIdentityArgument,
db_load_fn: Callable[..., Any],
identity_token: Optional[Any] = None,
) -> Optional[Any]:
mapper = self._only_full_mapper_zero("get")
return self.session._get_impl(
mapper,
primary_key_identity,
db_load_fn,
populate_existing=self.load_options._populate_existing,
with_for_update=self._for_update_arg,_get_impl if for_update_arg is not None:
statement._for_update_arg = for_update_arg
if options:
statement = statement.options(*options)
return db_load_fn(
self,
statement,
primary_key_identity,
load_options=load_options,
identity_token=identity_token,load_on_pk_identity execution_options = util.EMPTY_DICT.merge_with(
execution_options, {"_sa_orm_load_options": load_options}
)
result = (
session.execute( ^
q,
params=params,
execution_options=execution_options,
bind_arguments=bind_arguments,
)execute :return: a :class:`_engine.Result` object.
"""
return self._execute_internal(
statement,
params,
execution_options=execution_options,
bind_arguments=bind_arguments,
_parent_execute_state=_parent_execute_state,_execute_internal return conn.scalar(
statement, params or {}, execution_options=execution_options
)
if compile_state_cls:
result: Result[Any] = compile_state_cls.orm_execute_statement(
self,
statement,
params or {},
execution_options,
bind_arguments,orm_execute_statement params,
execution_options,
bind_arguments,
conn,
) -> Result:
result = conn.execute(
statement, params or {}, execution_options=execution_options
)
return cls.orm_setup_cursor_result(
session,
statement,execute try:
meth = statement._execute_on_connection
except AttributeError as err:
raise exc.ObjectNotExecutableError(statement) from err
else:
return meth(
self,
distilled_parameters,
execution_options or NO_OPTIONS,
)
_execute_on_connection execution_options: CoreExecuteOptionsParameter,
) -> Result[Any]:
if self.supports_execution:
if TYPE_CHECKING:
assert isinstance(self, Executable)
return connection._execute_clauseelement(
self, distilled_params, execution_options
)
else:
raise exc.ObjectNotExecutableError(self)
_execute_clauseelement column_keys=keys,
for_executemany=for_executemany,
schema_translate_map=schema_translate_map,
linting=self.dialect.compiler_linting | compiler.WARN_LINTING,
)
ret = self._execute_context(
dialect,
dialect.execution_ctx_cls._init_compiled,
compiled_sql,
distilled_parameters,
execution_options,_execute_context context.pre_exec()
if context.execute_style is ExecuteStyle.INSERTMANYVALUES:
return self._exec_insertmany_context(dialect, context)
else:
return self._exec_single_context(
dialect, context, statement, parameters
)
def _exec_single_context(
self,_exec_single_context context.post_exec()
result = context._setup_result_proxy()
except BaseException as e:
self._handle_dbapi_exception( ^
e, str_statement, effective_parameters, cursor, context
)
return result
_handle_dbapi_exception if newraise:
raise newraise.with_traceback(exc_info[2]) from e
elif should_wrap:
assert sqlalchemy_exception is not None
raise sqlalchemy_exception.with_traceback(exc_info[2]) from e ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
else:
assert exc_info[1] is not None
raise exc_info[1].with_traceback(exc_info[2])
finally:
del self._reentrant_error_exec_single_context context,
):
evt_handled = True
break
if not evt_handled:
self.dialect.do_execute( ^
cursor, str_statement, effective_parameters, context
)
if self._has_events or self.engine._has_events:
self.dispatch.after_cursor_execute(do_execute def do_executemany(self, cursor, statement, parameters, context=None):
cursor.executemany(statement, parameters)
def do_execute(self, cursor, statement, parameters, context=None):
cursor.execute(statement, parameters) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
def do_execute_no_params(self, cursor, statement, context=None):
cursor.execute(statement)
def is_disconnect(execute while self.nextset():
pass
query = self.mogrify(query, args)
result = self._query(query) ^^^^^^^^^^^^^^^^^^
self._executed = query
return result
def executemany(self, query, args):
"""Run several data against one query._query self.rownumber = r
def _query(self, q):
conn = self._get_db()
self._clear_result()
conn.query(q) ^^^^^^^^^^^^^
self._do_get_result()
return self.rowcount
def _clear_result(self):
self.rownumber = 0query # if DEBUG:
# print("DEBUG: sending query:", sql)
if isinstance(sql, str):
sql = sql.encode(self.encoding, "surrogateescape")
self._execute_command(COMMAND.COM_QUERY, sql)
self._affected_rows = self._read_query_result(unbuffered=unbuffered) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return self._affected_rows
def next_result(self, unbuffered=False):
self._affected_rows = self._read_query_result(unbuffered=unbuffered)
return self._affected_rows_read_query_result self._result = None
result = MySQLResult(self)
if unbuffered:
result.init_unbuffered_query()
else:
result.read() ^^^^^^^^^^^^^
self._result = result
if result.server_status is not None:
self.server_status = result.server_status
return result.affected_rows
read if self.unbuffered_active:
self._finish_unbuffered_query()
def read(self):
try:
first_packet = self.connection._read_packet() ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
if first_packet.is_ok_packet():
self._read_ok_packet(first_packet)
elif first_packet.is_load_local_packet():
self._read_load_local_packet(first_packet)_read_packet bytes_to_read = btrl + (btrh << 16)
if packet_number != self._next_seq_id:
self._force_close()
if packet_number == 0:
# MariaDB sends error packet with seqno==0 when shutdown
raise err.OperationalError( ^
CR.CR_SERVER_LOST,
"Lost connection to MySQL server during query",
)
raise err.InternalError(
"Packet sequence number wrong - got %d expected %d"sqlalchemy.exc.OperationalError: (pymysql.err.OperationalError) (2013, 'Lost connection to MySQL server during query') [SQL: SELECT live_config.id AS live_config_id, live_config.api_key AS live_config_api_key, live_config.api_secret_hash AS live_config_api_secret_hash, live_config.ip_whitelist AS live_config_ip_whitelist, live_config.enabled AS live_config_enabled, live_config.updated_at AS live_config_updated_at FROM live_config WHERE live_config.id = %(pk_1)s] [parameters: {'pk_1': 1}] (Background on this error at: https://sqlalche.me/e/20/e3q8)
This is the Copy/Paste friendly version of the traceback.
The console is locked and needs to be unlocked by entering the PIN. You can find the PIN printed out on the standard output of your shell that runs the server.