itD ddlZddlmZmZmZmZddlZddlmZddl m Z ddl m Z ddl m Z ddl mZdd l mZd efd Zd Zd ed ee effdZ d"deeeefdeeeefdeedeefdZ d#deeeefd efdZdZdZded dfdZdeded dfdZdeded dfdZded dfdZdeeefd ed dfd!Z dS)$N)AnyCallableOptionalUnion) ArrowArray) DataFrame) base_impl) driver_mode)errors) thick_implreturnc(tjS)z This function can only be called when python-oracledb is in Thick mode. Using it in Thin mode will throw an exception. )r clientversion^/var/www/html/Pagina-Ingenieria-Requisitos/venv/lib/python3.11/site-packages/oracledb/utils.pyrr,s  # % %%rcdtjd5 ddddS#1swxYwYdS)a Makes python-oracledb be in Thin mode. After this method is called, Thick mode cannot be enabled. If python-oracledb is already in Thick mode, then calling ``enable_thin_mode()`` will fail. If Thin mode connections have already been opened, or a connection pool created in Thin mode, then calling ``enable_thin_mode()`` is a no-op. Since python-oracledb defaults to Thin mode, almost all applications do not need to call this method. However, because it bypasses python-oracledb's internal mode-determination heuristic, it may be useful for applications with multiple threads that concurrently create :ref:`standalone connections ` when the application starts. T)requested_thin_modeN)r get_managerrrrenable_thin_moder4s  T : : :                     s %))objct|drtj|St|drtj|Sd}t |)a This method converts a data frame to a :ref:`DataFrame ` or :ref:`ArrowArray ` instance. If ``obj`` supports the Arrow PyCapsule interface ``__arrow_c_stream__`` method, then ``from_arrow()`` returns the instance as a :ref:`DataFrame `. If ``obj`` does not support that method, but does support ``__arrow_c_array__``, then an :ref:`ArrowArray ` is returned. __arrow_c_stream____arrow_c_array__z>object must implement the PyCapsule stream or array interfaces)hasattrr _from_arrowr ValueError)rmsgs r from_arrowr Fs]s())+$S))) ) * *+%c*** JC S//rlib_dir config_dir error_url driver_namec4tj||||dS)aG Enables python-oracledb Thick mode by initializing the Oracle Client library, see :ref:`enablingthick`. If a standalone connection or pool has already been created in Thin mode, ``init_oracle_client()`` will raise an exception and python-oracledb will remain in Thin mode. If a standalone connection or pool has *not* already been created in Thin mode, but ``init_oracle_client()`` raises an exception, python-oracledb will remain in Thin mode but further calls to ``init_oracle_client()`` can be made, if desired. The ``init_oracle_client()`` method can be called multiple times in each Python process as long as the arguments are the same each time. The ``lib_dir`` parameter is a string or a bytes object that specifies the directory containing Oracle Client libraries. If the ``lib_dir`` parameter is set, then the specified directory is the only one searched for the Oracle Client libraries; otherwise, the operating system library search path is used to locate the Oracle Client library. If you are using Python 3.11 and later, then the value specified in this parameter is encoded using `locale.getencoding() `__. For all other Python versions, the encoding "utf-8" is used. If a bytes object is specified in this parameter, then this value will be used as is without any encoding. The ``config_dir`` parameter is a string or a bytes object that specifies the directory in which the :ref:`Optional Oracle Net Configuration ` and :ref:`Optional Oracle Client Configuration ` files reside. If the ``config_dir`` parameter is set, then the specified directory is used to find Oracle Client library configuration files. This is equivalent to setting the environment variable ``TNS_ADMIN`` and overrides any value already set in ``TNS_ADMIN``. If this parameter is not set, the :ref:`Oracle standard ` way of locating Oracle Client library configuration files is used. If you are using Python 3.11 and later, then the value specified in this parameter is encoded using `locale.getencoding() `__. For all other Python versions, the encoding "utf-8" is used. If a bytes object is specified in this parameter, then this value will be used as is without any encoding. The ``error_url`` parameter is a string that specifies the URL which is included in the python-oracledb exception message if the Oracle Client libraries cannot be loaded. If the ``error_url`` parameter is set, then the specified value is included in the message of the exception raised when the Oracle Client library cannot be loaded; otherwise, the :ref:`installation` URL is included. This parameter lets your application display custom installation instructions. The ``driver_name`` parameter is a string that specifies the driver name value. If the ``driver_name`` parameter is set, then the specified value can be found in database views that give information about connections. For example, it is in the CLIENT_DRIVER column of the V$SESSION_CONNECT_INFO view. From Oracle Database 12.2, the name displayed can be 30 characters. The standard is to set this value to ``" : version>"``, where is the name of the driver and is its version. There should be a single space character before and after the colon. If this parameter is not set, then the value specified in :attr:`oracledb.defaults.driver_name ` is used. If the value of this attribute is *None*, then the default value in python-oracledb Thick mode is like "python-oracledb thk : ". See :ref:`otherinit`. At successful completion of a call to ``oracledb.init_oracle_client()``, the attribute :attr:`oracledb.defaults.config_dir ` will be set as determined below (first one wins): - the value of the ``oracledb.init_oracle_client()`` parameter ``config_dir``, if one was passed. - the value of :attr:`oracledb.defaults.config_dir ` if it has one. i.e. :attr:`oracledb.defaults.config_dir ` remains unchanged after ``oracledb.init_oracle_client()`` completes. - the value of the environment variable ``$TNS_ADMIN``, if it is set. - the value of ``$ORACLE_HOME/network/admin`` if the environment variable ``$ORACLE_HOME`` is set. - the directory of the loaded Oracle Client library, appended with ``network/admin``. Note this directory is not determinable on AIX. - otherwise the value *None* is used. (Leaving :attr:`oracledb.defaults.config_dir ` unchanged). N)r init_oracle_client)r!r"r#r$s rr&r&Zs"x!':y+NNNNNrvaluec@|tjj}nOt|tr|d}n$t|tst dt|dkr tdt|d|S)aZ Normalize and validate the transaction_id. - If `value` is a string, it's UTF-8 encoded. - If `value` is None, a UUID4-based transaction_id is generated. - If `value` is not str/bytes/None, raises TypeError. - If transaction_id exceeds 64 bytes, raises ValueError. Returns: bytes: Normalized transaction_id Nzutf-8z3invalid transaction_id: must be str, bytes, or None@z*transaction_id size exceeds 64 bytes (got )) uuiduuid4bytes isinstancestrencode TypeErrorlenr)r's r$normalize_sessionless_transaction_idr3s } " E3  O W%% u % %OMNNN 5zzB FU F F F    LrcFtjfd}|S)a[ Decorator function which is used on the ConnectParams and PoolParams classes. It creates the implementation object using the implementation class stored on the parameter class. It first, however, calls the original method to ensure that the keyword parameters supplied are valid (the original method itself does nothing). c|g|Ri|||_|r|j|dSdSN) _impl_class_implsetselfargskwargsfs r wrapped_fz params_initer..wrapped_fsb $       %%''  # JNN6 " " " " " # #r functoolswrapsr>r?s` r params_initerrDs;_Q##### rcFtjfd}|S)a^ Decorator function which is used on the ConnectParams and PoolParams classes. It calls the set() method on the parameter implementation object with the supplied keyword arguments. It first, however, calls the original method to ensure that the keyword parameters supplied are valid (the original method itself does nothing). cT|g|Ri||j|dSr6)r8r9r:s rr?z params_setter..wrapped_fs= $        vrr@rCs` r params_setterrGs;_Q r hook_functionc|t|stdtj|dS)aD Registers a user parameter hook function that will be called internally by python-oracledb prior to connection or pool creation. The hook function accepts a copy of the parameters that will be used to create the pool or standalone connection and may modify them. For example, the cloud native authentication plugins modify the "access_token" parameter with a function that will acquire the token using information found in the "extra_auth_parms" parameter. Multiple hooks may be registered. They will be invoked in order of registration. Nz3hook_function must be a callable and cannot be None)callabler1r REGISTERED_PARAMS_HOOKSappendrHs rregister_params_hookrNsCH]$;$;MNNN %,,];;;;;r password_typect|tstd|t|std|}|!t j|dS|t j|<dS)aG Registers a user password hook function that will be called internally by python-oracledb when a password is supplied as a dictionary containing the given ``password_type`` as the key "type". The hook function is called for passwords specified as the ``password``, ``newpassword`` and ``wallet_parameter`` parameters in calls to :meth:`oracledb.connect()`, :meth:`oracledb.create_pool()`, :meth:`oracledb.connect_async()`, and :meth:`oracledb.create_pool_async()`. Your hook function is expected to accept the dictionary supplied by the application and return the valid password. Calling :meth:`~oracledb.register_password_type()` with the ``hook_function`` parameter set to *None* will result in a previously registered user function being removed and the default behavior restored. zpassword_type must be a stringN hook_function must be a callable)r.r/r1rJlowerr REGISTERED_PASSWORD_TYPESpop)rOrHs rregister_password_typerU s& mS ) ):8999 -)@)@ :;;;!''))M+// >>>>>=J +M:::rprotocolct|tstd|t|std|}|!t j|dS|t j|<dS)a Registers a user protocol hook function that will be called internally by python-oracledb Thin mode prior to connection or pool creation. The hook function will be invoked when :func:`oracledb.connect`, :func:`oracledb.create_pool`, :meth:`oracledb.connect_async()`, or :meth:`oracledb.create_pool_async()` are called with a ``dsn`` parameter value prefixed with the specified protocol. The user function will also be invoked when :meth:`ConnectParams.parse_connect_string()` is called in Thin or Thick modes with a similar ``connect_string`` parameter value. Your hook function is expected to construct valid connection details. For example, if a hook function is registered for the "ldaps" protocol, then calling :func:`oracledb.connect` with a connection string prefixed with "ldaps://" will invoke the function. The function can then perform LDAP lookup to retrieve and set the actual database information that will be used internally by python-oracledb to complete the connection creation. The ``protocol`` parameter is a string that will be matched against the prefix appearing before "://" in connection strings. The ``hook_function`` parameter should be a function with the signature:: hook_function(protocol, protocol_arg, params) The hook function will be called with the following arguments: - The ``protocol`` parameter is the value that was registered. - The ``protocol_arg`` parameter is the section after "://" in the connection string used in the connection or pool creation call, or passed to :meth:`~ConnectParams.parse_connect_string()`. - The ``params`` parameter is an instance of :ref:`ConnectParams `. When your hook function is invoked internally prior to connection or pool creation, ``params`` will be the ConnectParams instance originally passed to the :func:`oracledb.connect`, :func:`oracledb.create_pool`, :meth:`oracledb.connect_async()`, or :meth:`oracledb.create_pool_async()` call, if such an instance was passed. Otherwise it will be a new ConnectParams instance. The hook function should parse ``protocol`` and ``protocol_arg`` and take any desired action to update ``params`` :ref:`attributes ` with appropriate connection parameters. Attributes can be set using :meth:`ConnectParams.set()` or :meth:`ConnectParams.parse_connect_string()`. The ConnectParams instance will then be used to complete the connection or pool creation. When your hook function is invoked by :meth:`ConnectParams.parse_connect_string()`, then ``params`` will be the invoking ConnectParams instance that you can update using :meth:`ConnectParams.set()` or :meth:`ConnectParams.parse_connect_string()`. Internal hook functions for the "tcp" and "tcps" protocols are pre-registered but can be overridden if needed. If any other protocol has not been registered, then connecting will result in the error ``DPY-4021: invalid protocol``. Calling :meth:`~oracledb.register_protocol()` with the ``hook_function`` parameter set to *None* will result in a previously registered user function being removed and the default behavior restored. zprotocol must be a stringNrQ)r.r/r1rJrRr REGISTERED_PROTOCOLSrT)rVrHs rregister_protocolrY*s~ h $ $53444 -)@)@ :;;;~~H&**8444443@ &x000rcDtj|dS)z Unregisters a user parameter function that was earlier registered with a call to :meth:`oracledb.register_params_hook()`. N)r rKremoverMs runregister_params_hookr\ts! %,,];;;;;r parameterskeyword_parametersc|:t|ttfstjtj|5t|t s"tjtjdSdSdS)ze Verifies that the arguments to a call to a stored procedure or function are acceptable. N)r.listtupler _raise_errERR_ARGS_MUST_BE_LIST_OR_TUPLEdictERR_KEYWORD_ARGS_MUST_BE_DICT)r]r^s rverify_stored_proc_argsrf|sujdE]&K&K&?@@@%jD//% &>?????&%%%r)NNNNr6)!rAtypingrrrrr+ arrow_arrayr dataframer r r r r rarrr r/r-r&r3rDrGrNrUrYr\r`rdrfrrrrks>111111111111 ###### &u&&&&   $CE)Z"78*,0.2#!% \O\O eCJ' (\OsEz*+\O}\O# \O\O\O\O@*. E%*% & :&"<