aitsc/.venv/Lib/site-packages/sqlalchemy/__pycache__/log.cpython-312.pyc

<EFBFBD>
<00><19>h<EFBFBD>"<00>
<01><00>UdZd
dl
mZ
d
dlZd
dlZd
dlmZ
d
dlmZ
d
dlmZ
d
dlm	Z	
d
dlm
Z

d
d	lmZ
d
d
lmZ
ddl
mZ
dd
l
mZ
ddlmZ
er	dZerdn
dZndZd
Zedd<13><14>ZedeedfZej.d<16>
Zej2ej4k(rej7ej8<00>

d"d<17>Ze<1E>Zde d<d#d<1A>Z!d$d<1B>Z"eejFdfZ$Gd<1D>d<13>Z%Gd<1E>d<1C>Z&	d%					d&d<1F>Z'Gd <20>d!<21>Z(y)'a<>
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.

<EFBFBD>)
<01>annotationsN)
<01>Any)
<01>Optional)
<01>overload)
<01>Set)
<01>Type)
<01>TypeVar)
<01>Union<6F>
)
<01>py311)
<01>py38)
<01>LiteralT<6C>F<>_IT<49>
Identified)
<01>bound<6E>debug<75>
sqlalchemyc

<01><><00>t
jtj<00>
}
|
j	t
j
d
<01>
<00>

|j
|
<01>

y)Nz.%(asctime)s %(levelname)s %(name)s %(message)s)<07>logging<6E>
StreamHandler<65>sys<79>stdout<75>setFormatter<65>	Formatter<65>
addHandler)<02>logger<65>handlers  <20>;D:\pythonpj\aitsc\.venv\Lib\site-packages\sqlalchemy/log.py<70>_add_default_handlerr :sC<00><00><15>#<23>#<23>C<EFBFBD>J<EFBFBD>J<EFBFBD>/<2F>G<EFBFBD><0B><18><18><0F><19><19>J<>K<><06><0B><15><15>g<EFBFBD><1E>zSet[Type[Identified]]<5D>_logged_classesc

<01>X<00>t
|d
d<00>x
s
|jdz|jzS)N<>_sqla_logger_namespace<63>
.)<03>getattr<74>
__module__<EFBFBD>__name__)
<01>clss
 r<00>_qual_logger_name_for_clsr*Es.<00><00><0F><03>-<2D>t<EFBFBD>4<>
	/<2F><0E>><3E>><3E>C<EFBFBD><1F>#<23>,<2C>,<2C>.<2E>r!c

<01><><00>
<01>t
jt|<00>
<00>
<00>
<01>
f
d
<01>|_<00>
f
d<02>|_<00>
|_tj|<00>

|S)Nc

<01>B<00>
<01><00>
j
tj<00>
S<00>
N)<03>isEnabledForr<00>DEBUG<55><02>selfrs <20>r<00><lambda>zclass_logger.<locals>.<lambda>Ns<00><><00><16>)<<3C>)<<3C><0F>
<0A>
<0A>*r!c

<01>B<00>
<01><00>
j
tj<00>
Sr-)r.r<00>INFOr0s <20>rr2zclass_logger.<locals>.<lambda>Qs<00><><00><06>(;<3B>(;<3B><0F><0C><0C>)r!)r<00>	getLoggerr*<00>_should_log_debug<75>_should_log_inforr"<00>add)r)rs @r<00>class_loggerr9LsI<00><><00>
<14>
<1E>
<1E>8<><13>=<3D>
><3E>F<EFBFBD><06>C<EFBFBD><19><06>C<EFBFBD><18><18>C<EFBFBD>J<EFBFBD><13><17><17><03><1C><0E>Jr!<00>InstanceLoggerc
<01>D<00>eZ
dZUd
ZdZded<ded<ded<dd	<09>Zdd
<EFBFBD>Zy)r<00>Nz
Optional[str]<5D>logging_name<6D>_IdentifiedLoggerTyper<00>
_EchoFlagType<70>_echoc

<01>T<00>|jjtj<00>
Sr-)rr.rr/<00>
r1s
 rr6zIdentified._should_log_debuges<00><00><13>{<7B>{<7B>'<27>'<27><07>
<0A>
<0A>6<>6r!c

<01>T<00>|jjtj<00>
Sr-)rr.rr4rBs
 rr7zIdentified._should_log_infohs<00><00><13>{<7B>{<7B>'<27>'<27><07><0C><0C>5<>5r!)<02>return<72>bool)r(r'<00>__qualname__<5F>	__slots__r=<00>__annotations__r6r7r<r!rrr\s'<00><00><12>I<EFBFBD>"&<26>L<EFBFBD>-<2D>&<26>!<21>!<21><18><18>
7<>
6r!c
<01><><00>eZ
dZUd
Zej
ej
ejejd<02>Zde	d<dZ
dd<06>Zdd<07>Zdd<08>Z
dd	<09>ZeZdd
<EFBFBD>Zdd<0B>Zdd<0C>Zdd
<0A>Zdd<0E>Zdd<0F>Zy)r:aA 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
    )NFTrr?r@)<02>echorc
