mBNj UdZddlmZddlZddlZddlZ ddl Z ddl Z ddlmZddlmZej(r ddlZddlZnddlmZmZ ddlmZgd Z!e"Z#Gd d Z$Gd d e%eZ&e&ejNdzZ(Gdde%eZ)e)ejNdzZ*ejNe)jVe)jXe)jZe)j\ddddfZ/ejNe)j`e)jbddfZ2d8dZ3d8dZ4d8dZ5eeZ6nee4Z6ne5Z6d9dZ7iZ8de9d<GddejtZ;Gd d!e;ejtZ<Gd"d#e<Z=Gd$d%e<Z>Gd&d'e;ejtZ?d(Z@d)ZAGd*d+e?ZBd,ZCd-ZDGd.d/e?ZEd0ZFd1ZGGd2d3e?ZHd4ZId5ZJGd6d7e?ZKy#e $rdZYxwxYw):z*Vector type to be exchanged with the DBMS.) annotationsN)Enum)_typing)nppa) swap_endian)Vector VectorDType VectorEndianceZdZUdZdZded<ej d"dZej d#dZejdd d$d Zejd%d Zejd&d Zd'd Ze e j d(d Z ddd)dZ dd d*dZed+dZd,dZd-dZd-dZedd d.dZdd d/dZeej d0dZeej d1dZe d2dZ d3dZd4dZed5dZd6dZd%dZed7dZd8dZd&d Zy!)9r a A class representing a Neo4j vector. The constructor accepts various types of data to create a vector. Depending on ``data``'s type, further arguments may be required/allowed. Examples of valid invocations are:: Vector([1, 2, 3], "i8") Vector(b"\x00\x01\x00\x02", VectorDType.I16) Vector(b"\x01\x00\x02\x00", "i16", byteorder="little") Vector(numpy.array([1, 2, 3])) Vector(pyarrow.array([1, 2, 3])) Internally, a vector is stored as a contiguous block of memory (:class:`bytes`), containing homogeneous values encoded in big-endian order. Support for this feature requires a DBMS supporting Bolt version 6.0 or later. :param data: The data from which the vector will be constructed. The constructor accepts the following types: * ``Iterable[float]``, ``Iterable[int]`` (but not ``bytes`` or ``bytearray``): Use an iterable of floats or an iterable of ints to construct the vector from native Python values. The ``dtype`` parameter is required. See also: :meth:`.from_native`. * ``bytes``, ``bytearray``: Use raw bytes to construct the vector. The ``dtype`` parameter is required and ``byteorder`` is optional. * ``numpy.ndarray``: Use a numpy array to construct the vector. No further parameters are accepted. See also: :meth:`.from_numpy`. * ``pyarrow.Array``: Use a pyarrow array to construct the vector. No further parameters are accepted. See also: :meth:`.from_pyarrow`. :param dtype: The type of the vector. See :class:`.VectorDType` for currently supported inner data types. See also :attr:`.dtype`. This parameter is required if ``data`` is of type :class:`bytes`, :class:`bytearray`, ``Iterable[float]``, or ``Iterable[int]``. Otherwise, it must be omitted. :param byteorder: The endianness of the input data (default: ``"big"``). If ``"little"`` is given, ``neo4j-rust-ext`` or ``numpy`` is used to speed up the internal byte flipping (if either package is installed). Use :data:`sys.byteorder` if you want to use the system's native endianness. This parameter is optional if ``data`` is of type ``bytes`` or ``bytearray``. Otherwise, it must be omitted. :raises ValueError: Depending on the type of ``data``: * ``Iterable[float]``, ``Iterable[int]`` (excluding byte types): * If the dtype is not supported. * ``bytes``, ``bytearray``: * If the dtype is not supported or data's size is not a multiple of dtype's size. * If byteorder is not one of ``"big"`` or ``"little"``. * ``numpy.ndarray``: * If the dtype is not supported. * If the array is not one-dimensional. * ``pyarrow.Array``: * If the array's type is not supported. * If the array contains null values. :raises TypeError: Depending on the type of ``data``: * ``Iterable[float]``, ``Iterable[int]`` (excluding byte types): * If data's elements don't match the expected type depending on dtype. :raises OverflowError: Depending on the type of ``data``: * ``Iterable[float]``, ``Iterable[int]`` (excluding byte types): * If the value is out of range for the given type. .. versionadded: 6.0 ) __weakref___inner _InnerVectorrcyNselfdatadtypes ]/Users/ahmed/devFolder/Ultron/claude-voice/.venv/lib/python3.12/site-packages/neo4j/vector.py__init__zVector.__init__ cyrrrs rrzVector.__init__rrbig byteordercyrrrrrrs rrzVector.__init__srcyrrrrs rrzVector.__init__s69rcyrrr#s rrzVector.__init__s47rct|ttfrG|j|j|||5|jt|g|i|dddyt Xt|t j r>|j|j|||5|j|g|i|dddytXt|tjr>|j|j|||5|j|g|i|dddy|j|j|||5|j|g|i|dddy#1swYyxYw#1swYyxYw#1swYyxYw#1swYyxYwr) isinstancebytes bytearray_checked_init_overload _set_bytes_npndarray _set_numpy_paArray _set_pyarrow _set_native)rrargskwargss rrzVector.__init__so dUI. /,,tV d =d=f=_D#++!>,,tV 6t6v6_D#))!<,,!!4v"!!$888 ,,  $f!  777   s/ EE$:E08E<E!$E-0E9<Fc#dK dy#t$rtj|} |j|g|i|#t$ra}t |j }|dk(rt |j }n|dt |j }td|d|dd}~wwxYwwxYww)Nbuiltins.z>Invalid arguments for Vector initialization with data of type z: ) TypeError_inspect signaturebindtype __module__ __qualname__)setterrr2r3r9 bind_errortype_name_module type_names rr)zVector._checked_init_overloads    **62I  t5d5f5  #':#8#8 #z1 $T 7 7I#3"4Ad4j6M6M5N OI$$-;b >   s:B0 B0B-?B- B)AB$$B))B--B0c|xdk(r|jjSdk(r|jjS td|d)a Get the raw bytes of the vector. The data is a continuous block of memory, containing an array of the vector's data type. The data is stored in big-endian order. Pass another byte-order to this method to get the converted data. :param byteorder: The endianness the data should be returned in. If the data's byte-order needs flipping, this method tries to use ``neo4j-rust-ext`` or ``numpy``, if installed, to speed up the process. Use :data:`sys.byteorder` if you want to use the system's native endianness. :returns: The raw bytes of the vector. :raises ValueError: If byteorder is not one of ``"big"`` or ``"little"``. rlittleInvalid byteorder: . Must be 'big' or 'little'.rrdata_le ValueError)rrs rrawz Vector.rawsN&{{'''{{*** ))711rc|xdk(r||j_ydk(r||j_y td|d)a Set the raw bytes of the vector. :param data: The new raw bytes of the vector. :param byteorder: The endianness of ``data``. The data will always be stored in big-endian order. If passed-in byte-order needs flipping, this method tries to use ``neo4j-rust-ext`` or ``numpy``, if installed, to speed up the process. Use :data:`sys.byteorder` if you want to use the system's native endianness. :raises ValueError: * If data's size is not a multiple of dtype's size. * If byteorder is not one of ``"big"`` or ``"little"``. :raises TypeError: If the data is not of type bytes. rrCrDrENrF)rrrs rset_rawzVector.set_rawsF.#'  &* # ))711rc.|jjS)zX Get the type of the vector. :returns: The type of the vector. )rrrs rrz Vector.dtype#s{{   rc,t|jS)zt Get the number of elements in the vector. :returns: The number of elements in the vector. )lenrrMs r__len__zVector.__len__,s 4;;rc,t|jSr)strrrMs r__str__zVector.__str__4s4;;rc|jjd|jd|jjdS)N(, )) __class____name__rIrvaluerMs r__repr__zVector.__repr__7s9~~&&'qb9I9I8LA N rcP|j|}|j||||S)a Create a Vector instance from raw bytes. :param data: The raw bytes to create the vector from. :param dtype: The type of the vector. See also :attr:`.dtype`. :param byteorder: The endianness of the data. If ``"little"``, the bytes in data will be flipped to big-endian. If installed, ``neo4j-rust-ext`` or ``numpy`` will be used to speed up the byte flipping. Use :data:`sys.byteorder` if you want to use the system's native endianness. :raises ValueError: * If data's size is not a multiple of dtype's size. * If byteorder is not one of ``"big"`` or ``"little"``. :raises TypeError: If the data is not of type bytes. r)__new__r*)clsrrrobjs r from_byteszVector.from_bytes<s)4kk# tUi8 rc4t||||_y)Nr) _get_typerr!s rr*zVector._set_bytesZs'i&tyA rcyrrr^rrs r from_nativezVector.from_nativedrcyrrrds rrezVector.from_nativejrfrcL|j|}|j|||S)a` Create a Vector instance from an iterable of values. :param data: The list, tuple, or other iterable of values to create the vector from. :param dtype: The type of the vector. See also :attr:`.dtype`. ``data`` must contain values that match the expected type given by ``dtype``: * ``dtype == "f32"``: :class:`float` * ``dtype == "f64"``: :class:`float` * ``dtype == "i8"``: :class:`int` * ``dtype == "i16"``: :class:`int` * ``dtype == "i32"``: :class:`int` * ``dtype == "i64"``: :class:`int` :raises ValueError: If the dtype is not supported. :raises TypeError: If data's elements don't match the expected type depending on dtype. :raises OverflowError: If the value is out of range for the given type. )r]r1)r^rrr_s rrezVector.from_nativeps%<kk# e$ rcBt|j||_yr)rbrerrs rr1zVector._set_natives  &2248 rc6|jjS)a Convert the vector to a native Python list. The type of the elements in the list depends on the dtype of the vector. See :meth:`Vector.from_native` for details. :returns: A list of values representing the vector. )r to_nativerMs rrkzVector.to_natives{{$$&&rcJ|j|}|j||S)af Create a Vector instance from a numpy array. :param data: The numpy array to create the vector from. The array must be one-dimensional and have a dtype that is supported by Neo4j vectors: ``float64``, ``float32``, ``int64``, ``int32``, ``int16``, or ``int8``. See also :class:`.VectorDType`. :raises ValueError: * If the dtype is not supported. * If the array is not one-dimensional. :raises ImportError: If numpy is not installed. :returns: A Vector instance constructed from the numpy array. )r]r-r^rr_s r from_numpyzVector.from_numpys#$kk# t rc6|jjS)a  Convert the vector to a numpy array. The array's dtype depends on the dtype of the vector. However, it will always be in big-endian order. :returns: A numpy array representing the vector. :raises ImportError: If numpy is not installed. )rto_numpyrMs rrpzVector.to_numpys{{##%%rcl|jdk7r td|jjxdk(rt}nbxdk(rt }nUxdk(rt }nHxdk(rt}n;xdk(rt}n.dk(rt}n# td |jj|j||_ y) NrzData must be one-dimensionalfloat64float32int64int32int16int8zUnsupported numpy dtype: ) ndimrHrname_VecF64_VecF32_VecI64_VecI32_VecI16_VecI8rnr)rrtype_s rr-zVector._set_numpys 99>;< <jjoo #z_t.Callable[..., None]r2tupler3zdict[str, _t.Any]rz_t.Generator[None, None, None])rrrr'rr'rrrr)rr rintrrR)rr'rrrrr_t.Self)rr'rrrrrr)rrrrrr)rrrrrr)r%_t.Iterable[float] | _t.Iterable[int]rrrr)rrrrrrrz list[object]rrrrrrrrrrrr) rYr<r=__doc__ __slots____annotations___toverloadr staticmethod _contextlibcontextmanagerr)rIrKpropertyrrPrSr[ classmethodr`r*rer1rkrnrpr-rrr0rrrr r ?sM^*I [[ #  [[!  [[&+  #  [[99[[778,&"  (  06;F&+   #   D!!   &+  #  F&+ BBB # B B[[%.A [[#,= 3  B9399  9 '* &-*,(rr ceZdZdZdZdZy)r a Data endianness (i.e., byte order) of the elements in a :class:`Vector`. Inherits from :class:`str` and :class:`enum.Enum`. Every driver API accepting a :class:`.VectorEndian` value will also accept a string:: >>> VectorEndian.BIG == "big" True >>> VectorEndian.LITTLE == "little" True .. seealso:: :attr:`Vector.raw` .. versionadded:: 6.0 rrCN)rYr<r=rBIGLITTLErrrr r s" C Frr )rrCc(eZdZdZdZdZdZdZdZdZ y) r a The data type of the elements in a :class:`Vector`. Currently supported types are: * ``f32``: 32-bit floating point number (single) * ``f64``: 64-bit floating point number (double) * ``i8``: 8-bit integer * ``i16``: 16-bit integer * ``i32``: 32-bit integer * ``i64``: 64-bit integer Inherits from :class:`str` and :class:`enum.Enum`. Every driver API accepting a :class:`.VectorDType` value will also accept a string:: >>> VectorDType.F32 == "f32" True >>> VectorDType.I8 == "i8" True .. seealso:: :attr:`Vector.dtype` .. versionadded:: 6.0 f32f64i8i16i32i64N) rYr<r=rF32F64I8I16I32I64rrrr r 2s'4 C C B C C Crr )rrrrrrrrrrrrc|dk(r|S|dvrtd|t||zdk7rtdt|d|t||S)z&Swap from big endian to little endian.r>Unsupported type size: r Data length  is not a multiple of )rHrO_swap_endian_unchecked) type_sizers r _swap_endianrgskA~  !29+>?? 4y9!3t9+%;I; G   ")T 22rc,|xdk(rtjd}nExdk(rtjd}n)dk(rtjd}n td|tj||j j S) Nrz>$e , 5 5 7 ? ? AArc|xdk(rd}nxdk(rd}ndk(rd}n td|t||z}d||}d ||}tj|gtj||S) Nrhrirqr><)rHrO_structpackunpack)rrfmtcountfmt_befmt_les r_swap_endian_unchecked_pyrs  C C C 6ykBC C I "Eu Fu F << >!= >>rc&t|tr:|tjj vrt d|dt|}t|tst dt|d|tvrt d|dt|S)NzUnsupported vector type: r6z#Expected a VectorDType or str, got ) r&rRr __members__valuesrHr7r;_TYPESrs rrbrbs%  //668 88 CD DE" e[ )=d5k]!LMM F4UIQ?@@ %=rz%dict[VectorDType, type[_InnerVector]]rceZdZUdZded<ded<ded<ded <d ed <d d  dfdZeddZejd dZeddZ e jd dZ d!fd Z d"dZ d#dZ e jd#dZd#dZee jd$dZe jd%dZed&dZe jd'dZed(dZe jd)dZxZS)*r)_data_data_lez_t.ClassVar[VectorDType]rz_t.ClassVar[int]sizez_t.ClassVar[str]cypher_inner_type_reprr'rz bytes | Nonerrrct||jtk(r t d|xdk(r||_d|_ydk(r#t|j||_||_y td|d)Nz-Cannot instantiate abstract class InnerVectorrrCrDrE) superrrXrr7rrrrrH)rrrrXs rrz_InnerVector.__init__sy  >>\ )KL L  $ (D9 $  ))711rc|jSr)rrMs rrz_InnerVector.datas zzrct|ts tdt||jzdk(s$t dt|d|j||_y)NzData must be of type bytesrrr)r&r'r7rOrrHrr#s rrz_InnerVector.datas\$&89 94y499$)s4yk)? {K  rc||j%t|j|j|_|jSr)rrrrrMs rrGz_InnerVector.data_les, == (DII>DM}}rcHt|j||_||_yr)rrrrr#s rrGz_InnerVector.data_les D1  rct|tj|jvryt |dd}t |tstd|jdt t |ddtstd|jd|jdvr%td|jd|j|tvrtd|jd|d |t|<y) NrzClass z) must have a VectorDType attribute'dtype'rz! must have a str attribute 'size'>rrrrz has an unhandled size z has a duplicate type '')r__init_subclass___abcABC __bases__getattrr&r r7rYrrrHr)r^rrXs rrz_InnerVector.__init_subclass__s !# 88s}} $ Wd+%-' '#vt4c:&GH  88< '&=chhZH  F?&=eWAF u rcFt|j|jzSr)rOrrrMs rrPz_InnerVector.__len__s499~**rcht|}|j}|j}d|d|d|dS)Nzvector(rVrW)rOr_cypher_values_repr)rr type_repr values_reprs rrSz_InnerVector.__str__s?4y// ..0  RvR {!<>**1TYYM++rcyrrr^rs rrez_InnerVector.from_nativesCFrcyrrrMs rrkz_InnerVector.to_native s),rc|jjdk(s,|jjdk(r#tjdk(r|j}||j S)Nr=rC)rr_sysrrrs rrnz_InnerVector.from_numpysM ::  3 & JJ C 'DNNh,F==?D4<<>""rcyrrrMs rrpz_InnerVector.to_numpy'*rc|jj}|j|k(sJtjj |dj r td|j\}}||j|z|jt|z|z}|t|tjS)N only_null)modez/PyArrow array must not contain any null values.r)r; byte_widthrr.computeras_pyrHbuffersoffsetrOr'rr)r^rwidth_buffers rrz_InnerVector.from_pyarrows $$xx5   ;;  T  4 : : <NO OLLN 6 KK% 4;;T#:e"C 5=DNN;;rcyrrrMs rrz_InnerVector.to_pyarrow&rrr)rr')rr'rrrrrrz_t.Iterable[object]rrrrrrr)rYr<r=rrrrrr>rGrrPrSrabstractmethodrr[rrerkrnrprr __classcell__)rXs@rrrsL%I ## ,, L?D,; & [[  ^^4+=  --, FF ,,## ** < < **rrceZdZdZddZy)_InnerVectorFloatrcxt|j}|jddjddS)NnanNaNinfInfinity)rRrkreplace)rress rrz%_InnerVectorFloat._cypher_values_repr-s1$.."#{{5%(00 CCrNrrYr<r=rrrrrr r *s IDrr cZeZdZdZej ZdZdZe d dZ d dZ d dZ d dZ y) rzrrzFLOAT NOT NULLc4t|tjs t|}t d|Ds9|D]4}t|t rt dt|jd|tjdt|dg|S)Nc3<K|]}t|tywrr&float.0items r z&_VecF64.from_native..=f8rnumpyrrrrr-s rrpz_VecF64.to_numpyJ( U1CDDrcddl}|j|j}|jj |j t |d|gdSNr)r py_bufferrGr/ from_buffersrrrOrrrs rrz_VecF64.to_pyarrowOH""4<<0}})) OO s4y4.!  rNr rrr)rYr<r=rr rrrrrrerkrprrrrrzrz2s=I OOE D- : :>E  rrzcZeZdZdZej ZdZdZe d dZ d dZ d dZ d dZ y) r{rrzFLOAT32 NOT NULLct|tjs t|}t d|Ds9|D]4}t|t rt dt|jd tjdt|dg|}||S#t$r=|D]6} tjd|#t$rtd|ddwxYwwxYw) Nc3<K|]}t|tywrrrs rrz&_VecF32.from_native..crr zCannot build f32 vector from r!rfz>fValue z9 is out of range for f32: [-3.4028234e+38, 3.4028234e+38]) r&rr#rr$rr7r;rYrrrO OverflowError)r^rrbytes_s rrez_VecF32.from_native_s$);Df4rr,r.s rrpz_VecF32.to_numpy|r/rcddl}|j|j}|jj |j t |d|gdSr1)rr2rGr/r3rsrOr4s rrz_VecF32.to_pyarrowr5rNr rrr)rYr<r=rr rrrrrrerkrprrrrr{r{Xs=I OOE D/0>E  rr{ceZdZdZddZy)_InnerVectorIntrc4t|jSr)rRrkrMs rrz#_InnerVectorInt._cypher_values_reprs4>>#$$rNrrrrrrArAs I%rrAllcZeZdZdZej ZdZdZe d dZ d dZ d dZ d dZ y) r|rrzINTEGER NOT NULLc t|tjs t|} t j dt |dg|}||S#tj$ro|D]h}t|ts#tdt|jddt|cxkr tkrJntd|dtdtddwxYw) NrrzCannot build i64 vector from , expected int.r:z is out of range for i64: [rV])r&rr#rrrrOerrorrr7r;rY_I64_MIN_I64_MAXr;r^rr<rs rrez_VecI64.from_native$);D \\Ac$i["2:T:F6{}} !$,#7T 8K8K7LM((   4383' '$:Rz4    #AAC1#Ccdt|j|jzd}tt j ||jS)Nrrr&r(s rrkz_VecI64.to_nativer*rcbddl}|j|j|jdS)Nrz>i8rr,r.s rrpz_VecI64.to_numpyr/rcddl}|j|j}|jj |j t |d|gdSr1)rr2rGr/r3rtrOr4s rrz_VecI64.to_pyarrowG""4<<0}})) MMOSYv  rNr rrr)rYr<r=rr rrrrrrerkrprrrrr|r|s=I OOE D/(>E  rr|iicZeZdZdZej ZdZdZe d dZ d dZ d dZ d dZ y) r}rrzINTEGER32 NOT NULLc t|tjs t|} t j dt |dg|}||S#tj$ro|D]h}t|ts#tdt|jddt|cxkr tkrJntd|dtdtddwxYw) NrrzCannot build i32 vector from rEr:z is out of range for i32: [rVrF)r&rr#rrrrOrGrr7r;rY_I32_MIN_I32_MAXr;rJs rrez_VecI32.from_nativerKrLcdt|j|jzd}tt j ||jS)Nrrr&r(s rrkz_VecI32.to_nativer*rcbddl}|j|j|jdS)Nrz>i4rr,r.s rrpz_VecI32.to_numpyr/rcddl}|j|j}|jj |j t |d|gdSr1)rr2rGr/r3rurOr4s rrz_VecI32.to_pyarrowrPrNr rrr)rYr<r=rr rrrrrrerkrprrrrr}r}=I OOE D1(>E  rr}iicZeZdZdZej ZdZdZe d dZ d dZ d dZ d dZ y) r~rrzINTEGER16 NOT NULLc t|tjs t|} t j dt |dg|}||S#tj$ro|D]h}t|ts#tdt|jddt|cxkr tkrJntd|dtdtddwxYw) NrrzCannot build i16 vector from rEr:z is out of range for i16: [rVrF)r&rr#rrrrOrGrr7r;rY_I16_MIN_I16_MAXr;rJs rrez_VecI16.from_nativerKrLcdt|j|jzd}tt j ||jS)Nrrr&r(s rrkz_VecI16.to_nativer*rcbddl}|j|j|jdS)Nrz>i2rr,r.s rrpz_VecI16.to_numpyr/rcddl}|j|j}|jj |j t |d|gdSr1)rr2rGr/r3rvrOr4s rrz_VecI16.to_pyarrowrPrNr rrr)rYr<r=rr rrrrrrerkrprrrrr~r~rXrr~icZeZdZdZej ZdZdZe d dZ d dZ d dZ d dZ y) rrrzINTEGER8 NOT NULLc t|tjs t|} t j dt |dg|}||S#tj$ro|D]h}t|ts#tdt|jddt|cxkr tkrJntd|dtdtddwxYw) NrbzCannot build i8 vector from rEr:z is out of range for i8: [rVrF)r&rr#rrrrOrGrr7r;rY_I8_MIN_I8_MAXr;rJs rrez_VecI8.from_native2s$);D \\Ac$i["2:T:F6{}} !$,#6tDz7J7J6KL((  $1'1' '#9Bwiq2    rLcdt|j|jzd}tt j ||jS)Nrrcr&r(s rrkz_VecI8.to_nativeGr*rcbddl}|j|j|jdS)Nrz>i1rr,r.s rrpz_VecI8.to_numpyKr/rcddl}|j|j}|jj |j t |d|gdSr1)rr2rGr/r3rwrOr4s rrz_VecI8.to_pyarrowPsG""4<<0}})) LLNCIf~q  rNr rrr)rYr<r=rr rrrrrrerkrprrrrrr+s=I NNE D0(>E  rr)rrrr'rr')rrrztype[_InnerVector])Lr __future__rrabcr contextlibrinspectr8structrsysrenumr_Enumrr TYPE_CHECKINGr-r+rr._optional_depsrrtyping _rust.vectorr _swap_endian_unchecked_rust ImportError__all__object_DEFAULTr rRr Literalrr rrrrrrrrrrrrrrbrrrrr rzr{rArHrIr|rSrTr}r[r\r~rdrerrrrr|s# 1'   'H   8RRt3,O!<< #u H"**DEEJJNNOOOOOO     jjOO[__eU2 3 B ? *8_66 13-2~+488~+BD dhhD# # L/ / d%lDHH% & $+ o+ \  + o+ \  + o+ \  + _+ u'"&'s F==GG