rj7ddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z d d l m Z d d l m Z d d l mZd d lmZd dlmZddl mZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZe rd dlmZd dlmZd dl m!Z!d dl"m#Z#ddlm$Z$Gddee Z%Gd d!ee&d"fZ'ed#ee&d$fd%ee&d$f&Z(ed'ee&d(fd%ee&d(f&Z)ed)ee&d"fd%ee&d"f&Z*ed*e'+Z+ed,e'd%-Z,Gd.d/eeeZ-ej\d0 d5d1Z/ej\d0 d6d2Z0d7d3Z1y4)8) annotations)Any)Generic)Literal)NoReturn)overload)Protocol) TYPE_CHECKING)sqltypes)_T)_Ts)_NoArg)ReadOnlyColumnCollection)util) ArgumentErrorInvalidRequestError) dunders_re)typing)Never)Self)TypeVar)Unpack) ColumnClause)KeyedColumnElement)Column) TypeEngine)_AnnotationScanTypecpeZdZUdZdZded<er&ed dZe d dZed dZd dZy y )NamedzA named descriptor that is interpreted by SQLAlchemy in various ways. .. seealso:: :class:`_schema.TypedColumns` Define table columns using this descriptor. .. versionadded:: 2.1.0b2 strkeycyNr#selfinstanceowners i/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/sqlalchemy/sql/_annotated_cols.py__get__z Named.__get__:s@Ccyr'r#r(s r,r-z Named.__get__=sr.cyr'r#r(s r,r-z Named.__get__As>Ar.cyr'r#r(s r,r-z Named.__get__Dsr.N)r*Noner+rreturnr)r* TypedColumnsr+rr3z Column[_T])r*rr+rr3r)r*z object | Noner+rr3r) __name__ __module__ __qualname____doc__ __slots____annotations__r rr-r#r.r,r"r"(shI H C C  ( 14      A AJr.r"c(eZdZdZdZesddZddZy)r4aClass that generally represent the typed columns of a :class:`.Table`, but can be used with most :class:`_sql.FromClause` subclasses with the :meth:`_sql.FromClause.with_cols` method. This is a "typing only" class that is never instantiated at runtime: the type checker will think that this class is exposed as the ``table.c`` attribute, but in reality a normal :class:`_schema.ColumnCollection` is used at runtime. Subclasses should just list the columns as class attributes, without specifying method or other non column members. To resolve the columns, a simplified version of the ORM logic is used, in particular, columns can be declared by: * directly instantiating :class:`_schema.Column`, to declare constraint, custom SQL types and additional column options. The annotation is usually inferred by type checkers from the column instance; * using only a :class:`.Named` or :class:`_schema.Column` type annotation, where nullability and SQL type will be inferred by the python type provided. Type inference is available for a common subset of python types. * a mix of both, where the instance can be used to declare constraints and other column options while the annotation will be used to set the SQL type and nullability if not provided by the instance. The information provided in the instance will take precedence over the annotation when they are conflicting, for example if setting nullable=True with an annotation tha does not include ``None``. In all cases the name is inferred from the attribute name, unless explicitly provided. .. note:: The generated table will create a copy of any column instance assigned as attributes of this class, so columns should be accessed only via the ``table.c`` collection, not using this class directly. Example of the inference behavior:: from sqlalchemy import Column, Integer, Named, String, TypedColumns class tbl_cols(TypedColumns): # the name will be set to ``id``, type is inferred as Column[int] # from the Integer SQL type. id = Column(Integer, primary_key=True) # not null String column is generated name: Named[str] # nullable Double column is generated weight: Named[float | None] # nullable Integer column, with SQL name 'user_age' age: Named[int | None] = Column("user_age") # not null column with type String(42) middle_name: Named[str] = Column(String(42)) Mixins and subclasses are also supported:: class with_id(TypedColumns): id = Column(Integer, primary_key=True) class named_cols(TypedColumns): name: Named[str] description: Named[str | None] class product_cols(named_cols, with_id): ean: Named[str] = Column(unique=True) product = Table("product", metadata, product_cols) class office_cols(named_cols, with_id): address: Named[str] office = Table("office", metadata, office_cols) The positional types returned when selecting the table can be optionally declared by specifying a :attr:`.HasRowPos.__row_pos__` annotation:: from sqlalchemy import select class some_cols(TypedColumns): id = Column(Integer, primary_key=True) name: Named[str] weight: Named[float | None] __row_pos__: tuple[int, str, float | None] some_table = Table("st", metadata, some_cols) # both will be typed as Select[int, str, float | None] stmt1 = some_table.select() stmt2 = select(some_table) .. seealso:: :class:`.Table` for usage details on how to use this class to create a table instance. :meth:`_sql.FromClause.with_cols` to apply a :class:`.TypedColumns` to a from clause. .. versionadded:: 2.1.0b2 r#ctd)Nz)Cannot instantiate a TypedColumns object.r)clsargskwargss r,__new__zTypedColumns.__new__s%; r.c|jjDchc]'\}}tj|s t |r|)}}}|rt dt |ycc}}w)Nz6TypedColumns subclasses may not define methods. Found )__dict__itemsrmatchcallablersorted)r=namevaluemethodss r,__init_subclass__zTypedColumns.__init_subclass__sv #||113 e##D)huo   %)+    s,A'N)r>rr?rr3r)r3r2)r5r6r7r8r9r r@rJr#r.r,r4r4HsrhI   r.r4z Column[Any] _KeyColCC_cozKeyedColumnElement[Any]T)bound covariantdefault_ColClauseCC_cozColumnClause[Any] _ColCC_co_TC)rL_TC_co)rLrMceZdZUdZded<y) HasRowPoszProtocol for a :class:`_schema.TypedColumns` used to indicate the positional types will be returned when selecting the table. .. versionadded:: 2.1.0b2 ztuple[Unpack[_Ts]] __row_pos__N)r5r6r7r8r:r#r.r,rTrTs $#r.rTzsqlalchemy.sql.schemac i}tjjj}tjjj}|j dddD]}|t j vrtj|}t|}tjt|t|Dcgc]:}tj|s#||j||j|f<}}|D]h\} } } | | Jt|| |j| } | t j"urt%d| d|j&d| dt)| } | "t%d| d| d|j&d| d || | t+j,|  || <t/| |r| j0D]A}|j2|j2j4't7d |j&d| d | j9}|j:|j<k(r|j:| k7r| |_|j<| |_|j>} d}t j"}| Jt|| |j| } | t j"ur t)| }t+j,| }| j@r=|(|j0st%d |j&d| d ||jC||t j"ur!|jD|ur|jFs||_$||| <Dt%d|j&d| dt?| t|jKScc}w)Nz7No type information could be extracted from annotation  for attribute '.'z#Could not find a SQL type for type z obtained from annotation z in attribute ')nullablezColumn 'z' with foreign key to non-table-bound columns is not supported when using a TypedColumns. If possible use the qualified string name the columnz4Python typing annotation is required for attribute 'zG' when primary argument(s) for Column construct are None or not presentz Unexpected value for attribute 'z'. Expected a Column, not: )&r preloaded sql_schemarNULL_UNSPECIFIED__mro__r4get_annotationsvarsmerge_lists_w_orderinglistrrDget_collect_annotationr6rNO_ARGrr5 _get_sqltype sa_typing includes_none isinstance foreign_keys _table_columntabler_copyr%rGtype_isnull _set_type_user_defined_nullable primary_keyr[values)table_columns_clscolumnsrr^basecls_annotationscls_varsnrCrGobj annotationextracted_typesqltypefkcol anno_sqltyper[s r,_extract_columns_from_classrs')G ^^ & & - -F~~00AA!))$B$/a <'' ' ..t4:00X_ 5 ##A&  Q!4!4Q!7 8  &+R  !D#z{!---!4%tT__j""V]]2'&&0\2 MM?!D64 '~6?'=n=MN44><@&&*mm_AdV1> !'&44^D! C(** B((4,,22:1&t}}oQtf=?? iik77chh&377d?"CG88##CH((# :@--)%8)4*&N&V]]:'3N'C #,#:#:>#J??#+C4D4D+**.--$@22 &1 l3FMM1226FFOO#+CL # #6t}}oQtfM115c =_R aH  !!{ s>?N c Ftjjj}|td} t j ||||}t j|s2t|tr"t||tfrtjSt j ||tfstd|d|jd|dt#|j$dk(sJ|j$d S#t$r%}td|d|jd|d|d}~wwxYw) N)rr"zCould not interpret annotation rXrYrZz Annotation z"' is not of type Named/Column[...]r r)rr\r]rr"rhde_stringify_annotation Exceptionrr5 is_genericrjro issubclassrrfis_origin_of_clslen__args__)r=rGmoduleraw_annotationr_localsr|es r,reregs.^^ & & - -F%0G66     , z4 ( zFE? 3}}  ' ' VUO D.)* ~Qtf$F H  :&&'1,,,""1%%) -n-=>,,qa 1  sC22 D ; DD ctj|}tj|}|!|jstj |Syr')rhde_optionalize_union_typesr _type_map_getrp to_instance)r|our_typesql_types r,rgrgsF33J?H%%h/HH$4$4##H--r.N)ruztype[TypedColumns]r3zlist[Column[Any]]) r=z type[Any]rGr$rr$rr r3z,_AnnotationScanType | Literal[_NoArg.NO_ARG])r|r r3zTypeEngine[Any] | None)2 __future__rrrrrrrr r r _typingr rrwrrrexcrrrrh util.typingrrrrelementsrrschemartype_apirr r"r$r4rKrOrPrQrRrTpreload_modulerrergr#r.r,rs# *%&! &,$1KGBKK@H+C,>?HV "3(A#A B $S*C%C D   "3(;#; < $S*=%= >   "3 #5 6 $S-%7 8   e<(  > % ,-l")l"l".l"^,-& &&'*&