<01><><00>|
|_tj|<02>
|_|j|
tj
kr-|jjst|j<00>

yyyr-)rJrr5r<00>	_echo_mapr4<00>handlersr )r1rJ<00>names   r<00>__init__zInstanceLogger.__init__<5F>sS<00><00><18><04>	<09><1D>'<27>'<27><04>-<2D><04><0B><10>><3E>><3E>$<24><1F>7<EFBFBD><<3C><<3C>/<2F><04><0B><0B>8L<38>8L<38> <20><14><1B><1B>-<2D>9M
<01>/r!c
<01>N<00>|jtj|
g|<02>
<01>i|<03>
<01>

y
)z/Delegate a debug call to the underlying logger.N)<03>logrr/<00>r1<00>msg<73>args<67>kwargss    rrzInstanceLogger.debug<75>s"<00><00>	<11><04><08><08><17><1D><1D><03>5<>d<EFBFBD>5<>f<EFBFBD>5r!c
<01>N<00>|jtj|
g|<02>
<01>i|<03>
<01>

y
)z/Delegate an info call to the underlying logger.N)rQrr4rRs    r<00>infozInstanceLogger.info<66>s"<00><00>	<11><04><08><08><17><1C><1C>s<EFBFBD>4<>T<EFBFBD>4<>V<EFBFBD>4r!c
<01>N<00>|jtj|
g|<02>
<01>i|<03>
<01>

y
)z1Delegate a warning call to the underlying logger.N)rQr<00>WARNINGrRs    r<00>warningzInstanceLogger.warning<6E>s"<00><00>	<11><04><08><08><17><1F><1F>#<23>7<><04>7<><06>7r!c
<01>N<00>|jtj|
g|<02>
<01>i|<03>
<01>

y
)zB
        Delegate an error call to the underlying logger.
        N<>rQr<00>ERRORrRs    r<00>errorzInstanceLogger.error<6F>s"<00><00>	<11><04><08><08><17><1D><1D><03>5<>d<EFBFBD>5<>f<EFBFBD>5r!c
<01>X<00>d
|d<|jtj|
g|<02>
<01>i|<03>
<01>

y)z4Delegate an exception call to the underlying logger.r<00>exc_infoNr\rRs    r<00>	exceptionzInstanceLogger.exception<6F>s,<00><00><1F><06>z<EFBFBD><1A><10><04><08><08><17><1D><1D><03>5<>d<EFBFBD>5<>f<EFBFBD>5r!c
<01>N<00>|jtj|
g|<02>
<01>i|<03>
<01>

y
)z2Delegate a critical call to the underlying logger.N)rQr<00>CRITICALrRs    r<00>criticalzInstanceLogger.critical<61>s$<00><00>	<11><04><08><08><17>!<21>!<21>3<EFBFBD>8<><14>8<><16>8r!c
<01>f
<00>|jjj|
k\r
y
|j|j}|t
jk(r|jj<00>}|
|k\rBtr|jdd<03>tz|d<|jj|
||fi|<04>
<01>

y
y
)z<>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.

        N<>
stacklevelr)r<00>manager<65>disablerLrJr<00>NOTSET<45>getEffectiveLevel<65>
STACKLEVEL<EFBFBD>get<65>STACKLEVEL_OFFSET<45>_log)r1<00>levelrSrTrU<00>selected_levels      rrQzInstanceLogger.log<6F>s<><00><00><10>;<3B>;<3B><1E><1E>&<26>&<26>%<25>/<2F><12><1D><1E><1E><04>	<09>	<09>2<><0E><19>W<EFBFBD>^<5E>^<5E>+<2B>!<21>[<5B>[<5B>:<3A>:<3A><<3C>N<EFBFBD><10>N<EFBFBD>"<22><19><1A>J<EFBFBD>J<EFBFBD>|<7C>Q<EFBFBD>/<2F>2C<32>C<><17>|<7C>$<24>
<1D>D<EFBFBD>K<EFBFBD>K<EFBFBD><1C><1C>U<EFBFBD>C<EFBFBD><14>8<><16>8<>
#r!c
<01>p<00>|jjj|
k\r
y
|
|j<00>k\S)z)Is this logger enabled for level 'level'?F)rrgrhrj<00>r1ros  rr.zInstanceLogger.isEnabledFor<6F>s3<00><00><10>;<3B>;<3B><1E><1E>&<26>&<26>%<25>/<2F><18><14><04>.<2E>.<2E>0<>0<>0r!c

