Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-27 02:38
📄 __init__.py # sqlalchemy/__init__.py # Copyright (C) 2005-2021 the SQLAlchemy authors and contributors # <see AUTHORS file> # # This module is part of SQLAlchemy and is released under # the MIT License: http://www.opensource.org/licenses/mit-license.php from . import util as _util # noqa from .inspection import inspect # noqa from .schema import BLANK_SCHEMA # noqa from .schema import CheckConstraint # noqa from .schema import Column # noqa from .schema import ColumnDefault # noqa from .schema import Computed # noqa from .schema import Constraint # noqa from .schema import DDL # noqa from .schema import DefaultClause # noqa from .schema import FetchedValue # noqa from .schema import ForeignKey # noqa from .schema import ForeignKeyConstraint # noqa from .schema import IdentityOptions # noqa from .schema import Index # noqa from .schema import MetaData # noqa from .schema import PassiveDefault # noqa from .schema import PrimaryKeyConstraint # noqa from .schema import Sequence # noqa from .schema import Table # noqa from .schema import ThreadLocalMetaData # noqa from .schema import UniqueConstraint # noqa from .sql import alias # noqa from .sql import all_ # noqa from .sql import and_ # noqa from .sql import any_ # noqa from .sql import asc # noqa from .sql import between # noqa from .sql import bindparam # noqa from .sql import case # noqa from .sql import cast # noqa from .sql import collate # noqa from .sql import column # noqa from .sql import delete # noqa from .sql import desc # noqa from .sql import distinct # noqa from .sql import except_ # noqa from .sql import except_all # noqa from .sql import exists # noqa from .sql import extract # noqa from .sql import false # noqa from .sql import func # noqa from .sql import funcfilter # noqa from .sql import insert # noqa from .sql import intersect # noqa from .sql import intersect_all # noqa from .sql import join # noqa from .sql import lateral # noqa from .sql import literal # noqa from .sql import literal_column # noqa from .sql import modifier # noqa from .sql import not_ # noqa from .sql import null # noqa from .sql import nullsfirst # noqa from .sql import nullslast # noqa from .sql import or_ # noqa from .sql import outerjoin # noqa from .sql import outparam # noqa from .sql import over # noqa from .sql import select # noqa from .sql import subquery # noqa from .sql import table # noqa from .sql import tablesample # noqa from .sql import text # noqa from .sql import true # noqa from .sql import tuple_ # noqa from .sql import type_coerce # noqa from .sql import union # noqa from .sql import union_all # noqa from .sql import update # noqa from .sql import within_group # noqa from .types import ARRAY # noqa from .types import BIGINT # noqa from .types import BigInteger # noqa from .types import BINARY # noqa from .types import Binary # noqa from .types import BLOB # noqa from .types import BOOLEAN # noqa from .types import Boolean # noqa from .types import CHAR # noqa from .types import CLOB # noqa from .types import DATE # noqa from .types import Date # noqa from .types import DATETIME # noqa from .types import DateTime # noqa from .types import DECIMAL # noqa from .types import Enum # noqa from .types import FLOAT # noqa from .types import Float # noqa from .types import INT # noqa from .types import INTEGER # noqa from .types import Integer # noqa from .types import Interval # noqa from .types import JSON # noqa from .types import LargeBinary # noqa from .types import NCHAR # noqa from .types import NUMERIC # noqa from .types import Numeric # noqa from .types import NVARCHAR # noqa from .types import PickleType # noqa from .types import REAL # noqa from .types import SMALLINT # noqa from .types import SmallInteger # noqa from .types import String # noqa from .types import TEXT # noqa from .types import Text # noqa from .types import TIME # noqa from .types import Time # noqa from .types import TIMESTAMP # noqa from .types import TypeDecorator # noqa from .types import Unicode # noqa from .types import UnicodeText # noqa from .types import VARBINARY # noqa from .types import VARCHAR # noqa from .engine import create_engine # noqa nosort from .engine import engine_from_config # noqa nosort __version__ = "1.3.24" def __go(lcls): global __all__ from . import events # noqa from . import util as _sa_util import inspect as _inspect __all__ = sorted( name for name, obj in lcls.items() if not (name.startswith("_") or _inspect.ismodule(obj)) ) _sa_util.dependencies.resolve_all("sqlalchemy") from . import exc exc._version_token = "".join(__version__.split(".")[0:2]) __go(locals())	4.68 KB	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📁 connectors	-	2026-03-21 15:45
📄 cprocessors.cpython-311-x86_64-linux-gnu.so ELF��>��@��(E��@�8� �@��X��X��5��5�� H��H��,��<��<��p��-��=��=��8��8��8��$��$��P�td��$��$��$��Q�td��R�td��,��<��<��GNU��#���/C�(0���7N��f�� 0��#�� Z��w��U��,�� I��F��"��<��`��__gmon_start__�_ITM_deregisterTMCloneTable�_ITM_registerTMCloneTable�__cxa_finalize�PyArg_ParseTuple�PyArg_ParseTupleAndKeywords�PyUnicode_AsASCIIString�PyBytes_FromString�_Py_NoneStruct�PyObject_IsTrue�_Py_TrueStruct�_Py_FalseStruct�PyBytes_AsStringAndSize�PyUnicode_Decode�PyNumber_Float�PyObject_Str�_Py_Dealloc�PyTuple_Pack�PyUnicode_Format�PyObject_CallFunctionObjArgs�__isoc99_sscanf�PyObject_Repr�PyExc_ValueError�PyErr_Format�PyInit_cprocessors�PyType_GenericNew�PyType_Ready�PyModule_Create2�PyCapsule_Import�PyModule_AddObject�libc.so.6�GLIBC_2.2.5�GLIBC_2.7�/opt/alt/python311/lib64:/opt/alt/sqlite/usr/lib64��ui ��$��ii ��0��<��0��<��=��=��@�� @�� H@�� P@��X"��`@��@��@�� @��0��@��"��@�� @��p��@��"��@�� @��P��@��"��A�� A��`��A��(#�� A�� (A��8A��`#��@A�� HA��XA��#��A��#��A��0B��#��hB�� C��B��@�� C��!��(C��0��8C�� xC��$��C��D��H$��HD��E��D��E��!��E��E�� E��!��(E��8E��h$��?��?��?��?�� ?��?��?��?��?��?��?�� ?��(?��0?��8?�� @?��H?�� P?��X?��`?��h?��p?��x?��?��?��?��?��?��?��?��H��H��/��H��t��H��5�.��%�.��@��%�.��h��%�.��h��%�.��h��%�.��h��%�.��h��%�.��h��%�.��h��%�.��h��p��%�.��h��`��%�.��h ��P��%�.��h ��@��%�.��h��0��%z.��h�� %r.��h ��%j.��h��%b.��h��%Z.��h��%R.��h��%J.��h��%B.��h��%:.��h��H�=�3��H��3��H9�tH�.��H��t ��H�=�3��H�5�3��H)�H��H��?H��H�H�tH�.��H��t��fD��=e3��u+UH�=�-��H��tH�=���I��d��=3��]��w��S1�H��H��H�5� ��H��H�L$H��t+H�$H��H�CH�D$H��H�C1�H��[�f.��f��S1�H��H� S-��H��H��H�I ��H��L�L$I��H�D$��\��tHH�<$��H�\|$H�$H�CH��t��H�C1�H��[�@�H�= ��\|��H��u��f��H;5�,��H��t<H��t1��uH��,��H��H��fD��H�a,��H�H��SH��H��H��H;5N,��t H�F��tH�H��H��[�f�H�T$H��A��1�E��u�H�CH�SH�t$H�<$H�H H�� ;��H��[�D��SH��H��H��H;5�+��t<H�T$H��/��A��1�E��uH�CH�SH�t$H�<$H�H H�� H��[ÐH�H��H��[��H;5�+��H��t��H�H��H;5i+��H��t��H�H��UH��H�H��tH�/t-H�}H��tH�/tH�EH��]H��@��D��{��f��UH��H�H��tH�/t-H�}H��tH�/tH�EH��]H��@��D��3��+��f��H;5���t_AT1�USH��H�� H��H��tUH�{H��H�m�I��t2M��t:H�{1�1�L��-��I�,$t6H��[]A\�D��H�H��H��M��u�H��1�[]A\��L��H�D$��H�D$H��[]A\�D��AUATUH��SH��H;5�)��H��I��H��H�x H�L$1�H�T$L�D$H�5� ��I�,$��H��H��H��tKH��I��H��t;H�P H�P)��H�5� ��H�81��I�,$��H�m��f��E1�H��L��[]A\A]��H��P��H��H��t�H�� I��H��t�H�P H��(��H�5. ��H�81��<��I�m��H�m�u�H��B��H�I��H��[L��]A\A]��H�9.��T$�t$�\|$H��P0H��I��[]L��A\A]�fD��L��H��+��L��L��j��ff.��AUATUH��SH��H�,(��D$��H9��H��#��I��H��tsH�x H�L$1�H��L�L$L�D$H�5;��I�,$A��A��H�P-��L$I�؋T$�t$L�H�<$�P@I��H��L��[]A\A]�fD��H��H��H��tBH��I��H��t2H�P H�M'��H�5 ��H�81��I�m��H�m��H��E1�[L��]A\A]�D��H�I��H��[L��]A\A]��H��@��H��H��t�H��I��H��t�H�P H��&��H�5��H�81��,��I�,$t5H�m�u�H��6��{��L��(��H��L��fD��L��2��AUATUH��SH��(H�l&��D$��H9��+��H��c��I��H��H�T$H�L$H��H�x H�D$$PH�5k��H�D$(PH�D$,P1�L�L$0L�D$,��H�� A��I�$H�P�I�$H��/��A��H�f+��H��pS�T$4RD�L$8D�D$4�L$0�T$,�t$(�\|$$�P8H�� I��H��(L��[]A\A]��H��H��H��tBH��I��H��t2H�P H�M%��H�5n��H�81��I�m��H�m��H��(E1�[L��]A\A]�D��H�I��H��([L��]A\A]��H��@��H��H��t�H��I��H��t�H�P H��$��H�56��H�81��,��I�,$t5H�m�u�H��6��{��L��(��H��L��fD��L��2��AVAUL�-�'��ATL�%T$��L��L�%)��L�5�%��L�%'��L��xs��H�=o$��I��H��tI1�H�=x��L��L��H�5}��H�'��H��)��L��L��H�5s��H�~%��L��A\A]A^��E1�L��A\A]A^��H��H��OU�U\|U:__init__�strict�%4u-%2u-%2u�%4u-%2u-%2u %2u:%2u:%2u.%6u�datetime.datetime_CAPI�UnicodeResultProcessor�DecimalResultProcessor�encoding�errors�cprocessors�int_to_boolean�to_str�to_float�str_to_datetime�str_to_time�str_to_date�The value processor itself.�conditional_process��Couldn't parse date string '%.200s' - value is not a string.��Couldn't parse date string: %.200s��Couldn't parse time string '%.200s' - value is not a string.��Couldn't parse time string: %.200s��Couldn't parse datetime string '%.200s' - value is not a string.��Couldn't parse datetime string: %.200s��Module containing C versions of data processing functions.��Convert an integer to a boolean.��Convert any value to its string representation.�Convert any value to its floating point representation.�Convert an ISO string to a datetime.datetime object.��Convert an ISO string to a datetime.time object.��Convert an ISO string to a datetime.date object.��sqlalchemy.DecimalResultProcessor��DecimalResultProcessor objects��sqlalchemy.cprocessors.UnicodeResultProcessor��UnicodeResultProcessor objects��Conditional version of the value processor.�;��,��\�T��L��L�8��x��zR�x��$��`��FJw��?;*3$"�� D��W��A�S p AK�� h��A�] D AE��P��Pa GP��$��k��A�J a ACyA(��]��A�J B ABHD��4� ��@� ��(��L�G��A�i N��D��G��A�i NT��`��K�C�A �L0C AABF��H0��Q CABIV AAB\��B�B�A �D(�D@� (D ABBHc (A DBBD] (D AEBG\��l��B�B�A �D(�D@� (D ABBGV (D DBBFK (A DBBD\|��x��B�B�A �D(�DPzXJ`MhFpUPmXC`AhEpaPG (D ABBHV (D DBBFK (A DBBD��4��L��B�B�I �� BBHHBB��0��=��:�� (��<��<��o��`��p�� m��>��` ��P�� o��o�� o��o��o��-��=��6��F��V��f��v��&��6��F��V��f��v�� X"��@�� 0��"�� p��"�� P��"�� `��(#�� `#�� #��#�� #�� C��@��!��0�� $�� H$��E��!�� !��h$��GCC: (GNU) 11.5.0 20240719 (Red Hat 11.5.0-5)��GA$3a1��GA$3a1��GA$3a1�(��0��GA$3a1��9��GA$3a1�%��%��GA$3a1�%��%��GA$3a1��GA$3a1�0��5��,��`E��8��<��_��0��k��<��@��W��@��0��P��k��]��$��P�� -��p�� 4��G��S��G��r��0��hE��`��`C��A�� @��h��@�� C��@��6��E��`��U��D(��c��(��i��=��v��=��$��`E��>�� 8��`��p�� P��` �� (�� $��%��<��<��=��=��>��@��`E��pe�� %��7��H��U��e�� t��`��!��9��L��Z��k��x�� "��deregister_tm_clones�__do_global_dtors_aux�completed.0�__do_global_dtors_aux_fini_array_entry�frame_dummy�__frame_dummy_init_array_entry�DecimalResultProcessor_init�UnicodeResultProcessor_init�kwlist.0�int_to_boolean�UnicodeResultProcessor_conditional_process�UnicodeResultProcessor_process�to_float�to_str�DecimalResultProcessor_dealloc�UnicodeResultProcessor_dealloc�DecimalResultProcessor_process�str_to_date�PyDateTimeAPI�str_to_time�str_to_datetime�UnicodeResultProcessorType�DecimalResultProcessorType�module_def�module_methods�DecimalResultProcessor_methods�UnicodeResultProcessor_methods�__FRAME_END__�_fini�__dso_handle�_DYNAMIC�__GNU_EH_FRAME_HDR�__TMC_END__�_GLOBAL_OFFSET_TABLE_�PyArg_ParseTupleAndKeywords�_ITM_deregisterTMCloneTable�PyNumber_Float�_Py_Dealloc�PyObject_Str�PyExc_ValueError�PyType_GenericNew�PyCapsule_Import�PyType_Ready�_Py_FalseStruct�__gmon_start__�PyBytes_FromString�PyModule_Create2�PyObject_CallFunctionObjArgs�PyInit_cprocessors�__isoc99_sscanf@GLIBC_2.7�_Py_NoneStruct�PyObject_IsTrue�PyArg_ParseTuple�_Py_TrueStruct�PyUnicode_AsASCIIString�PyModule_AddObject�PyObject_Repr�PyUnicode_Decode�PyErr_Format�_ITM_registerTMCloneTable�PyBytes_AsStringAndSize�PyUnicode_Format�__cxa_finalize@GLIBC_2.2.5�PyTuple_Pack��.symtab�.strtab�.shstrtab�.note.gnu.build-id�.gnu.hash�.dynsym�.dynstr�.gnu.version�.gnu.version_r�.rela.dyn�.rela.plt�.init�.text�.fini�.rodata�.eh_frame_hdr�.eh_frame�.init_array�.fini_array�.data.rel.ro�.dynamic�.got�.data�.bss�.comment�.gnu.build.attributes��8��8��$��.��o��`��`��$��8��@��p��p��m��H��o��>��U��o�� 0��d��P��P��n��B��` ��` ��x��s�� `��~�� (��(�� 2�� $��$��%��%��0��<��,��<��,��=��-��=��-��>��.��@��0��`�� `E��`5��0��`5��.��pe��5�� 6��=�� 8?��D��	19.04 KB	2026-01-20 12:58
📄 cresultproxy.cpython-311-x86_64-linux-gnu.so ELF��>��p"��@��g��@�8� �@�� @��@��@�� L��\��\��L��\��\��8��8��8��$��$��P�td��pE��pE��pE��Q�td��R�td��L��\��\��x��x��GNU�N�0b�>'ڵѶFf5��H#\|��3��@� ��3��,��l��F�� Q��$��F�� 4��~��,�� T����6�� Y��9��$��f��U��C��x��g��`�� `0��k��__gmon_start__�_ITM_deregisterTMCloneTable�_ITM_registerTMCloneTable�__cxa_finalize�PyArg_UnpackTuple�PySequence_Check�PyList_Type�PyDict_Type�PyExc_TypeError�PyErr_SetString�PySequence_Size�_Py_Dealloc�PyImport_ImportModule�PyObject_GetAttrString�PyObject_IsInstance�PyList_Size�PyList_New�PySequence_Fast�PyObject_CallFunctionObjArgs�_Py_NoneStruct�PyTuple_New�PyExc_RuntimeError�PyErr_Format�PyObject_GetIter�PyArg_ParseTuple�PyObject_CallMethod�PyObject_CallObject�Py_BuildValue�PyLong_Type�PySlice_Type�PyDict_GetItem�PyTuple_GetItem�PyLong_AsLong�PyList_GetItem�PyTuple_Type�PySequence_GetItem�PyObject_Str�PyUnicode_AsASCIIString�PyObject_GetItem�PyErr_Occurred�PyObject_GenericGetAttr�PyExc_AttributeError�PyErr_ExceptionMatches�PyErr_Clear�PyExc_KeyError�PyLong_FromSsize_t�PyInit_cresultproxy�PyType_GenericNew�PyType_Ready�PyModule_Create2�PyModule_AddObject�/opt/alt/python311/lib64:/opt/alt/sqlite/usr/lib64��\�� #��\��"��\��\��(`��@��0`��8D��@`��`��`��@��`����`��xD��`��D��`��P&��(a��b��0a��`b��Pa��/��pa��D��a��)��a��b��a��@c��a��p#��`b��$��hb��,��b��$��b��@0��b�� A��b��)��b��E��c��A��c����c��A��@c��6A��Hc��0#��Pc��&��Xc��m@��hc��>A��pc��@#��xc��%��c��CA��c��VA��c��P#��c��$��c��bA��c��zA��c��`#��c��0%��c��PE��_��_��_��_�� _��_��_��_��_��!��_��"��_��%��_��(��_��,��_��-��_��2��h^��p^��x^��^��^��^��^�� ^��^��^�� ^��^��^��^��^��^��^��^��^��_��_��_��_�� _��(_�� 0_��#��8_��$��@_��&��H_��'��P_��)��X_����`_��+��h_��.��p_��/��x_��0��_��1��H��H��?��H��t��H��52>��%4>��@��%2>��h��%>��h��%">��h��%>��h��%>��h��% >��h��%>��h��%�=��h��p��%�=��h��`��%�=��h ��P��%�=��h ��@��%�=��h��0��%�=��h�� %�=��h ��%�=��h��%�=��h��%�=��h��%�=��h��%�=��h��%�=��h��%�=��h��%�=��h��%�=��h��%z=��h��p��%r=��h��`��%j=��h��P��%b=��h��@��%Z=��h��0��%R=��h�� %J=��h��%B=��h��%:=��h��%2=��h ��%=��h!��%"=��h"��%=��h#��H�=�A��H��A��H9�tH�6=��H��t ��H�=aA��H�5ZA��H)�H��H��?H��H�H�tH��<��H��t��fD��=A��u+UH�=�<��H��tH�=�9��i��d��@��]��w��H�GH��H�GH��H�G H��H�G(H��S��H��H��H�5x��H�� H�D$PH�D$P1�L�L$L�D$�G��ZY��tqH�$H�\|$H��H�C��H�D$H�<��H��H�CH�D$H9PuDH��H� �;��H�C H�D$H9HuJH��H�C(1�H�� [�f.��f��H��;��H�5��H�8�J��H�a;��H�5��H�8���H�D;��H�5��H�8� ��fD��H��USH��H��tbH�6;��H��H9Fu5H��H� H��tH�/tH�1�H�] H��[]�f��f��H��:��H�5��H�8��H��:��H�5m��H�8�m��fD��USH��H��tbH��:��H��H9Fu5H��H�(H��tH�/tH�1�H�](H��[]�f��;��f��H�1:��H�5��H�8��H�:��H�5=��H�8��fD��USH��H��tYH��H��H��w��tH�}H��tH�/tH�1�H�]H��[]��H��9��H�5S��H�8�s��H��9��H�5��H�8�V��ff.��@�UH��H�H��tH�/tMH�}H��tH�/tNH�} H��tH�/tOH�}(H��tH�/tH�EH��]H��@��f��f��f��AUATUSH��H��I��H�=W��H��H��H��H�5U��H��H�m�I��tFM��L��H��u]I�,$t6I�}H��tH�/t7H�1�I�]H��[]A\A]�f�H��8��fD��L��(��fD��f��H�8��H�5��H�8��H��7��H�5��H�8��fD��AWAVAUA��ATI��USH��H��4��H��H��9��H9��P��H��E��?��I��M��H�5��L��$��H�$H��H��H�@L�y��tL�yH�CL�c��tL�cI�EM�u��tM�uH��H��xL1��&��1�1��H��H��tI�4�H��H9�t"I�<�H;=�6��I�4�u�H�I�4�H��H9�u�H�$H�H�D$H��H��H��L��[]A\A]A^A_�D��K��I��M��E1��H�$H�H�D$H��H�tI�m�u�L��\��H��R��H�6��E1�H�5��H�81��A��u��@�H�<$��c��f.��H�w H�1��1��U��H��H�w H��H��t4H��H��H�m�t H��]�@�H��H�D$��H�D$H��]�H��1�]��AUH��1�H�5^��ATH��H�L$H��H�<$L�-9��H�54��1�L��H��I��H��tpH�L$H��1�L��H�5��H��H��t<H�(tYI�\|$�tI�\|$�tI�\|$ �tI�\|$(�u,H��4��H�5��H�8��I�,$uL��@�E1�H��L��A\A]Ð��f��AVH�5��AUATI��UH��H��H��1�H��H�m�I��M��H�=��H��H��tlH�5��H��v��H�m�I��ttM��tGH�51��L��X��H��H��t H��L��L��1�]H�=��A\A]A^��I�.u L��f�I�m�t1H��1�]A\A]A^��H��Y��H��L��ff.��AUATUH��SH��H��H�FH;�3��'��H;�3��R��H�(�Y��I��H��H��H��H�� L�--3��L9��H��H��H��G��H�{ H��I��H��H�{H�$3��H��H9G��z�I��H��L;-�2��t 1�H��L��1��I�,$H��X��I��H��L��[]A\A]��H�=��H��H��tUH�5��H��H�m�I��M��t3L��H��H��t�P�H��H��tH��H��H��E1�[L��]A\A]�fD��H��W�I��H��t�H�{ H��C�H��H��w��H��L��'��I�m�I��H�m��H��L�-�1��H�{H��1�H��H�5��M��j�I��H��W��H��H��H��>��I�,$�-��L��r�� D��H��H��H��H��H�{��H�� f��{�I��H��L;-�0��tH��H��L��1�[1�]A\A]��D��H����H��D��L��H�m�L�` t}L��H�5��L��1��E1��f��I�m��>��L��}��1��L��I��e��H��X��;�H��D��H��0��v��ff.��AUI��ATUH��SH��[�I��H��tH��L��[]A\A]�D��H� 0��H�;��t��H�L��H��H��tH��I��[L��]A\A]��H��/��H�8�A��t�L��H��t�H�;H�P H�5��1��s��fD��UH��H��H��]H��AUL�-W0��ATL��E1�H��H�\/��H�u1��x3��H�=h/��s�I��H��tL��H�5Q��H��H�0��1�H��L��A\A]��H��H��BaseRowProxy�row must be a sequence�processors must be a list�keymap must be a dict�sqlalchemy.engine.result�ResultMetaData�OO�__new__�__setstate__�__getstate__�__class__�(N(NN))�_key_fallback�sqlalchemy.exc�InvalidRequestError�cresultproxy�safe_rowproxy_reconstructor�values�__reduce__�Pickle support method.�_parent�_row�Original row tuple�_processors�list of type processors�_keymap��Cannot delete the 'processors' attribute��The 'processors' attribute value must be a list�Cannot delete the 'keymap' attribute��The 'keymap' attribute value must be a dict��Cannot delete the 'row' attribute��The 'row' attribute value must be a sequence��Cannot delete the 'parent' attribute��The 'parent' attribute value must be an instance of ResultMetaData��number of values in row (%d) differ from number of column processors (%d)��__setstate__ for BaseRowProxy subclasses must set values for parent, row, processors and keymap�Ambiguous column name '%.200s' in result set column descriptions��Could not locate column in row for column '%.200s'��Module containing C versions of core ResultProxy classes.��reconstruct a RowProxy instance from its pickled form.��sqlalchemy.cresultproxy.BaseRowProxy��BaseRowProxy is a abstract base class for RowProxy��Return the values represented by this BaseRowProxy as a list.��Key to (processor, index) dict��;�� 4��H�� x��0��P��p�0��p�l��0��@��,��\|�� ,��H��zR�x��$��P��FJw��?;3$"��D�� X�� l�� ,��A�[0F8F@R8A0i AK�� (��A�A�D u AAC��(��A�A�D u AAC��(��0��d��A�A�D t AAD��\��A�G P��8��\|��8��B�B�A �A(�D0} (A ABBC�H��B�B�B �E(�D0�A8�GP 8D0A(B BBBF��p��0��l�X��A�I h AEV AADC��(��L��B�N�D0� EBB�L��x��L��B�I�B �D(�D0 (I IBBF[ (C BBBD��`��B�B�A �D(�G0� (D ABBHm (D DBBG (I CBBJ��H��,��8��B�E�A �D(�D0Q (D ABBFl (D DBBH��x��A�O��$��k��B�I�J NEB�� #��"��\��g�� 0��\��\��o��`��h�� P^��`�� o��o��-��\��6 ��F ��V ��f ��v �� !��!��&!��6!��F!��V!��f!��v!��!��!��!��!��!��!��!��!��"��"��&"��6"��F"��V"��f"��@��8D��`��@����xD��D��0��P&��b��`b��/��D��)��b��@c��p#��$��,��$��@0�� A��)��E��A����A��6A��0#��&��m@��>A��@#��%��CA��VA��P#��$��bA��zA��`#��0%��PE��GCC: (GNU) 11.5.0 20240719 (Red Hat 11.5.0-5)��GA$3a1�p"��p"��GA$3a1�� GA$3a1��0��0��GA$3a1�p"��)#��GA$3a1��0��0��GA$3a1��0��0��GA$3a1� �� GA$3a1��0��0�� p"�� "�� "��,��d��8��\��_�� #��k��\�� 0#�� @#�� P#�� `#�� p#�� $�� $��(�� 0%��?�� %��S�� P&��h�� &�� '�� )�� )��X�� �� �� ,�� /�� @0��2��`��C��`��h��N��`��@��]��b��P��v��`b��b��`��@c�� I��\��d��\�� pE�� 0��P^��8��`��h�� p"�� 0��@��pE�� (F��\��\��\��\��P^��`��d��,��?��K��b��q�� %�� ?��R��^��n�� `0��k�� ,��;��H��T��a��v�� (��4��B��S��d��p�� deregister_tm_clones�__do_global_dtors_aux�completed.0�__do_global_dtors_aux_fini_array_entry�frame_dummy�__frame_dummy_init_array_entry�BaseRowProxy_getparent�BaseRowProxy_getrow�BaseRowProxy_getprocessors�BaseRowProxy_getkeymap�BaseRowProxy_init�BaseRowProxy_length�BaseRowProxy_setprocessors�BaseRowProxy_setkeymap�BaseRowProxy_setrow�BaseRowProxy_dealloc�BaseRowProxy_setparent�BaseRowProxy_processvalues�BaseRowProxy_values�BaseRowProxy_iter�safe_rowproxy_reconstructor�BaseRowProxy_reduce�BaseRowProxy_subscript�BaseRowProxy_getattro�BaseRowProxy_getitem�BaseRowProxyType�module_def�module_methods�BaseRowProxy_as_sequence�BaseRowProxy_as_mapping�BaseRowProxy_methods�BaseRowProxy_getseters�__FRAME_END__�_DYNAMIC�__TMC_END__�__dso_handle�__GNU_EH_FRAME_HDR�_fini�_GLOBAL_OFFSET_TABLE_�PyExc_RuntimeError�PySequence_GetItem�PyList_Size�PyErr_ExceptionMatches�_Py_NoneStruct�PySequence_Fast�__cxa_finalize�Py_BuildValue�PyExc_KeyError�PyErr_SetString�PyErr_Occurred�PyObject_CallFunctionObjArgs�PyObject_IsInstance�PyObject_GetAttrString�PyObject_GetItem�_ITM_registerTMCloneTable�PyModule_AddObject�PyLong_Type�PyTuple_GetItem�PyImport_ImportModule�PyErr_Clear�PyInit_cresultproxy�PySequence_Size�PyExc_TypeError�PyList_GetItem�PyType_Ready�PyList_New�_ITM_deregisterTMCloneTable�PyObject_CallMethod�PyObject_GetIter�PyDict_GetItem�PyObject_Str�_Py_Dealloc�PyTuple_Type�PyExc_AttributeError�PyErr_Format�PyObject_CallObject�PyType_GenericNew�PyUnicode_AsASCIIString�PyArg_UnpackTuple�PySlice_Type�PyObject_GenericGetAttr�PyModule_Create2�PyLong_FromSsize_t�PyList_Type�PyDict_Type�PyLong_AsLong�PyArg_ParseTuple�PySequence_Check�PyTuple_New�__gmon_start__��.symtab�.strtab�.shstrtab�.note.gnu.build-id�.gnu.hash�.dynsym�.dynstr�.rela.dyn�.rela.plt�.init�.text�.fini�.rodata�.eh_frame_hdr�.eh_frame�.init_array�.fini_array�.data.rel.ro�.dynamic�.got�.data�.bss�.comment�.gnu.build.attributes��8��8��$��.��o��`��`��$��8��@��h��h��H��R��B��`��\�� W�� P��b��p"��p"��[��h��0��0�� n��2��@��@��o��v��pE��pE��(F��(F��\��L��\��L��\��L��\��L��P^��PN��`��P�� d��T��0��T��.��8T�� XU�� @�� `��f��	27.52 KB	2026-01-20 12:58
📄 cutils.cpython-311-x86_64-linux-gnu.so ELF��>��@��:��@�8� �@��Q��Q�� p��p��-��=��=��(��0��-��=��=��8��8��8��$��$��P�td�� ,��,��Q�td��R�td��-��=��=��h��h��GNU�' �D�Wi�e��;#�Ķw�4�� 5)�v��s��F�� ,�� U��a�� 0��__gmon_start__�_ITM_deregisterTMCloneTable�_ITM_registerTMCloneTable�__cxa_finalize�_Py_Dealloc�PyArg_UnpackTuple�_Py_NoneStruct�PyTuple_Size�PyTuple_GetItem�PyObject_HasAttrString�PyList_New�PyList_SetItem�PyDict_Size�PySequence_Size�PySequence_GetItem�PyInit_cutils�PyModule_Create2�/opt/alt/python311/lib64:/opt/alt/sqlite/usr/lib64��=��=��`��=��=��(@��$ ��0@��0 ��@@��@��@�� @��@��h ��?��?��?��?�� ?��x?��?��?��?��?��?��?�� ?��?��?�� ?��?��H��H��/��H��t��H��5B/��%D/��@��%B/��h��%:/��h��%2/��h��%/��h��%"/��h��%/��h��%/��h��% /��h��p��%/��h��`��%�.��h ��P��%�.��h ��@��%�.��h��0��H�=�/��H��/��H9�tH��.��H��t ��H�=�/��H�5�/��H)�H��H��?H��H�H�tH��.��H��t��fD��=U/��u+UH�=j.��H��tH�=&,��d��-/��]��w��H�/t �f��ff.��AUH��1��AT��H�5��UH��L�L$I��H�<$L�%�-��L9��H��i��H�<$1�H��/��H�5� ��H��I��tH�5� ��L��z��I��H��H�$1�H��H��u7H�<$H�/��+��f�H�\|$L9�t��H��1��I��H��L��]A\A]Ð��H��H�@H��3��H��{��H��1�H��I��H��toH�5��H��I�,$��D��I��H��t;H�E�1�H��H��c��H�m��fD��I�,$uL��H��E1�L��]A\A]Ð��I��H��t�H�T$1�H��H��H�\|$H�/u��H�5)��L��@��I�,$uL��f.��H�E�I��L�$$I�$��f�H��H�5��tH�C��I��H��6��H�E�1�H��H��^��H��4��L��E1��)��F��@��I��H��I��H��tgH�E�1�H��L��t1�L��L��H��L��L��E1��L��5��H��f��L��f��H�=���H��H��_distill_params�strip�keys�__iter__�cutils��Module containing C versions of utility functions.��Distill an execute() parameter structure.��;(��D��l��<��zR�x��$��@��FJw��?;3$"��D��@��X��W��B�L�M �D0� DBBB� GBBB��`��=�� D��=��=��o��`��8�� Q��`?�� P�� o��o�� =��6��F��V��f��v��$ ��0 ��@�� h ��GCC: (GNU) 11.5.0 20240719 (Red Hat 11.5.0-5)��GA$3a1��GA$3a1��GA$3a1�D��L��GA$3a1��GA$3a1�A��A��GA$3a1�A��A��GA$3a1��GA$3a1�L��Q�� `��,��@��8��=��_�� k��=�� W��@��h��@��@�� l!��=��@��=�� D��`?��8��`��8�� D�� =��=��=��=��`?��@��@��`��"�� 0��0��C��R�� a��m��\|�� 0�� deregister_tm_clones�__do_global_dtors_aux�completed.0�__do_global_dtors_aux_fini_array_entry�frame_dummy�__frame_dummy_init_array_entry�Py_DECREF�distill_params�module_def�module_methods�__FRAME_END__�_DYNAMIC�__TMC_END__�__dso_handle�_init�__GNU_EH_FRAME_HDR�_fini�_GLOBAL_OFFSET_TABLE_�PyInit_cutils�PySequence_GetItem�_Py_NoneStruct�__cxa_finalize�PyDict_Size�PyList_SetItem�_ITM_registerTMCloneTable�PyTuple_GetItem�PySequence_Size�PyList_New�_ITM_deregisterTMCloneTable�_Py_Dealloc�PyTuple_Size�PyArg_UnpackTuple�PyModule_Create2�PyObject_HasAttrString�__gmon_start__��.symtab�.strtab�.shstrtab�.note.gnu.build-id�.gnu.hash�.dynsym�.dynstr�.rela.dyn�.rela.plt�.init�.text�.fini�.rodata�.eh_frame_hdr�.eh_frame�.init_array�.fini_array�.data.rel.ro�.dynamic�.got�.data�.bss�.comment�.gnu.build.attributes��8��8��$��.��o��`��`��$��8��@��8��8��Q��H��P��R��B�� \��W�� b��Q��h��D��D�� n��2�� v�� ,�� =��-��=��-��=��-��=��-��`?��`/��@��0�� @��0��0��0��.��`��0�� 2���� 7��?��9��	16.32 KB	2026-01-20 12:58
📁 databases	-	2026-03-21 15:45
📁 dialects	-	2026-03-21 15:45
📁 engine	-	2026-03-21 15:45
📁 event	-	2026-03-21 15:45
📄 events.py # sqlalchemy/events.py # Copyright (C) 2005-2021 the SQLAlchemy authors and contributors # <see AUTHORS file> # # This module is part of SQLAlchemy and is released under # the MIT License: http://www.opensource.org/licenses/mit-license.php """Core event interfaces.""" from . import event from . import exc from . import util from .engine import Connectable from .engine import Dialect from .engine import Engine from .pool import Pool from .sql.base import SchemaEventTarget class DDLEvents(event.Events): """ Define event listeners for schema objects, that is, :class:`.SchemaItem` and other :class:`.SchemaEventTarget` subclasses, including :class:`_schema.MetaData`, :class:`_schema.Table`, :class:`_schema.Column`. :class:`_schema.MetaData` and :class:`_schema.Table` support events specifically regarding when CREATE and DROP DDL is emitted to the database. Attachment events are also provided to customize behavior whenever a child schema element is associated with a parent, such as, when a :class:`_schema.Column` is associated with its :class:`_schema.Table`, when a :class:`_schema.ForeignKeyConstraint` is associated with a :class:`_schema.Table`, etc. Example using the ``after_create`` event:: from sqlalchemy import event from sqlalchemy import Table, Column, Metadata, Integer m = MetaData() some_table = Table('some_table', m, Column('data', Integer)) def after_create(target, connection, kw): connection.execute("ALTER TABLE %s SET name=foo_%s" % (target.name, target.name)) event.listen(some_table, "after_create", after_create) DDL events integrate closely with the :class:`.DDL` class and the :class:`.DDLElement` hierarchy of DDL clause constructs, which are themselves appropriate as listener callables:: from sqlalchemy import DDL event.listen( some_table, "after_create", DDL("ALTER TABLE %(table)s SET name=foo_%(table)s") ) The methods here define the name of an event as well as the names of members that are passed to listener functions. For all :class:`.DDLEvent` events, the ``propagate=True`` keyword argument will ensure that a given event handler is propagated to copies of the object, which are made when using the :meth:`_schema.Table.tometadata` method:: from sqlalchemy import DDL event.listen( some_table, "after_create", DDL("ALTER TABLE %(table)s SET name=foo_%(table)s"), propagate=True ) new_table = some_table.tometadata(new_metadata) The above :class:`.DDL` object will also be associated with the :class:`_schema.Table` object represented by ``new_table``. .. seealso:: :ref:`event_toplevel` :class:`.DDLElement` :class:`.DDL` :ref:`schema_ddl_sequences` """ _target_class_doc = "SomeSchemaClassOrObject" _dispatch_target = SchemaEventTarget def before_create(self, target, connection, kw): r"""Called before CREATE statements are emitted. :param target: the :class:`_schema.MetaData` or :class:`_schema.Table` object which is the target of the event. :param connection: the :class:`_engine.Connection` where the CREATE statement or statements will be emitted. :param \kw: additional keyword arguments relevant to the event. The contents of this dictionary may vary across releases, and include the list of tables being generated for a metadata-level event, the checkfirst flag, and other elements used by internal events. :func:`.event.listen` also accepts the ``propagate=True`` modifier for this event; when True, the listener function will be established for any copies made of the target object, i.e. those copies that are generated when :meth:`_schema.Table.tometadata` is used. """ def after_create(self, target, connection, kw): r"""Called after CREATE statements are emitted. :param target: the :class:`_schema.MetaData` or :class:`_schema.Table` object which is the target of the event. :param connection: the :class:`_engine.Connection` where the CREATE statement or statements have been emitted. :param \kw: additional keyword arguments relevant to the event. The contents of this dictionary may vary across releases, and include the list of tables being generated for a metadata-level event, the checkfirst flag, and other elements used by internal events. :func:`.event.listen` also accepts the ``propagate=True`` modifier for this event; when True, the listener function will be established for any copies made of the target object, i.e. those copies that are generated when :meth:`_schema.Table.tometadata` is used. """ def before_drop(self, target, connection, kw): r"""Called before DROP statements are emitted. :param target: the :class:`_schema.MetaData` or :class:`_schema.Table` object which is the target of the event. :param connection: the :class:`_engine.Connection` where the DROP statement or statements will be emitted. :param \kw: additional keyword arguments relevant to the event. The contents of this dictionary may vary across releases, and include the list of tables being generated for a metadata-level event, the checkfirst flag, and other elements used by internal events. :func:`.event.listen` also accepts the ``propagate=True`` modifier for this event; when True, the listener function will be established for any copies made of the target object, i.e. those copies that are generated when :meth:`_schema.Table.tometadata` is used. """ def after_drop(self, target, connection, kw): r"""Called after DROP statements are emitted. :param target: the :class:`_schema.MetaData` or :class:`_schema.Table` object which is the target of the event. :param connection: the :class:`_engine.Connection` where the DROP statement or statements have been emitted. :param \*kw: additional keyword arguments relevant to the event. The contents of this dictionary may vary across releases, and include the list of tables being generated for a metadata-level event, the checkfirst flag, and other elements used by internal events. :func:`.event.listen` also accepts the ``propagate=True`` modifier for this event; when True, the listener function will be established for any copies made of the target object, i.e. those copies that are generated when :meth:`_schema.Table.tometadata` is used. """ def before_parent_attach(self, target, parent): """Called before a :class:`.SchemaItem` is associated with a parent :class:`.SchemaItem`. :param target: the target object :param parent: the parent to which the target is being attached. :func:`.event.listen` also accepts the ``propagate=True`` modifier for this event; when True, the listener function will be established for any copies made of the target object, i.e. those copies that are generated when :meth:`_schema.Table.tometadata` is used. """ def after_parent_attach(self, target, parent): """Called after a :class:`.SchemaItem` is associated with a parent :class:`.SchemaItem`. :param target: the target object :param parent: the parent to which the target is being attached. :func:`.event.listen` also accepts the ``propagate=True`` modifier for this event; when True, the listener function will be established for any copies made of the target object, i.e. those copies that are generated when :meth:`_schema.Table.tometadata` is used. """ def _sa_event_column_added_to_pk_constraint(self, const, col): """internal event hook used for primary key naming convention updates. """ def column_reflect(self, inspector, table, column_info): """Called for each unit of 'column info' retrieved when a :class:`_schema.Table` is being reflected. Currently, this event may only be applied to the :class:`_schema.Table` class directly:: from sqlalchemy import Table @event.listens_for(Table, 'column_reflect') def receive_column_reflect(inspector, table, column_info): # receives for all Table objects that are reflected Or applied using the :paramref:`_schema.Table.listeners` parameter:: t1 = Table( "my_table", autoload_with=some_engine, listeners=[ ('column_reflect', receive_column_reflect) ] ) A future release will allow it to be associated with a specific :class:`_schema.MetaData` object as well. The dictionary of column information as returned by the dialect is passed, and can be modified. The dictionary is that returned in each element of the list returned by :meth:`.reflection.Inspector.get_columns`: ``name`` - the column's name, is applied to the :paramref:`_schema.Column.name` parameter * ``type`` - the type of this column, which should be an instance of :class:`~sqlalchemy.types.TypeEngine`, is applied to the :paramref:`_schema.Column.type` parameter * ``nullable`` - boolean flag if the column is NULL or NOT NULL, is applied to the :paramref:`_schema.Column.nullable` parameter * ``default`` - the column's server default value. This is normally specified as a plain string SQL expression, however the event can pass a :class:`.FetchedValue`, :class:`.DefaultClause`, or :func:`_expression.text` object as well. Is applied to the :paramref:`_schema.Column.server_default` parameter .. versionchanged:: 1.1.6 The :meth:`.DDLEvents.column_reflect` event allows a non string :class:`.FetchedValue`, :func:`_expression.text`, or derived object to be specified as the value of ``default`` in the column dictionary. The event is called before any action is taken against this dictionary, and the contents can be modified; the following additional keys may be added to the dictionary to further modify how the :class:`_schema.Column` is constructed: * ``key`` - the string key that will be used to access this :class:`_schema.Column` in the ``.c`` collection; will be applied to the :paramref:`_schema.Column.key` parameter. Is also used for ORM mapping. See the section :ref:`mapper_automated_reflection_schemes` for an example. * ``quote`` - force or un-force quoting on the column name; is applied to the :paramref:`_schema.Column.quote` parameter. * ``info`` - a dictionary of arbitrary data to follow along with the :class:`_schema.Column`, is applied to the :paramref:`_schema.Column.info` parameter. :func:`.event.listen` also accepts the ``propagate=True`` modifier for this event; when True, the listener function will be established for any copies made of the target object, i.e. those copies that are generated when :meth:`_schema.Table.to_metadata` is used. """ class PoolEvents(event.Events): """Available events for :class:`_pool.Pool`. The methods here define the name of an event as well as the names of members that are passed to listener functions. e.g.:: from sqlalchemy import event def my_on_checkout(dbapi_conn, connection_rec, connection_proxy): "handle an on checkout event" event.listen(Pool, 'checkout', my_on_checkout) In addition to accepting the :class:`_pool.Pool` class and :class:`_pool.Pool` instances, :class:`_events.PoolEvents` also accepts :class:`_engine.Engine` objects and the :class:`_engine.Engine` class as targets, which will be resolved to the ``.pool`` attribute of the given engine or the :class:`_pool.Pool` class:: engine = create_engine("postgresql://scott:tiger@localhost/test") # will associate with engine.pool event.listen(engine, 'checkout', my_on_checkout) """ _target_class_doc = "SomeEngineOrPool" _dispatch_target = Pool @classmethod def _accept_with(cls, target): if isinstance(target, type): if issubclass(target, Engine): return Pool elif issubclass(target, Pool): return target elif isinstance(target, Engine): return target.pool else: return target def connect(self, dbapi_connection, connection_record): """Called at the moment a particular DBAPI connection is first created for a given :class:`_pool.Pool`. This event allows one to capture the point directly after which the DBAPI module-level ``.connect()`` method has been used in order to produce a new DBAPI connection. :param dbapi_connection: a DBAPI connection. :param connection_record: the :class:`._ConnectionRecord` managing the DBAPI connection. """ def first_connect(self, dbapi_connection, connection_record): """Called exactly once for the first time a DBAPI connection is checked out from a particular :class:`_pool.Pool`. The rationale for :meth:`_events.PoolEvents.first_connect` is to determine information about a particular series of database connections based on the settings used for all connections. Since a particular :class:`_pool.Pool` refers to a single "creator" function (which in terms of a :class:`_engine.Engine` refers to the URL and connection options used), it is typically valid to make observations about a single connection that can be safely assumed to be valid about all subsequent connections, such as the database version, the server and client encoding settings, collation settings, and many others. :param dbapi_connection: a DBAPI connection. :param connection_record: the :class:`._ConnectionRecord` managing the DBAPI connection. """ def checkout(self, dbapi_connection, connection_record, connection_proxy): """Called when a connection is retrieved from the Pool. :param dbapi_connection: a DBAPI connection. :param connection_record: the :class:`._ConnectionRecord` managing the DBAPI connection. :param connection_proxy: the :class:`._ConnectionFairy` object which will proxy the public interface of the DBAPI connection for the lifespan of the checkout. If you raise a :class:`~sqlalchemy.exc.DisconnectionError`, the current connection will be disposed and a fresh connection retrieved. Processing of all checkout listeners will abort and restart using the new connection. .. seealso:: :meth:`_events.ConnectionEvents.engine_connect` - a similar event which occurs upon creation of a new :class:`_engine.Connection`. """ def checkin(self, dbapi_connection, connection_record): """Called when a connection returns to the pool. Note that the connection may be closed, and may be None if the connection has been invalidated. ``checkin`` will not be called for detached connections. (They do not return to the pool.) :param dbapi_connection: a DBAPI connection. :param connection_record: the :class:`._ConnectionRecord` managing the DBAPI connection. """ def reset(self, dbapi_connection, connection_record): """Called before the "reset" action occurs for a pooled connection. This event represents when the ``rollback()`` method is called on the DBAPI connection before it is returned to the pool. The behavior of "reset" can be controlled, including disabled, using the ``reset_on_return`` pool argument. The :meth:`_events.PoolEvents.reset` event is usually followed by the :meth:`_events.PoolEvents.checkin` event is called, except in those cases where the connection is discarded immediately after reset. :param dbapi_connection: a DBAPI connection. :param connection_record: the :class:`._ConnectionRecord` managing the DBAPI connection. .. seealso:: :meth:`_events.ConnectionEvents.rollback` :meth:`_events.ConnectionEvents.commit` """ def invalidate(self, dbapi_connection, connection_record, exception): """Called when a DBAPI connection is to be "invalidated". This event is called any time the :meth:`._ConnectionRecord.invalidate` method is invoked, either from API usage or via "auto-invalidation", without the ``soft`` flag. The event occurs before a final attempt to call ``.close()`` on the connection occurs. :param dbapi_connection: a DBAPI connection. :param connection_record: the :class:`._ConnectionRecord` managing the DBAPI connection. :param exception: the exception object corresponding to the reason for this invalidation, if any. May be ``None``. .. versionadded:: 0.9.2 Added support for connection invalidation listening. .. seealso:: :ref:`pool_connection_invalidation` """ def soft_invalidate(self, dbapi_connection, connection_record, exception): """Called when a DBAPI connection is to be "soft invalidated". This event is called any time the :meth:`._ConnectionRecord.invalidate` method is invoked with the ``soft`` flag. Soft invalidation refers to when the connection record that tracks this connection will force a reconnect after the current connection is checked in. It does not actively close the dbapi_connection at the point at which it is called. .. versionadded:: 1.0.3 """ def close(self, dbapi_connection, connection_record): """Called when a DBAPI connection is closed. The event is emitted before the close occurs. The close of a connection can fail; typically this is because the connection is already closed. If the close operation fails, the connection is discarded. The :meth:`.close` event corresponds to a connection that's still associated with the pool. To intercept close events for detached connections use :meth:`.close_detached`. .. versionadded:: 1.1 """ def detach(self, dbapi_connection, connection_record): """Called when a DBAPI connection is "detached" from a pool. This event is emitted after the detach occurs. The connection is no longer associated with the given connection record. .. versionadded:: 1.1 """ def close_detached(self, dbapi_connection): """Called when a detached DBAPI connection is closed. The event is emitted before the close occurs. The close of a connection can fail; typically this is because the connection is already closed. If the close operation fails, the connection is discarded. .. versionadded:: 1.1 """ class ConnectionEvents(event.Events): """Available events for :class:`.Connectable`, which includes :class:`_engine.Connection` and :class:`_engine.Engine`. The methods here define the name of an event as well as the names of members that are passed to listener functions. An event listener can be associated with any :class:`.Connectable` class or instance, such as an :class:`_engine.Engine`, e.g.:: from sqlalchemy import event, create_engine def before_cursor_execute(conn, cursor, statement, parameters, context, executemany): log.info("Received statement: %s", statement) engine = create_engine('postgresql://scott:tiger@localhost/test') event.listen(engine, "before_cursor_execute", before_cursor_execute) or with a specific :class:`_engine.Connection`:: with engine.begin() as conn: @event.listens_for(conn, 'before_cursor_execute') def before_cursor_execute(conn, cursor, statement, parameters, context, executemany): log.info("Received statement: %s", statement) When the methods are called with a `statement` parameter, such as in :meth:`.after_cursor_execute`, :meth:`.before_cursor_execute` and :meth:`.dbapi_error`, the statement is the exact SQL string that was prepared for transmission to the DBAPI ``cursor`` in the connection's :class:`.Dialect`. The :meth:`.before_execute` and :meth:`.before_cursor_execute` events can also be established with the ``retval=True`` flag, which allows modification of the statement and parameters to be sent to the database. The :meth:`.before_cursor_execute` event is particularly useful here to add ad-hoc string transformations, such as comments, to all executions:: from sqlalchemy.engine import Engine from sqlalchemy import event @event.listens_for(Engine, "before_cursor_execute", retval=True) def comment_sql_calls(conn, cursor, statement, parameters, context, executemany): statement = statement + " -- some comment" return statement, parameters .. note:: :class:`_events.ConnectionEvents` can be established on any combination of :class:`_engine.Engine`, :class:`_engine.Connection`, as well as instances of each of those classes. Events across all four scopes will fire off for a given instance of :class:`_engine.Connection`. However, for performance reasons, the :class:`_engine.Connection` object determines at instantiation time whether or not its parent :class:`_engine.Engine` has event listeners established. Event listeners added to the :class:`_engine.Engine` class or to an instance of :class:`_engine.Engine` after the instantiation of a dependent :class:`_engine.Connection` instance will usually not be available on that :class:`_engine.Connection` instance. The newly added listeners will instead take effect for :class:`_engine.Connection` instances created subsequent to those event listeners being established on the parent :class:`_engine.Engine` class or instance. :param retval=False: Applies to the :meth:`.before_execute` and :meth:`.before_cursor_execute` events only. When True, the user-defined event function must have a return value, which is a tuple of parameters that replace the given statement and parameters. See those methods for a description of specific return arguments. """ _target_class_doc = "SomeEngine" _dispatch_target = Connectable @classmethod def _listen(cls, event_key, retval=False): target, identifier, fn = ( event_key.dispatch_target, event_key.identifier, event_key._listen_fn, ) target._has_events = True if not retval: if identifier == "before_execute": orig_fn = fn def wrap_before_execute( conn, clauseelement, multiparams, params ): orig_fn(conn, clauseelement, multiparams, params) return clauseelement, multiparams, params fn = wrap_before_execute elif identifier == "before_cursor_execute": orig_fn = fn def wrap_before_cursor_execute( conn, cursor, statement, parameters, context, executemany ): orig_fn( conn, cursor, statement, parameters, context, executemany, ) return statement, parameters fn = wrap_before_cursor_execute elif retval and identifier not in ( "before_execute", "before_cursor_execute", "handle_error", ): raise exc.ArgumentError( "Only the 'before_execute', " "'before_cursor_execute' and 'handle_error' engine " "event listeners accept the 'retval=True' " "argument." ) event_key.with_wrapper(fn).base_listen() def before_execute(self, conn, clauseelement, multiparams, params): """Intercept high level execute() events, receiving uncompiled SQL constructs and other objects prior to rendering into SQL. This event is good for debugging SQL compilation issues as well as early manipulation of the parameters being sent to the database, as the parameter lists will be in a consistent format here. This event can be optionally established with the ``retval=True`` flag. The ``clauseelement``, ``multiparams``, and ``params`` arguments should be returned as a three-tuple in this case:: @event.listens_for(Engine, "before_execute", retval=True) def before_execute(conn, clauseelement, multiparams, params): # do something with clauseelement, multiparams, params return clauseelement, multiparams, params :param conn: :class:`_engine.Connection` object :param clauseelement: SQL expression construct, :class:`.Compiled` instance, or string statement passed to :meth:`_engine.Connection.execute`. :param multiparams: Multiple parameter sets, a list of dictionaries. :param params: Single parameter set, a single dictionary. .. seealso:: :meth:`.before_cursor_execute` """ def after_execute(self, conn, clauseelement, multiparams, params, result): """Intercept high level execute() events after execute. :param conn: :class:`_engine.Connection` object :param clauseelement: SQL expression construct, :class:`.Compiled` instance, or string statement passed to :meth:`_engine.Connection.execute`. :param multiparams: Multiple parameter sets, a list of dictionaries. :param params: Single parameter set, a single dictionary. :param result: :class:`_engine.ResultProxy` generated by the execution . """ def before_cursor_execute( self, conn, cursor, statement, parameters, context, executemany ): """Intercept low-level cursor execute() events before execution, receiving the string SQL statement and DBAPI-specific parameter list to be invoked against a cursor. This event is a good choice for logging as well as late modifications to the SQL string. It's less ideal for parameter modifications except for those which are specific to a target backend. This event can be optionally established with the ``retval=True`` flag. The ``statement`` and ``parameters`` arguments should be returned as a two-tuple in this case:: @event.listens_for(Engine, "before_cursor_execute", retval=True) def before_cursor_execute(conn, cursor, statement, parameters, context, executemany): # do something with statement, parameters return statement, parameters See the example at :class:`_events.ConnectionEvents`. :param conn: :class:`_engine.Connection` object :param cursor: DBAPI cursor object :param statement: string SQL statement, as to be passed to the DBAPI :param parameters: Dictionary, tuple, or list of parameters being passed to the ``execute()`` or ``executemany()`` method of the DBAPI ``cursor``. In some cases may be ``None``. :param context: :class:`.ExecutionContext` object in use. May be ``None``. :param executemany: boolean, if ``True``, this is an ``executemany()`` call, if ``False``, this is an ``execute()`` call. .. seealso:: :meth:`.before_execute` :meth:`.after_cursor_execute` """ def after_cursor_execute( self, conn, cursor, statement, parameters, context, executemany ): """Intercept low-level cursor execute() events after execution. :param conn: :class:`_engine.Connection` object :param cursor: DBAPI cursor object. Will have results pending if the statement was a SELECT, but these should not be consumed as they will be needed by the :class:`_engine.ResultProxy`. :param statement: string SQL statement, as passed to the DBAPI :param parameters: Dictionary, tuple, or list of parameters being passed to the ``execute()`` or ``executemany()`` method of the DBAPI ``cursor``. In some cases may be ``None``. :param context: :class:`.ExecutionContext` object in use. May be ``None``. :param executemany: boolean, if ``True``, this is an ``executemany()`` call, if ``False``, this is an ``execute()`` call. """ @util.deprecated( "0.9", "The :meth:`_events.ConnectionEvents.dbapi_error` " "event is deprecated and will be removed in a future release. " "Please refer to the :meth:`_events.ConnectionEvents.handle_error` " "event.", ) def dbapi_error( self, conn, cursor, statement, parameters, context, exception ): """Intercept a raw DBAPI error. This event is called with the DBAPI exception instance received from the DBAPI itself, before SQLAlchemy wraps the exception with it's own exception wrappers, and before any other operations are performed on the DBAPI cursor; the existing transaction remains in effect as well as any state on the cursor. The use case here is to inject low-level exception handling into an :class:`_engine.Engine`, typically for logging and debugging purposes. .. warning:: Code should not modify any state or throw any exceptions here as this will interfere with SQLAlchemy's cleanup and error handling routines. For exception modification, please refer to the new :meth:`_events.ConnectionEvents.handle_error` event. Subsequent to this hook, SQLAlchemy may attempt any number of operations on the connection/cursor, including closing the cursor, rolling back of the transaction in the case of connectionless execution, and disposing of the entire connection pool if a "disconnect" was detected. The exception is then wrapped in a SQLAlchemy DBAPI exception wrapper and re-thrown. :param conn: :class:`_engine.Connection` object :param cursor: DBAPI cursor object :param statement: string SQL statement, as passed to the DBAPI :param parameters: Dictionary, tuple, or list of parameters being passed to the ``execute()`` or ``executemany()`` method of the DBAPI ``cursor``. In some cases may be ``None``. :param context: :class:`.ExecutionContext` object in use. May be ``None``. :param exception: The unwrapped exception emitted directly from the DBAPI. The class here is specific to the DBAPI module in use. """ def handle_error(self, exception_context): r"""Intercept all exceptions processed by the :class:`_engine.Connection`. This includes all exceptions emitted by the DBAPI as well as within SQLAlchemy's statement invocation process, including encoding errors and other statement validation errors. Other areas in which the event is invoked include transaction begin and end, result row fetching, cursor creation. Note that :meth:`.handle_error` may support new kinds of exceptions and new calling scenarios at any time. Code which uses this event must expect new calling patterns to be present in minor releases. To support the wide variety of members that correspond to an exception, as well as to allow extensibility of the event without backwards incompatibility, the sole argument received is an instance of :class:`.ExceptionContext`. This object contains data members representing detail about the exception. Use cases supported by this hook include: * read-only, low-level exception handling for logging and debugging purposes * exception re-writing * Establishing or disabling whether a connection or the owning connection pool is invalidated or expired in response to a specific exception. [1]_. The hook is called while the cursor from the failed operation (if any) is still open and accessible. Special cleanup operations can be called on this cursor; SQLAlchemy will attempt to close this cursor subsequent to this hook being invoked. If the connection is in "autocommit" mode, the transaction also remains open within the scope of this hook; the rollback of the per-statement transaction also occurs after the hook is called. .. note:: .. [1] The pool "pre_ping" handler enabled using the :paramref:`_sa.create_engine.pool_pre_ping` parameter does not consult this event before deciding if the "ping" returned false, as opposed to receiving an unhandled error. For this use case, the :ref:`legacy recipe based on engine_connect() may be used <pool_disconnects_pessimistic_custom>`. A future API allow more comprehensive customization of the "disconnect" detection mechanism across all functions. A handler function has two options for replacing the SQLAlchemy-constructed exception into one that is user defined. It can either raise this new exception directly, in which case all further event listeners are bypassed and the exception will be raised, after appropriate cleanup as taken place:: @event.listens_for(Engine, "handle_error") def handle_exception(context): if isinstance(context.original_exception, psycopg2.OperationalError) and \ "failed" in str(context.original_exception): raise MySpecialException("failed operation") .. warning:: Because the :meth:`_events.ConnectionEvents.handle_error` event specifically provides for exceptions to be re-thrown as the ultimate exception raised by the failed statement, stack traces will be misleading if the user-defined event handler itself fails and throws an unexpected exception; the stack trace may not illustrate the actual code line that failed! It is advised to code carefully here and use logging and/or inline debugging if unexpected exceptions are occurring. Alternatively, a "chained" style of event handling can be used, by configuring the handler with the ``retval=True`` modifier and returning the new exception instance from the function. In this case, event handling will continue onto the next handler. The "chained" exception is available using :attr:`.ExceptionContext.chained_exception`:: @event.listens_for(Engine, "handle_error", retval=True) def handle_exception(context): if context.chained_exception is not None and \ "special" in context.chained_exception.message: return MySpecialException("failed", cause=context.chained_exception) Handlers that return ``None`` may be used within the chain; when a handler returns ``None``, the previous exception instance, if any, is maintained as the current exception that is passed onto the next handler. When a custom exception is raised or returned, SQLAlchemy raises this new exception as-is, it is not wrapped by any SQLAlchemy object. If the exception is not a subclass of :class:`sqlalchemy.exc.StatementError`, certain features may not be available; currently this includes the ORM's feature of adding a detail hint about "autoflush" to exceptions raised within the autoflush process. :param context: an :class:`.ExceptionContext` object. See this class for details on all available members. .. versionadded:: 0.9.7 Added the :meth:`_events.ConnectionEvents.handle_error` hook. .. versionchanged:: 1.1 The :meth:`.handle_error` event will now receive all exceptions that inherit from ``BaseException``, including ``SystemExit`` and ``KeyboardInterrupt``. The setting for :attr:`.ExceptionContext.is_disconnect` is ``True`` in this case and the default for :attr:`.ExceptionContext.invalidate_pool_on_disconnect` is ``False``. .. versionchanged:: 1.0.0 The :meth:`.handle_error` event is now invoked when an :class:`_engine.Engine` fails during the initial call to :meth:`_engine.Engine.connect`, as well as when a :class:`_engine.Connection` object encounters an error during a reconnect operation. .. versionchanged:: 1.0.0 The :meth:`.handle_error` event is not fired off when a dialect makes use of the ``skip_user_error_events`` execution option. This is used by dialects which intend to catch SQLAlchemy-specific exceptions within specific operations, such as when the MySQL dialect detects a table not present within the ``has_table()`` dialect method. Prior to 1.0.0, code which implements :meth:`.handle_error` needs to ensure that exceptions thrown in these scenarios are re-raised without modification. """ def engine_connect(self, conn, branch): """Intercept the creation of a new :class:`_engine.Connection`. This event is called typically as the direct result of calling the :meth:`_engine.Engine.connect` method. It differs from the :meth:`_events.PoolEvents.connect` method, which refers to the actual connection to a database at the DBAPI level; a DBAPI connection may be pooled and reused for many operations. In contrast, this event refers only to the production of a higher level :class:`_engine.Connection` wrapper around such a DBAPI connection. It also differs from the :meth:`_events.PoolEvents.checkout` event in that it is specific to the :class:`_engine.Connection` object, not the DBAPI connection that :meth:`_events.PoolEvents.checkout` deals with, although this DBAPI connection is available here via the :attr:`_engine.Connection.connection` attribute. But note there can in fact be multiple :meth:`_events.PoolEvents.checkout` events within the lifespan of a single :class:`_engine.Connection` object, if that :class:`_engine.Connection` is invalidated and re-established. There can also be multiple :class:`_engine.Connection` objects generated for the same already-checked-out DBAPI connection, in the case that a "branch" of a :class:`_engine.Connection` is produced. :param conn: :class:`_engine.Connection` object. :param branch: if True, this is a "branch" of an existing :class:`_engine.Connection`. A branch is generated within the course of a statement execution to invoke supplemental statements, most typically to pre-execute a SELECT of a default value for the purposes of an INSERT statement. .. versionadded:: 0.9.0 .. seealso:: :ref:`pool_disconnects_pessimistic` - illustrates how to use :meth:`_events.ConnectionEvents.engine_connect` to transparently ensure pooled connections are connected to the database. :meth:`_events.PoolEvents.checkout` the lower-level pool checkout event for an individual DBAPI connection :meth:`_events.ConnectionEvents.set_connection_execution_options` - a copy of a :class:`_engine.Connection` is also made when the :meth:`_engine.Connection.execution_options` method is called. """ def set_connection_execution_options(self, conn, opts): """Intercept when the :meth:`_engine.Connection.execution_options` method is called. This method is called after the new :class:`_engine.Connection` has been produced, with the newly updated execution options collection, but before the :class:`.Dialect` has acted upon any of those new options. Note that this method is not called when a new :class:`_engine.Connection` is produced which is inheriting execution options from its parent :class:`_engine.Engine`; to intercept this condition, use the :meth:`_events.ConnectionEvents.engine_connect` event. :param conn: The newly copied :class:`_engine.Connection` object :param opts: dictionary of options that were passed to the :meth:`_engine.Connection.execution_options` method. .. versionadded:: 0.9.0 .. seealso:: :meth:`_events.ConnectionEvents.set_engine_execution_options` - event which is called when :meth:`_engine.Engine.execution_options` is called. """ def set_engine_execution_options(self, engine, opts): """Intercept when the :meth:`_engine.Engine.execution_options` method is called. The :meth:`_engine.Engine.execution_options` method produces a shallow copy of the :class:`_engine.Engine` which stores the new options. That new :class:`_engine.Engine` is passed here. A particular application of this method is to add a :meth:`_events.ConnectionEvents.engine_connect` event handler to the given :class:`_engine.Engine` which will perform some per- :class:`_engine.Connection` task specific to these execution options. :param conn: The newly copied :class:`_engine.Engine` object :param opts: dictionary of options that were passed to the :meth:`_engine.Connection.execution_options` method. .. versionadded:: 0.9.0 .. seealso:: :meth:`_events.ConnectionEvents.set_connection_execution_options` - event which is called when :meth:`_engine.Connection.execution_options` is called. """ def engine_disposed(self, engine): """Intercept when the :meth:`_engine.Engine.dispose` method is called. The :meth:`_engine.Engine.dispose` method instructs the engine to "dispose" of it's connection pool (e.g. :class:`_pool.Pool`), and replaces it with a new one. Disposing of the old pool has the effect that existing checked-in connections are closed. The new pool does not establish any new connections until it is first used. This event can be used to indicate that resources related to the :class:`_engine.Engine` should also be cleaned up, keeping in mind that the :class:`_engine.Engine` can still be used for new requests in which case it re-acquires connection resources. .. versionadded:: 1.0.5 """ def begin(self, conn): """Intercept begin() events. :param conn: :class:`_engine.Connection` object """ def rollback(self, conn): """Intercept rollback() events, as initiated by a :class:`.Transaction`. Note that the :class:`_pool.Pool` also "auto-rolls back" a DBAPI connection upon checkin, if the ``reset_on_return`` flag is set to its default value of ``'rollback'``. To intercept this rollback, use the :meth:`_events.PoolEvents.reset` hook. :param conn: :class:`_engine.Connection` object .. seealso:: :meth:`_events.PoolEvents.reset` """ def commit(self, conn): """Intercept commit() events, as initiated by a :class:`.Transaction`. Note that the :class:`_pool.Pool` may also "auto-commit" a DBAPI connection upon checkin, if the ``reset_on_return`` flag is set to the value ``'commit'``. To intercept this commit, use the :meth:`_events.PoolEvents.reset` hook. :param conn: :class:`_engine.Connection` object """ def savepoint(self, conn, name): """Intercept savepoint() events. :param conn: :class:`_engine.Connection` object :param name: specified name used for the savepoint. """ def rollback_savepoint(self, conn, name, context): """Intercept rollback_savepoint() events. :param conn: :class:`_engine.Connection` object :param name: specified name used for the savepoint. :param context: :class:`.ExecutionContext` in use. May be ``None``. """ def release_savepoint(self, conn, name, context): """Intercept release_savepoint() events. :param conn: :class:`_engine.Connection` object :param name: specified name used for the savepoint. :param context: :class:`.ExecutionContext` in use. May be ``None``. """ def begin_twophase(self, conn, xid): """Intercept begin_twophase() events. :param conn: :class:`_engine.Connection` object :param xid: two-phase XID identifier """ def prepare_twophase(self, conn, xid): """Intercept prepare_twophase() events. :param conn: :class:`_engine.Connection` object :param xid: two-phase XID identifier """ def rollback_twophase(self, conn, xid, is_prepared): """Intercept rollback_twophase() events. :param conn: :class:`_engine.Connection` object :param xid: two-phase XID identifier :param is_prepared: boolean, indicates if :meth:`.TwoPhaseTransaction.prepare` was called. """ def commit_twophase(self, conn, xid, is_prepared): """Intercept commit_twophase() events. :param conn: :class:`_engine.Connection` object :param xid: two-phase XID identifier :param is_prepared: boolean, indicates if :meth:`.TwoPhaseTransaction.prepare` was called. """ class DialectEvents(event.Events): """event interface for execution-replacement functions. These events allow direct instrumentation and replacement of key dialect functions which interact with the DBAPI. .. note:: :class:`.DialectEvents` hooks should be considered semi-public and experimental. These hooks are not for general use and are only for those situations where intricate re-statement of DBAPI mechanics must be injected onto an existing dialect. For general-use statement-interception events, please use the :class:`_events.ConnectionEvents` interface. .. seealso:: :meth:`_events.ConnectionEvents.before_cursor_execute` :meth:`_events.ConnectionEvents.before_execute` :meth:`_events.ConnectionEvents.after_cursor_execute` :meth:`_events.ConnectionEvents.after_execute` .. versionadded:: 0.9.4 """ _target_class_doc = "SomeEngine" _dispatch_target = Dialect @classmethod def _listen(cls, event_key, retval=False): target = event_key.dispatch_target target._has_events = True event_key.base_listen() @classmethod def _accept_with(cls, target): if isinstance(target, type): if issubclass(target, Engine): return Dialect elif issubclass(target, Dialect): return target elif isinstance(target, Engine): return target.dialect else: return target def do_connect(self, dialect, conn_rec, cargs, cparams): """Receive connection arguments before a connection is made. Return a DBAPI connection to halt further events from invoking; the returned connection will be used. Alternatively, the event can manipulate the cargs and/or cparams collections; cargs will always be a Python list that can be mutated in-place and cparams a Python dictionary. Return None to allow control to pass to the next event handler and ultimately to allow the dialect to connect normally, given the updated arguments. .. versionadded:: 1.0.3 .. seealso:: :ref:`custom_dbapi_args` """ def do_executemany(self, cursor, statement, parameters, context): """Receive a cursor to have executemany() called. Return the value True to halt further events from invoking, and to indicate that the cursor execution has already taken place within the event handler. """ def do_execute_no_params(self, cursor, statement, context): """Receive a cursor to have execute() with no parameters called. Return the value True to halt further events from invoking, and to indicate that the cursor execution has already taken place within the event handler. """ def do_execute(self, cursor, statement, parameters, context): """Receive a cursor to have execute() called. Return the value True to halt further events from invoking, and to indicate that the cursor execution has already taken place within the event handler. """ def do_setinputsizes( self, inputsizes, cursor, statement, parameters, context ): """Receive the setinputsizes dictionary for possible modification. This event is emitted in the case where the dialect makes use of the DBAPI ``cursor.setinputsizes()`` method which passes information about parameter binding for a particular statement. The given ``inputsizes`` dictionary will contain :class:`.BindParameter` objects as keys, linked to DBAPI-specific type objects as values; for parameters that are not bound, they are added to the dictionary with ``None`` as the value, which means the parameter will not be included in the ultimate setinputsizes call. The event may be used to inspect and/or log the datatypes that are being bound, as well as to modify the dictionary in place. Parameters can be added, modified, or removed from this dictionary. Callers will typically want to inspect the :attr:`.BindParameter.type` attribute of the given bind objects in order to make decisions about the DBAPI object. After the event, the ``inputsizes`` dictionary is converted into an appropriate datastructure to be passed to ``cursor.setinputsizes``; either a list for a positional bound parameter execution style, or a dictionary of string parameter keys to DBAPI type objects for a named bound parameter execution style. Most dialects do not use this method at all; the only built-in dialect which uses this hook is the cx_Oracle dialect. The hook here is made available so as to allow customization of how datatypes are set up with the cx_Oracle DBAPI. .. versionadded:: 1.2.9 .. seealso:: :ref:`cx_oracle_setinputsizes` """ pass	52.37 KB	2026-01-20 12:58
📄 exc.py # sqlalchemy/exc.py # Copyright (C) 2005-2021 the SQLAlchemy authors and contributors # <see AUTHORS file> # # This module is part of SQLAlchemy and is released under # the MIT License: http://www.opensource.org/licenses/mit-license.php """Exceptions used with SQLAlchemy. The base exception class is :exc:`.SQLAlchemyError`. Exceptions which are raised as a result of DBAPI exceptions are all subclasses of :exc:`.DBAPIError`. """ from .util import _preloaded from .util import compat _version_token = None class SQLAlchemyError(Exception): """Generic error class.""" code = None def __init__(self, arg, kw): code = kw.pop("code", None) if code is not None: self.code = code super(SQLAlchemyError, self).__init__(arg, *kw) def _code_str(self): if not self.code: return "" else: return ( "(Background on this error at: " "http://sqlalche.me/e/%s/%s)" % ( _version_token, self.code, ) ) def _message(self, as_unicode=compat.py3k): # rules: # # 1. under py2k, for __str__ return single string arg as it was # given without converting to unicode. for __unicode__ # do a conversion but check that it's not unicode already just in # case # # 2. under py3k, single arg string will usually be a unicode # object, but since __str__() must return unicode, check for # bytestring just in case # # 3. for multiple self.args, this is not a case in current # SQLAlchemy though this is happening in at least one known external # library, call str() which does a repr(). # if len(self.args) == 1: text = self.args[0] if as_unicode and isinstance(text, compat.binary_types): text = compat.decode_backslashreplace(text, "utf-8") # This is for when the argument is not a string of any sort. # Otherwise, converting this exception to string would fail for # non-string arguments. elif compat.py3k or not as_unicode: text = str(text) else: text = compat.text_type(text) return text else: # this is not a normal case within SQLAlchemy but is here for # compatibility with Exception.args - the str() comes out as # a repr() of the tuple return str(self.args) def _sql_message(self, as_unicode): message = self._message(as_unicode) if self.code: message = "%s %s" % (message, self._code_str()) return message def __str__(self): return self._sql_message(compat.py3k) def __unicode__(self): return self._sql_message(as_unicode=True) class ArgumentError(SQLAlchemyError): """Raised when an invalid or conflicting function argument is supplied. This error generally corresponds to construction time state errors. """ class ObjectNotExecutableError(ArgumentError): """Raised when an object is passed to .execute() that can't be executed as SQL. .. versionadded:: 1.1 """ def __init__(self, target): super(ObjectNotExecutableError, self).__init__( "Not an executable object: %r" % target ) class NoSuchModuleError(ArgumentError): """Raised when a dynamically-loaded module (usually a database dialect) of a particular name cannot be located.""" class NoForeignKeysError(ArgumentError): """Raised when no foreign keys can be located between two selectables during a join.""" class AmbiguousForeignKeysError(ArgumentError): """Raised when more than one foreign key matching can be located between two selectables during a join.""" class CircularDependencyError(SQLAlchemyError): """Raised by topological sorts when a circular dependency is detected. There are two scenarios where this error occurs: In a Session flush operation, if two objects are mutually dependent on each other, they can not be inserted or deleted via INSERT or DELETE statements alone; an UPDATE will be needed to post-associate or pre-deassociate one of the foreign key constrained values. The ``post_update`` flag described at :ref:`post_update` can resolve this cycle. * In a :attr:`_schema.MetaData.sorted_tables` operation, two :class:`_schema.ForeignKey` or :class:`_schema.ForeignKeyConstraint` objects mutually refer to each other. Apply the ``use_alter=True`` flag to one or both, see :ref:`use_alter`. """ def __init__(self, message, cycles, edges, msg=None, code=None): if msg is None: message += " (%s)" % ", ".join(repr(s) for s in cycles) else: message = msg SQLAlchemyError.__init__(self, message, code=code) self.cycles = cycles self.edges = edges def __reduce__(self): return self.__class__, (None, self.cycles, self.edges, self.args[0]) class CompileError(SQLAlchemyError): """Raised when an error occurs during SQL compilation""" class UnsupportedCompilationError(CompileError): """Raised when an operation is not supported by the given compiler. .. seealso:: :ref:`faq_sql_expression_string` :ref:`error_l7de` """ code = "l7de" def __init__(self, compiler, element_type, message=None): super(UnsupportedCompilationError, self).__init__( "Compiler %r can't render element of type %s%s" % (compiler, element_type, ": %s" % message if message else "") ) class IdentifierError(SQLAlchemyError): """Raised when a schema name is beyond the max character limit""" class DisconnectionError(SQLAlchemyError): """A disconnect is detected on a raw DB-API connection. This error is raised and consumed internally by a connection pool. It can be raised by the :meth:`_events.PoolEvents.checkout` event so that the host pool forces a retry; the exception will be caught three times in a row before the pool gives up and raises :class:`~sqlalchemy.exc.InvalidRequestError` regarding the connection attempt. """ invalidate_pool = False class InvalidatePoolError(DisconnectionError): """Raised when the connection pool should invalidate all stale connections. A subclass of :class:`_exc.DisconnectionError` that indicates that the disconnect situation encountered on the connection probably means the entire pool should be invalidated, as the database has been restarted. This exception will be handled otherwise the same way as :class:`_exc.DisconnectionError`, allowing three attempts to reconnect before giving up. .. versionadded:: 1.2 """ invalidate_pool = True class TimeoutError(SQLAlchemyError): # noqa """Raised when a connection pool times out on getting a connection.""" class InvalidRequestError(SQLAlchemyError): """SQLAlchemy was asked to do something it can't do. This error generally corresponds to runtime state errors. """ class NoInspectionAvailable(InvalidRequestError): """A subject passed to :func:`sqlalchemy.inspection.inspect` produced no context for inspection.""" class ResourceClosedError(InvalidRequestError): """An operation was requested from a connection, cursor, or other object that's in a closed state.""" class NoSuchColumnError(KeyError, InvalidRequestError): """A nonexistent column is requested from a ``RowProxy``.""" class NoReferenceError(InvalidRequestError): """Raised by ``ForeignKey`` to indicate a reference cannot be resolved.""" class NoReferencedTableError(NoReferenceError): """Raised by ``ForeignKey`` when the referred ``Table`` cannot be located. """ def __init__(self, message, tname): NoReferenceError.__init__(self, message) self.table_name = tname def __reduce__(self): return self.__class__, (self.args[0], self.table_name) class NoReferencedColumnError(NoReferenceError): """Raised by ``ForeignKey`` when the referred ``Column`` cannot be located. """ def __init__(self, message, tname, cname): NoReferenceError.__init__(self, message) self.table_name = tname self.column_name = cname def __reduce__(self): return ( self.__class__, (self.args[0], self.table_name, self.column_name), ) class NoSuchTableError(InvalidRequestError): """Table does not exist or is not visible to a connection.""" class UnreflectableTableError(InvalidRequestError): """Table exists but can't be reflected for some reason. .. versionadded:: 1.2 """ class UnboundExecutionError(InvalidRequestError): """SQL was attempted without a database connection to execute it on.""" class DontWrapMixin(object): """A mixin class which, when applied to a user-defined Exception class, will not be wrapped inside of :exc:`.StatementError` if the error is emitted within the process of executing a statement. E.g.:: from sqlalchemy.exc import DontWrapMixin class MyCustomException(Exception, DontWrapMixin): pass class MySpecialType(TypeDecorator): impl = String def process_bind_param(self, value, dialect): if value == 'invalid': raise MyCustomException("invalid!") """ # Moved to orm.exc; compatibility definition installed by orm import until 0.6 UnmappedColumnError = None class StatementError(SQLAlchemyError): """An error occurred during execution of a SQL statement. :class:`StatementError` wraps the exception raised during execution, and features :attr:`.statement` and :attr:`.params` attributes which supply context regarding the specifics of the statement which had an issue. The wrapped exception object is available in the :attr:`.orig` attribute. """ statement = None """The string SQL statement being invoked when this exception occurred.""" params = None """The parameter list being used when this exception occurred.""" orig = None """The DBAPI exception object.""" ismulti = None def __init__( self, message, statement, params, orig, hide_parameters=False, code=None, ismulti=None, ): SQLAlchemyError.__init__(self, message, code=code) self.statement = statement self.params = params self.orig = orig self.ismulti = ismulti self.hide_parameters = hide_parameters self.detail = [] def add_detail(self, msg): self.detail.append(msg) def __reduce__(self): return ( self.__class__, ( self.args[0], self.statement, self.params, self.orig, self.hide_parameters, self.ismulti, ), ) @_preloaded.dependencies("sqlalchemy.sql.util") def _sql_message(self, util, as_unicode): details = [self._message(as_unicode=as_unicode)] if self.statement: if not as_unicode and not compat.py3k: stmt_detail = "[SQL: %s]" % compat.safe_bytestring( self.statement ) else: stmt_detail = "[SQL: %s]" % self.statement details.append(stmt_detail) if self.params: if self.hide_parameters: details.append( "[SQL parameters hidden due to hide_parameters=True]" ) else: params_repr = util._repr_params( self.params, 10, ismulti=self.ismulti ) details.append("[parameters: %r]" % params_repr) code_str = self._code_str() if code_str: details.append(code_str) return "\n".join(["(%s)" % det for det in self.detail] + details) class DBAPIError(StatementError): """Raised when the execution of a database operation fails. Wraps exceptions raised by the DB-API underlying the database operation. Driver-specific implementations of the standard DB-API exception types are wrapped by matching sub-types of SQLAlchemy's :class:`DBAPIError` when possible. DB-API's ``Error`` type maps to :class:`DBAPIError` in SQLAlchemy, otherwise the names are identical. Note that there is no guarantee that different DB-API implementations will raise the same exception type for any given error condition. :class:`DBAPIError` features :attr:`~.StatementError.statement` and :attr:`~.StatementError.params` attributes which supply context regarding the specifics of the statement which had an issue, for the typical case when the error was raised within the context of emitting a SQL statement. The wrapped exception object is available in the :attr:`~.StatementError.orig` attribute. Its type and properties are DB-API implementation specific. """ code = "dbapi" @classmethod def instance( cls, statement, params, orig, dbapi_base_err, hide_parameters=False, connection_invalidated=False, dialect=None, ismulti=None, ): # Don't ever wrap these, just return them directly as if # DBAPIError didn't exist. if ( isinstance(orig, BaseException) and not isinstance(orig, Exception) ) or isinstance(orig, DontWrapMixin): return orig if orig is not None: # not a DBAPI error, statement is present. # raise a StatementError if isinstance(orig, SQLAlchemyError) and statement: return StatementError( "(%s.%s) %s" % ( orig.__class__.__module__, orig.__class__.__name__, orig.args[0], ), statement, params, orig, hide_parameters=hide_parameters, code=orig.code, ismulti=ismulti, ) elif not isinstance(orig, dbapi_base_err) and statement: return StatementError( "(%s.%s) %s" % ( orig.__class__.__module__, orig.__class__.__name__, orig, ), statement, params, orig, hide_parameters=hide_parameters, ismulti=ismulti, ) glob = globals() for super_ in orig.__class__.__mro__: name = super_.__name__ if dialect: name = dialect.dbapi_exception_translation_map.get( name, name ) if name in glob and issubclass(glob[name], DBAPIError): cls = glob[name] break return cls( statement, params, orig, connection_invalidated=connection_invalidated, hide_parameters=hide_parameters, code=cls.code, ismulti=ismulti, ) def __reduce__(self): return ( self.__class__, ( self.statement, self.params, self.orig, self.hide_parameters, self.connection_invalidated, self.ismulti, ), ) def __init__( self, statement, params, orig, hide_parameters=False, connection_invalidated=False, code=None, ismulti=None, ): try: text = str(orig) except Exception as e: text = "Error in str() of DB-API-generated exception: " + str(e) StatementError.__init__( self, "(%s.%s) %s" % (orig.__class__.__module__, orig.__class__.__name__, text), statement, params, orig, hide_parameters, code=code, ismulti=ismulti, ) self.connection_invalidated = connection_invalidated class InterfaceError(DBAPIError): """Wraps a DB-API InterfaceError.""" code = "rvf5" class DatabaseError(DBAPIError): """Wraps a DB-API DatabaseError.""" code = "4xp6" class DataError(DatabaseError): """Wraps a DB-API DataError.""" code = "9h9h" class OperationalError(DatabaseError): """Wraps a DB-API OperationalError.""" code = "e3q8" class IntegrityError(DatabaseError): """Wraps a DB-API IntegrityError.""" code = "gkpj" class InternalError(DatabaseError): """Wraps a DB-API InternalError.""" code = "2j85" class ProgrammingError(DatabaseError): """Wraps a DB-API ProgrammingError.""" code = "f405" class NotSupportedError(DatabaseError): """Wraps a DB-API NotSupportedError.""" code = "tw8g" # Warnings class SADeprecationWarning(DeprecationWarning): """Issued once per usage of a deprecated API.""" class SAPendingDeprecationWarning(PendingDeprecationWarning): """Issued once per usage of a deprecated API.""" class SAWarning(RuntimeWarning): """Issued at runtime."""	17.46 KB	2026-01-20 12:58
📁 ext	-	2026-03-21 15:45
📄 inspection.py # sqlalchemy/inspect.py # Copyright (C) 2005-2021 the SQLAlchemy authors and contributors # <see AUTHORS file> # # This module is part of SQLAlchemy and is released under # the MIT License: http://www.opensource.org/licenses/mit-license.php """The inspection module provides the :func:`_sa.inspect` function, which delivers runtime information about a wide variety of SQLAlchemy objects, both within the Core as well as the ORM. The :func:`_sa.inspect` function is the entry point to SQLAlchemy's public API for viewing the configuration and construction of in-memory objects. Depending on the type of object passed to :func:`_sa.inspect`, the return value will either be a related object which provides a known interface, or in many cases it will return the object itself. The rationale for :func:`_sa.inspect` is twofold. One is that it replaces the need to be aware of a large variety of "information getting" functions in SQLAlchemy, such as :meth:`_reflection.Inspector.from_engine`, :func:`.orm.attributes.instance_state`, :func:`_orm.class_mapper`, and others. The other is that the return value of :func:`_sa.inspect` is guaranteed to obey a documented API, thus allowing third party tools which build on top of SQLAlchemy configurations to be constructed in a forwards-compatible way. """ from . import exc from . import util _registrars = util.defaultdict(list) def inspect(subject, raiseerr=True): """Produce an inspection object for the given target. The returned value in some cases may be the same object as the one given, such as if a :class:`_orm.Mapper` object is passed. In other cases, it will be an instance of the registered inspection type for the given object, such as if an :class:`_engine.Engine` is passed, an :class:`_reflection.Inspector` object is returned. :param subject: the subject to be inspected. :param raiseerr: When ``True``, if the given subject does not correspond to a known SQLAlchemy inspected type, :class:`sqlalchemy.exc.NoInspectionAvailable` is raised. If ``False``, ``None`` is returned. """ type_ = type(subject) for cls in type_.__mro__: if cls in _registrars: reg = _registrars[cls] if reg is True: return subject ret = reg(subject) if ret is not None: break else: reg = ret = None if raiseerr and (reg is None or ret is None): raise exc.NoInspectionAvailable( "No inspection system is " "available for object of type %s" % type_ ) return ret def _inspects(*types): def decorate(fn_or_cls): for type_ in types: if type_ in _registrars: raise AssertionError( "Type %s is already " "registered" % type_ ) _registrars[type_] = fn_or_cls return fn_or_cls return decorate def _self_inspects(cls): _inspects(cls)(True) return cls	2.96 KB	2026-01-20 12:58
📄 interfaces.py # sqlalchemy/interfaces.py # Copyright (C) 2007-2021 the SQLAlchemy authors and contributors # <see AUTHORS file> # Copyright (C) 2007 Jason Kirtland jek@discorporate.us # # This module is part of SQLAlchemy and is released under # the MIT License: http://www.opensource.org/licenses/mit-license.php """Deprecated core event interfaces. .. deprecated:: 0.7 As of SQLAlchemy 0.7, the new event system described in :ref:`event_toplevel` replaces the extension/proxy/listener system, providing a consistent interface to all events without the need for subclassing. """ from . import event from . import util class PoolListener(object): """Hooks into the lifecycle of connections in a :class:`_pool.Pool`. .. deprecated:: 0.7 :class:`.PoolListener` is deprecated and will be removed in a future release. Please refer to :func:`.event.listen` in conjunction with the :class:`_events.PoolEvents` listener interface. Usage:: class MyListener(PoolListener): def connect(self, dbapi_con, con_record): '''perform connect operations''' # etc. # create a new pool with a listener p = QueuePool(..., listeners=[MyListener()]) # add a listener after the fact p.add_listener(MyListener()) # usage with create_engine() e = create_engine("url://", listeners=[MyListener()]) All of the standard connection :class:`~sqlalchemy.pool.Pool` types can accept event listeners for key connection lifecycle events: creation, pool check-out and check-in. There are no events fired when a connection closes. For any given DB-API connection, there will be one ``connect`` event, `n` number of ``checkout`` events, and either `n` or `n - 1` ``checkin`` events. (If a ``Connection`` is detached from its pool via the ``detach()`` method, it won't be checked back in.) These are low-level events for low-level objects: raw Python DB-API connections, without the conveniences of the SQLAlchemy ``Connection`` wrapper, ``Dialect`` services or ``ClauseElement`` execution. If you execute SQL through the connection, explicitly closing all cursors and other resources is recommended. Events also receive a ``_ConnectionRecord``, a long-lived internal ``Pool`` object that basically represents a "slot" in the connection pool. ``_ConnectionRecord`` objects have one public attribute of note: ``info``, a dictionary whose contents are scoped to the lifetime of the DB-API connection managed by the record. You can use this shared storage area however you like. There is no need to subclass ``PoolListener`` to handle events. Any class that implements one or more of these methods can be used as a pool listener. The ``Pool`` will inspect the methods provided by a listener object and add the listener to one or more internal event queues based on its capabilities. In terms of efficiency and function call overhead, you're much better off only providing implementations for the hooks you'll be using. """ @classmethod def _adapt_listener(cls, self, listener): """Adapt a :class:`.PoolListener` to individual :class:`event.Dispatch` events. """ methods = ["connect", "first_connect", "checkout", "checkin"] listener = util.as_interface(listener, methods=methods) for meth in methods: me_meth = getattr(PoolListener, meth) ls_meth = getattr(listener, meth, None) if ls_meth is not None and not util.methods_equivalent( me_meth, ls_meth ): util.warn_deprecated( "PoolListener.%s is deprecated. The " "PoolListener class will be removed in a future " "release. Please transition to the @event interface, " "using @event.listens_for(Engine, '%s')." % (meth, meth) ) if hasattr(listener, "connect"): event.listen(self, "connect", listener.connect) if hasattr(listener, "first_connect"): event.listen(self, "first_connect", listener.first_connect) if hasattr(listener, "checkout"): event.listen(self, "checkout", listener.checkout) if hasattr(listener, "checkin"): event.listen(self, "checkin", listener.checkin) def connect(self, dbapi_con, con_record): """Called once for each new DB-API connection or Pool's ``creator()``. dbapi_con A newly connected raw DB-API connection (not a SQLAlchemy ``Connection`` wrapper). con_record The ``_ConnectionRecord`` that persistently manages the connection """ def first_connect(self, dbapi_con, con_record): """Called exactly once for the first DB-API connection. dbapi_con A newly connected raw DB-API connection (not a SQLAlchemy ``Connection`` wrapper). con_record The ``_ConnectionRecord`` that persistently manages the connection """ def checkout(self, dbapi_con, con_record, con_proxy): """Called when a connection is retrieved from the Pool. dbapi_con A raw DB-API connection con_record The ``_ConnectionRecord`` that persistently manages the connection con_proxy The ``_ConnectionFairy`` which manages the connection for the span of the current checkout. If you raise an ``exc.DisconnectionError``, the current connection will be disposed and a fresh connection retrieved. Processing of all checkout listeners will abort and restart using the new connection. """ def checkin(self, dbapi_con, con_record): """Called when a connection returns to the pool. Note that the connection may be closed, and may be None if the connection has been invalidated. ``checkin`` will not be called for detached connections. (They do not return to the pool.) dbapi_con A raw DB-API connection con_record The ``_ConnectionRecord`` that persistently manages the connection """ class ConnectionProxy(object): """Allows interception of statement execution by Connections. .. deprecated:: 0.7 :class:`.ConnectionProxy` is deprecated and will be removed in a future release. Please refer to :func:`.event.listen` in conjunction with the :class:`_events.ConnectionEvents` listener interface. Either or both of the ``execute()`` and ``cursor_execute()`` may be implemented to intercept compiled statement and cursor level executions, e.g.:: class MyProxy(ConnectionProxy): def execute(self, conn, execute, clauseelement, multiparams, params): print "compiled statement:", clauseelement return execute(clauseelement, multiparams, *params) def cursor_execute(self, execute, cursor, statement, parameters, context, executemany): print "raw statement:", statement return execute(cursor, statement, parameters, context) The ``execute`` argument is a function that will fulfill the default execution behavior for the operation. The signature illustrated in the example should be used. The proxy is installed into an :class:`~sqlalchemy.engine.Engine` via the ``proxy`` argument:: e = create_engine('someurl://', proxy=MyProxy()) """ @classmethod def _adapt_listener(cls, self, listener): methods = [ "execute", "cursor_execute", "begin", "rollback", "commit", "savepoint", "rollback_savepoint", "release_savepoint", "begin_twophase", "prepare_twophase", "rollback_twophase", "commit_twophase", ] for meth in methods: me_meth = getattr(ConnectionProxy, meth) ls_meth = getattr(listener, meth) if not util.methods_equivalent(me_meth, ls_meth): util.warn_deprecated( "ConnectionProxy.%s is deprecated. The " "ConnectionProxy class will be removed in a future " "release. Please transition to the @event interface, " "using @event.listens_for(Engine, '%s')." % (meth, meth) ) def adapt_execute(conn, clauseelement, multiparams, params): def execute_wrapper(clauseelement, multiparams, *params): return clauseelement, multiparams, params return listener.execute( conn, execute_wrapper, clauseelement, multiparams, *params ) event.listen(self, "before_execute", adapt_execute) def adapt_cursor_execute( conn, cursor, statement, parameters, context, executemany ): def execute_wrapper(cursor, statement, parameters, context): return statement, parameters return listener.cursor_execute( execute_wrapper, cursor, statement, parameters, context, executemany, ) event.listen(self, "before_cursor_execute", adapt_cursor_execute) def do_nothing_callback(arg, *kw): pass def adapt_listener(fn): def go(conn, arg, *kw): fn(conn, do_nothing_callback, arg, *kw) return util.update_wrapper(go, fn) event.listen(self, "begin", adapt_listener(listener.begin)) event.listen(self, "rollback", adapt_listener(listener.rollback)) event.listen(self, "commit", adapt_listener(listener.commit)) event.listen(self, "savepoint", adapt_listener(listener.savepoint)) event.listen( self, "rollback_savepoint", adapt_listener(listener.rollback_savepoint), ) event.listen( self, "release_savepoint", adapt_listener(listener.release_savepoint), ) event.listen( self, "begin_twophase", adapt_listener(listener.begin_twophase) ) event.listen( self, "prepare_twophase", adapt_listener(listener.prepare_twophase) ) event.listen( self, "rollback_twophase", adapt_listener(listener.rollback_twophase), ) event.listen( self, "commit_twophase", adapt_listener(listener.commit_twophase) ) def execute(self, conn, execute, clauseelement, multiparams, *params): """Intercept high level execute() events.""" return execute(clauseelement, multiparams, **params) def cursor_execute( self, execute, cursor, statement, parameters, context, executemany ): """Intercept low-level cursor execute() events.""" return execute(cursor, statement, parameters, context) def begin(self, conn, begin): """Intercept begin() events.""" return begin() def rollback(self, conn, rollback): """Intercept rollback() events.""" return rollback() def commit(self, conn, commit): """Intercept commit() events.""" return commit() def savepoint(self, conn, savepoint, name=None): """Intercept savepoint() events.""" return savepoint(name=name) def rollback_savepoint(self, conn, rollback_savepoint, name, context): """Intercept rollback_savepoint() events.""" return rollback_savepoint(name, context) def release_savepoint(self, conn, release_savepoint, name, context): """Intercept release_savepoint() events.""" return release_savepoint(name, context) def begin_twophase(self, conn, begin_twophase, xid): """Intercept begin_twophase() events.""" return begin_twophase(xid) def prepare_twophase(self, conn, prepare_twophase, xid): """Intercept prepare_twophase() events.""" return prepare_twophase(xid) def rollback_twophase(self, conn, rollback_twophase, xid, is_prepared): """Intercept rollback_twophase() events.""" return rollback_twophase(xid, is_prepared) def commit_twophase(self, conn, commit_twophase, xid, is_prepared): """Intercept commit_twophase() events.""" return commit_twophase(xid, is_prepared)	12.44 KB	2026-01-20 12:58
📄 log.py # sqlalchemy/log.py # Copyright (C) 2006-2021 the SQLAlchemy authors and contributors # <see AUTHORS file> # Includes alterations by Vinay Sajip vinay_sajip@yahoo.co.uk # # This module is part of SQLAlchemy and is released under # the MIT License: http://www.opensource.org/licenses/mit-license.php """Logging control and utilities. Control of logging for SA can be performed from the regular python logging module. The regular dotted module namespace is used, starting at 'sqlalchemy'. For class-level logging, the class name is appended. The "echo" keyword parameter, available on SQLA :class:`_engine.Engine` and :class:`_pool.Pool` objects, corresponds to a logger specific to that instance only. """ import logging import sys # set initial level to WARN. This so that # log statements don't occur in the absence of explicit # logging being enabled for 'sqlalchemy'. rootlogger = logging.getLogger("sqlalchemy") if rootlogger.level == logging.NOTSET: rootlogger.setLevel(logging.WARN) def _add_default_handler(logger): handler = logging.StreamHandler(sys.stdout) handler.setFormatter( logging.Formatter("%(asctime)s %(levelname)s %(name)s %(message)s") ) logger.addHandler(handler) _logged_classes = set() def class_logger(cls): logger = logging.getLogger(cls.__module__ + "." + cls.__name__) cls._should_log_debug = lambda self: logger.isEnabledFor(logging.DEBUG) cls._should_log_info = lambda self: logger.isEnabledFor(logging.INFO) cls.logger = logger _logged_classes.add(cls) return cls class Identified(object): logging_name = None def _should_log_debug(self): return self.logger.isEnabledFor(logging.DEBUG) def _should_log_info(self): return self.logger.isEnabledFor(logging.INFO) class InstanceLogger(object): """A logger adapter (wrapper) for :class:`.Identified` subclasses. This allows multiple instances (e.g. Engine or Pool instances) to share a logger, but have its verbosity controlled on a per-instance basis. The basic functionality is to return a logging level which is based on an instance's echo setting. Default implementation is: 'debug' -> logging.DEBUG True -> logging.INFO False -> Effective level of underlying logger ( logging.WARNING by default) None -> same as False """ # Map echo settings to logger levels _echo_map = { None: logging.NOTSET, False: logging.NOTSET, True: logging.INFO, "debug": logging.DEBUG, } def __init__(self, echo, name): self.echo = echo self.logger = logging.getLogger(name) # if echo flag is enabled and no handlers, # add a handler to the list if self._echo_map[echo] <= logging.INFO and not self.logger.handlers: _add_default_handler(self.logger) # # Boilerplate convenience methods # def debug(self, msg, args, kwargs): """Delegate a debug call to the underlying logger.""" self.log(logging.DEBUG, msg, args, *kwargs) def info(self, msg, args, *kwargs): """Delegate an info call to the underlying logger.""" self.log(logging.INFO, msg, args, *kwargs) def warning(self, msg, args, *kwargs): """Delegate a warning call to the underlying logger.""" self.log(logging.WARNING, msg, args, *kwargs) warn = warning def error(self, msg, args, *kwargs): """ Delegate an error call to the underlying logger. """ self.log(logging.ERROR, msg, args, *kwargs) def exception(self, msg, args, *kwargs): """Delegate an exception call to the underlying logger.""" kwargs["exc_info"] = 1 self.log(logging.ERROR, msg, args, *kwargs) def critical(self, msg, args, *kwargs): """Delegate a critical call to the underlying logger.""" self.log(logging.CRITICAL, msg, args, *kwargs) def log(self, level, msg, args, kwargs): """Delegate a log call to the underlying logger. The level here is determined by the echo flag as well as that of the underlying logger, and logger._log() is called directly. """ # inline the logic from isEnabledFor(), # getEffectiveLevel(), to avoid overhead. if self.logger.manager.disable >= level: return selected_level = self._echo_map[self.echo] if selected_level == logging.NOTSET: selected_level = self.logger.getEffectiveLevel() if level >= selected_level: self.logger._log(level, msg, args, kwargs) def isEnabledFor(self, level): """Is this logger enabled for level 'level'?""" if self.logger.manager.disable >= level: return False return level >= self.getEffectiveLevel() def getEffectiveLevel(self): """What's the effective level for this logger?""" level = self._echo_map[self.echo] if level == logging.NOTSET: level = self.logger.getEffectiveLevel() return level def instance_logger(instance, echoflag=None): """create a logger for an instance that implements :class:`.Identified`.""" if instance.logging_name: name = "%s.%s.%s" % ( instance.__class__.__module__, instance.__class__.__name__, instance.logging_name, ) else: name = "%s.%s" % ( instance.__class__.__module__, instance.__class__.__name__, ) instance._echo = echoflag if echoflag in (False, None): # if no echo setting or False, return a Logger directly, # avoiding overhead of filtering logger = logging.getLogger(name) else: # if a specified echo flag, return an EchoLogger, # which checks the flag, overrides normal log # levels by calling logger._log() logger = InstanceLogger(echoflag, name) instance.logger = logger class echo_property(object): __doc__ = """\ When ``True``, enable log output for this element. This has the effect of setting the Python logging level for the namespace of this element's class and object reference. A value of boolean ``True`` indicates that the loglevel ``logging.INFO`` will be set for the logger, whereas the string value ``debug`` will set the loglevel to ``logging.DEBUG``. """ def __get__(self, instance, owner): if instance is None: return self else: return instance._echo def __set__(self, instance, value): instance_logger(instance, echoflag=value)	6.55 KB	2026-01-20 12:58
📁 orm	-	2026-03-21 15:45
📁 pool	-	2026-03-21 15:45
📄 processors.py # sqlalchemy/processors.py # Copyright (C) 2010-2021 the SQLAlchemy authors and contributors # <see AUTHORS file> # Copyright (C) 2010 Gaetan de Menten gdementen@gmail.com # # This module is part of SQLAlchemy and is released under # the MIT License: http://www.opensource.org/licenses/mit-license.php """defines generic type conversion functions, as used in bind and result processors. They all share one common characteristic: None is passed through unchanged. """ import codecs import datetime import re from . import util def str_to_datetime_processor_factory(regexp, type_): rmatch = regexp.match # Even on python2.6 datetime.strptime is both slower than this code # and it does not support microseconds. has_named_groups = bool(regexp.groupindex) def process(value): if value is None: return None else: try: m = rmatch(value) except TypeError as err: util.raise_( ValueError( "Couldn't parse %s string '%r' " "- value is not a string." % (type_.__name__, value) ), from_=err, ) if m is None: raise ValueError( "Couldn't parse %s string: " "'%s'" % (type_.__name__, value) ) if has_named_groups: groups = m.groupdict(0) return type_( *dict( list( zip( iter(groups.keys()), list(map(int, iter(groups.values()))), ) ) ) ) else: return type_(list(map(int, m.groups(0)))) return process def py_fallback(): def to_unicode_processor_factory(encoding, errors=None): decoder = codecs.getdecoder(encoding) def process(value): if value is None: return None else: # decoder returns a tuple: (value, len). Simply dropping the # len part is safe: it is done that way in the normal # 'xx'.decode(encoding) code path. return decoder(value, errors)[0] return process def to_conditional_unicode_processor_factory(encoding, errors=None): decoder = codecs.getdecoder(encoding) def process(value): if value is None: return None elif isinstance(value, util.text_type): return value else: # decoder returns a tuple: (value, len). Simply dropping the # len part is safe: it is done that way in the normal # 'xx'.decode(encoding) code path. return decoder(value, errors)[0] return process def to_decimal_processor_factory(target_class, scale): fstring = "%%.%df" % scale def process(value): if value is None: return None else: return target_class(fstring % value) return process def to_float(value): # noqa if value is None: return None else: return float(value) def to_str(value): # noqa if value is None: return None else: return str(value) def int_to_boolean(value): # noqa if value is None: return None else: return bool(value) DATETIME_RE = re.compile( r"(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)(?:\.(\d+))?" ) TIME_RE = re.compile(r"(\d+):(\d+):(\d+)(?:\.(\d+))?") DATE_RE = re.compile(r"(\d+)-(\d+)-(\d+)") str_to_datetime = str_to_datetime_processor_factory( # noqa DATETIME_RE, datetime.datetime ) str_to_time = str_to_datetime_processor_factory( # noqa TIME_RE, datetime.time ) # noqa str_to_date = str_to_datetime_processor_factory( # noqa DATE_RE, datetime.date ) # noqa return locals() try: from sqlalchemy.cprocessors import DecimalResultProcessor # noqa from sqlalchemy.cprocessors import int_to_boolean # noqa from sqlalchemy.cprocessors import str_to_date # noqa from sqlalchemy.cprocessors import str_to_datetime # noqa from sqlalchemy.cprocessors import str_to_time # noqa from sqlalchemy.cprocessors import to_float # noqa from sqlalchemy.cprocessors import to_str # noqa from sqlalchemy.cprocessors import UnicodeResultProcessor # noqa def to_unicode_processor_factory(encoding, errors=None): if errors is not None: return UnicodeResultProcessor(encoding, errors).process else: return UnicodeResultProcessor(encoding).process def to_conditional_unicode_processor_factory(encoding, errors=None): if errors is not None: return UnicodeResultProcessor(encoding, errors).conditional_process else: return UnicodeResultProcessor(encoding).conditional_process def to_decimal_processor_factory(target_class, scale): # Note that the scale argument is not taken into account for integer # values in the C implementation while it is in the Python one. # For example, the Python implementation might return # Decimal('5.00000') whereas the C implementation will # return Decimal('5'). These are equivalent of course. return DecimalResultProcessor(target_class, "%%.%df" % scale).process except ImportError: globals().update(py_fallback())	5.61 KB	2026-01-20 12:58
📄 schema.py # schema.py # Copyright (C) 2005-2021 the SQLAlchemy authors and contributors # <see AUTHORS file> # # This module is part of SQLAlchemy and is released under # the MIT License: http://www.opensource.org/licenses/mit-license.php """Compatibility namespace for sqlalchemy.sql.schema and related. """ from .sql.base import SchemaVisitor # noqa from .sql.ddl import _CreateDropBase # noqa from .sql.ddl import _DDLCompiles # noqa from .sql.ddl import _DropView # noqa from .sql.ddl import AddConstraint # noqa from .sql.ddl import CreateColumn # noqa from .sql.ddl import CreateIndex # noqa from .sql.ddl import CreateSchema # noqa from .sql.ddl import CreateSequence # noqa from .sql.ddl import CreateTable # noqa from .sql.ddl import DDL # noqa from .sql.ddl import DDLBase # noqa from .sql.ddl import DDLElement # noqa from .sql.ddl import DropColumnComment # noqa from .sql.ddl import DropConstraint # noqa from .sql.ddl import DropIndex # noqa from .sql.ddl import DropSchema # noqa from .sql.ddl import DropSequence # noqa from .sql.ddl import DropTable # noqa from .sql.ddl import DropTableComment # noqa from .sql.ddl import SetColumnComment # noqa from .sql.ddl import SetTableComment # noqa from .sql.ddl import sort_tables # noqa from .sql.ddl import sort_tables_and_constraints # noqa from .sql.naming import conv # noqa from .sql.schema import _get_table_key # noqa from .sql.schema import BLANK_SCHEMA # noqa from .sql.schema import CheckConstraint # noqa from .sql.schema import Column # noqa from .sql.schema import ColumnCollectionConstraint # noqa from .sql.schema import ColumnCollectionMixin # noqa from .sql.schema import ColumnDefault # noqa from .sql.schema import Computed # noqa from .sql.schema import Constraint # noqa from .sql.schema import DefaultClause # noqa from .sql.schema import DefaultGenerator # noqa from .sql.schema import FetchedValue # noqa from .sql.schema import ForeignKey # noqa from .sql.schema import ForeignKeyConstraint # noqa from .sql.schema import IdentityOptions # noqa from .sql.schema import Index # noqa from .sql.schema import MetaData # noqa from .sql.schema import PassiveDefault # noqa from .sql.schema import PrimaryKeyConstraint # noqa from .sql.schema import SchemaItem # noqa from .sql.schema import Sequence # noqa from .sql.schema import Table # noqa from .sql.schema import ThreadLocalMetaData # noqa from .sql.schema import UniqueConstraint # noqa	2.41 KB	2026-01-20 12:58
📁 sql	-	2026-03-21 15:45
📁 testing	-	2026-03-21 15:45
📄 types.py # types.py # Copyright (C) 2005-2021 the SQLAlchemy authors and contributors # <see AUTHORS file> # # This module is part of SQLAlchemy and is released under # the MIT License: http://www.opensource.org/licenses/mit-license.php """Compatibility namespace for sqlalchemy.sql.types. """ __all__ = [ "TypeEngine", "TypeDecorator", "UserDefinedType", "INT", "CHAR", "VARCHAR", "NCHAR", "NVARCHAR", "TEXT", "Text", "FLOAT", "NUMERIC", "REAL", "DECIMAL", "TIMESTAMP", "DATETIME", "CLOB", "BLOB", "BINARY", "VARBINARY", "BOOLEAN", "BIGINT", "SMALLINT", "INTEGER", "DATE", "TIME", "String", "Integer", "SmallInteger", "BigInteger", "Numeric", "Float", "DateTime", "Date", "Time", "LargeBinary", "Binary", "Boolean", "Unicode", "Concatenable", "UnicodeText", "PickleType", "Interval", "Enum", "Indexable", "ARRAY", "JSON", ] from .sql.sqltypes import _Binary # noqa from .sql.sqltypes import ARRAY # noqa from .sql.sqltypes import BIGINT # noqa from .sql.sqltypes import BigInteger # noqa from .sql.sqltypes import BINARY # noqa from .sql.sqltypes import Binary # noqa from .sql.sqltypes import BLOB # noqa from .sql.sqltypes import BOOLEAN # noqa from .sql.sqltypes import Boolean # noqa from .sql.sqltypes import CHAR # noqa from .sql.sqltypes import CLOB # noqa from .sql.sqltypes import Concatenable # noqa from .sql.sqltypes import DATE # noqa from .sql.sqltypes import Date # noqa from .sql.sqltypes import DATETIME # noqa from .sql.sqltypes import DateTime # noqa from .sql.sqltypes import DECIMAL # noqa from .sql.sqltypes import Enum # noqa from .sql.sqltypes import FLOAT # noqa from .sql.sqltypes import Float # noqa from .sql.sqltypes import Indexable # noqa from .sql.sqltypes import INT # noqa from .sql.sqltypes import INTEGER # noqa from .sql.sqltypes import Integer # noqa from .sql.sqltypes import Interval # noqa from .sql.sqltypes import JSON # noqa from .sql.sqltypes import LargeBinary # noqa from .sql.sqltypes import MatchType # noqa from .sql.sqltypes import NCHAR # noqa from .sql.sqltypes import NULLTYPE # noqa from .sql.sqltypes import NullType # noqa from .sql.sqltypes import NUMERIC # noqa from .sql.sqltypes import Numeric # noqa from .sql.sqltypes import NVARCHAR # noqa from .sql.sqltypes import PickleType # noqa from .sql.sqltypes import REAL # noqa from .sql.sqltypes import SchemaType # noqa from .sql.sqltypes import SMALLINT # noqa from .sql.sqltypes import SmallInteger # noqa from .sql.sqltypes import String # noqa from .sql.sqltypes import STRINGTYPE # noqa from .sql.sqltypes import TEXT # noqa from .sql.sqltypes import Text # noqa from .sql.sqltypes import TIME # noqa from .sql.sqltypes import Time # noqa from .sql.sqltypes import TIMESTAMP # noqa from .sql.sqltypes import Unicode # noqa from .sql.sqltypes import UnicodeText # noqa from .sql.sqltypes import VARBINARY # noqa from .sql.sqltypes import VARCHAR # noqa from .sql.type_api import adapt_type # noqa from .sql.type_api import to_instance # noqa from .sql.type_api import TypeDecorator # noqa from .sql.type_api import TypeEngine # noqa from .sql.type_api import UserDefinedType # noqa from .sql.type_api import Variant # noqa	3.3 KB	2026-01-20 12:58
📁 util	-	2026-03-21 15:45

Edit File:

Terminal