<01><><00>|j|j}
|
tjk(r|jj<00>}
|
S)
z+What's the effective level for this logger?)rLrJrrirrjrrs  rrjz InstanceLogger.getEffectiveLevel<65>s9<00><00><15><0E><0E>t<EFBFBD>y<EFBFBD>y<EFBFBD>)<29><05><10>G<EFBFBD>N<EFBFBD>N<EFBFBD>"<22><18>K<EFBFBD>K<EFBFBD>1<>1<>3<>E<EFBFBD><14>r!N)rJr?rN<00>str)rSrtrTrrUrrD<00>None)
ro<00>intrSrtrTrrUrrDru)rorvrDrE)rDrv)r(r'rF<00>__doc__rrir4r/rLrHrGrOrrWrZ<00>warnr^rardrQr.rjr<r!rr:r:lsr<00><00><08>(<16>n<EFBFBD>n<EFBFBD><16>~<7E>~<7E><15>l<EFBFBD>l<EFBFBD><18><1D><1D>	<06>I<EFBFBD><19><18>"<22>I<EFBFBD>.<2E>6<>
5<>
8<>
<13>D<EFBFBD>6<>6<>9<>
9<>61<>r!c
<01>
<00>|jr%t|j<00>
<00>
d
|j<00>
<01>}nt|j<00>
}|
|_|
dvrt	j
|<02>
}||_yt
|
|<02>}||_y)zEcreate a logger for an instance that implements :class:`.Identified`.r%)FNN)r=r*<00>	__class__r@rr5r:r)<04>instance<63>echoflagrNrs    r<00>instance_loggerr}<00>s~<00><00>
<10><1C><1C>%<25>h<EFBFBD>&8<>&8<>9<><14>!<21>!<21>
<EFBFBD><04>
)<29><18>);<3B>);<3B><<3C><04><1D>H<EFBFBD>N<EFBFBD><10>=<3D> <20><19>"<22>"<22>4<EFBFBD>(<28><06><1D>H<EFBFBD>O<EFBFBD> <20><08>$<24>/<2F><06><1C>H<EFBFBD>Or!c
<01>h<00>eZ
dZd
Ze						dd<02><04>Ze						dd<03><04>Z						d	d<04>Zd
d<05>Zy)<0B>
echo_propertya}
    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``.
    c
<01><00>yr-r<<00>r1r{<00>owners   r<00>__get__zecho_property.__get__

<00><00><00>r!c
<01><00>yr-r<r<>s   rr<>zecho_property.__get__
r<>r!c

<01>"<00>|
<01>|S|
jSr-)
r@r<>s   rr<>zecho_property.__get__
s<00><00><14><1B><17>K<EFBFBD><1B>><3E>><3E>!r!c
<01><00>t
|
|<02>
<01>
y)N)
r|)
r})r1r{<00>values   r<00>__set__zecho_property.__set__
s<00><00><17><08>5<EFBFBD>1r!N)r{z
Literal[None]r<><00>Type[Identified]rDr)r{rr<>r<>rDr?)r{zOptional[Identified]r<>r<>rDz#Union[echo_property, _EchoFlagType])r{rr<>r?rDru)r(r'rFrwrr<>r<>r<r!rrr
s<><00><00><08>G<EFBFBD><0E><1C>%<25><1C>.><3E><1C>	<16><1C><0E><1C><0E><1C>"<22><1C>+;<3B><1C>	<16><1C><0E><1C>"<22>,<2C>"<22>5E<35>"<22>	,<2C>"<22>
2r!r)rzlogging.LoggerrDru)r)r<>rDrt)r)<00>	Type[_IT]rDr<>r-)r{rr|r?rDru))rw<00>
__future__rrr<00>typingrrrrrr	r
<00>utilrr
<00>util.typingrrkrmrrEr?r5<00>
rootloggerrori<00>setLevel<65>WARNr <00>setr"rHr*r9<00>Loggerr>rr:r}rr<r!r<00><module>r<>
s&
<00>


<01>

<04>
#<23><0E>
<EFBFBD><16><1B><1B><16><17><1A><18><17><16> <20><08><15>J<EFBFBD>#<23>
<01>
<01><15><16>J<EFBFBD><19><15>
<0A>e<EFBFBD><<3C>(<28><03><15>d<EFBFBD>D<EFBFBD>'<27>'<27>"2<>2<>3<>
<0A>
<1F>W<EFBFBD>
<1E>
<1E>|<7C>
,<2C>
<EFBFBD>
<0A><13><13>w<EFBFBD>~<7E>~<7E>%<25><0E><17><17><07><0C><0C>%<25>
<1F>*-<2D><15><0F>&<26>.<2E>
<06>

<0F><1E>g<EFBFBD>n<EFBFBD>n<EFBFBD>.><3E>><3E>?<3F><15>

6<>

6<> u

<15>u

<15>r59<35>
<1D><18>
<1D>$1<>
<1D>	<09>
<1D><
2<>
2r!