a !fB@svdZddlZddlmZddlmZddlmZddlm Z ddl m Z Gdd d ej Z d d Zd d ZddZdS)z,Connections to gcloud datastore API servers.N) connection)GCD_HOST)make_exception) datastore_pb2) status_pb2cseZdZdZdZdZdZdZdfdd Zd d Z d d Z dd dZ dddZ dddZ ddZddZddZddZZS) ConnectionaA connection to the Google Cloud Datastore via the Protobuf API. This class should understand only the basic types (and protobufs) in method arguments, however should be capable of returning advanced types. :type credentials: :class:`oauth2client.client.OAuth2Credentials` :param credentials: The OAuth2 Credentials to use for this connection. :type http: :class:`httplib2.Http` or class that defines ``request()``. :param http: An optional HTTP object to make requests. :type api_base_url: string :param api_base_url: The base of the API call URL. Defaults to :attr:`API_BASE_URL`. z https://datastore.googleapis.comZv1beta3z4{api_base}/{api_version}/projects/{project}:{method})z)https://www.googleapis.com/auth/datastoreNcsVtt|j||d|durLzdtjtf}WntyJ|jj}Yn0||_ dS)N) credentialshttpz %s/datastore) superr__init__osenvironrKeyError __class__ API_BASE_URL api_base_url)selfrr rr\/var/www/html/python-backend/venv/lib/python3.9/site-packages/gcloud/datastore/connection.pyr 8s zConnection.__init__cCshdtt||jd}|jj|j||dd||d\}}|d}|dkrdtj|}t ||j dd |S) aMake a request over the Http transport to the Cloud Datastore API. :type project: string :param project: The project to make the request for. :type method: string :param method: The API call method name (ie, ``runQuery``, ``lookup``, etc) :type data: string :param data: The data to send with the API call. Typically this is a serialized Protobuf string. :rtype: string :returns: The string response content from the API call. :raises: :class:`gcloud.exceptions.GCloudError` if the response code is not 200 OK. zapplication/x-protobuf)z Content-TypezContent-Lengthz User-Agent)projectmethodPOST)urirheadersbodystatusZ200F)Zuse_json) strlenZ USER_AGENTr request build_api_urlrStatus FromStringrmessage)rrrdatarcontentrZ error_statusrrr_requestCs    zConnection._requestcCs|j|||d}||S)aMake a protobuf RPC request. :type project: string :param project: The project to connect to. This is usually your project name in the cloud console. :type method: string :param method: The name of the method to invoke. :type request_pb: :class:`google.protobuf.message.Message` instance :param request_pb: the protobuf instance representing the request. :type response_pb_cls: A :class:`google.protobuf.message.Message` subclass. :param response_pb_cls: The class used to unmarshall the response protobuf. :rtype: :class:`google.protobuf.message.Message` :returns: The RPC message parsed from the response. )rrr$)r&ZSerializeToStringr")rrrZ request_pbZresponse_pb_clsresponserrr_rpcfszConnection._rpccCs |jj|p|j|p|j||dS)a5Construct the URL for a particular API call. This method is used internally to come up with the URL to use when making RPCs to the Cloud Datastore API. :type project: string :param project: The project to connect to. This is usually your project name in the cloud console. :type method: string :param method: The API method to call (e.g. 'runQuery', 'lookup'). :type base_url: string :param base_url: The base URL where the API lives. You shouldn't have to provide this. :type api_version: string :param api_version: The version of the API to connect to. You shouldn't have to provide this. :rtype: str :returns: The API URL created. )Zapi_base api_versionrr)API_URL_TEMPLATEformatr API_VERSION)rrrbase_urlr)rrrr s zConnection.build_api_urlFc Csbt}t|||t|j|||d|tj}dd|jD}dd|jD}||t |j fS)aLookup keys from a project in the Cloud Datastore. Maps the ``DatastoreService.Lookup`` protobuf RPC. This uses mostly protobufs (:class:`gcloud.datastore._generated.entity_pb2.Key` as input and :class:`gcloud.datastore._generated.entity_pb2.Entity` as output). It is used under the hood in :meth:`Client.get() <.datastore.client.Client.get>`: >>> from gcloud import datastore >>> client = datastore.Client(project='project') >>> key = client.key('MyKind', 1234) >>> client.get(key) [] Using a :class:`Connection` directly: >>> connection.lookup('project', [key.to_protobuf()]) [] :type project: string :param project: The project to look up the keys in. :type key_pbs: list of :class:`gcloud.datastore._generated.entity_pb2.Key` :param key_pbs: The keys to retrieve from the datastore. :type eventual: bool :param eventual: If False (the default), request ``STRONG`` read consistency. If True, request ``EVENTUAL`` read consistency. :type transaction_id: string :param transaction_id: If passed, make the request in the scope of the given transaction. Incompatible with ``eventual==True``. :rtype: tuple :returns: A triple of (``results``, ``missing``, ``deferred``) where both ``results`` and ``missing`` are lists of :class:`gcloud.datastore._generated.entity_pb2.Entity` and ``deferred`` is a list of :class:`gcloud.datastore._generated.entity_pb2.Key`. lookupcSsg|] }|jqSrentity.0resultrrr z%Connection.lookup..cSsg|] }|jqSrr/r1rrrr4r5) _datastore_pb2Z LookupRequest_set_read_options_add_keys_to_requestkeysr(ZLookupResponsefoundmissinglistdeferred) rrkey_pbseventualtransaction_idZlookup_requestZlookup_responseresultsr;rrrr.s/   zConnection.lookupcCsdt}t||||r ||j_|j|||d|tj}dd|j j D|j j |j j |j j fS)a Run a query on the Cloud Datastore. Maps the ``DatastoreService.RunQuery`` protobuf RPC. Given a Query protobuf, sends a ``runQuery`` request to the Cloud Datastore API and returns a list of entity protobufs matching the query. You typically wouldn't use this method directly, in favor of the :meth:`gcloud.datastore.query.Query.fetch` method. Under the hood, the :class:`gcloud.datastore.query.Query` class uses this method to fetch data: >>> from gcloud import datastore >>> client = datastore.Client() >>> query = client.query(kind='MyKind') >>> query.add_filter('property', '=', 'val') Using the query iterator's :meth:`next_page() <.datastore.query.Iterator.next_page>` method: >>> query_iter = query.fetch() >>> entities, more_results, cursor = query_iter.next_page() >>> entities [] >>> more_results >>> cursor Under the hood this is doing: >>> connection.run_query('project', query.to_protobuf()) [], cursor, more_results, skipped_results :type project: string :param project: The project over which to run the query. :type query_pb: :class:`gcloud.datastore._generated.query_pb2.Query` :param query_pb: The Protobuf representing the query to run. :type namespace: string :param namespace: The namespace over which to run the query. :type eventual: bool :param eventual: If False (the default), request ``STRONG`` read consistency. If True, request ``EVENTUAL`` read consistency. :type transaction_id: string :param transaction_id: If passed, make the request in the scope of the given transaction. Incompatible with ``eventual==True``. :rtype: tuple :returns: Four-tuple containing the entities returned, the end cursor of the query, a ``more_results`` enum and a count of the number of skipped results. ZrunQuerycSsg|] }|jqSrr/)r2errrr4 r5z(Connection.run_query..)r6ZRunQueryRequestr7Z partition_idZ namespace_idqueryCopyFromr(ZRunQueryResponsebatchZentity_resultsZ end_cursorZ more_resultsZskipped_results)rrZquery_pb namespacer?r@rr'rrr run_querys>   zConnection.run_querycCs t}||d|tj}|jS)aBegin a transaction. Maps the ``DatastoreService.BeginTransaction`` protobuf RPC. :type project: string :param project: The project to which the transaction applies. :rtype: bytes :returns: The serialized transaction that was begun. ZbeginTransaction)r6ZBeginTransactionRequestr(ZBeginTransactionResponse transaction)rrrr'rrrbegin_transaction&s  zConnection.begin_transactioncCs:|rtjj|_||_n tjj|_||d|tj}t|S)aCommit mutations in context of current transation (if any). Maps the ``DatastoreService.Commit`` protobuf RPC. :type project: string :param project: The project to which the transaction applies. :type request: :class:`._generated.datastore_pb2.CommitRequest` :param request: The protobuf with the mutations being committed. :type transaction_id: string or None :param transaction_id: The transaction ID returned from :meth:`begin_transaction`. Non-transactional batches must pass ``None``. .. note:: This method will mutate ``request`` before using it. :rtype: tuple :returns: The pair of the number of index updates and a list of :class:`._generated.entity_pb2.Key` for each incomplete key that was completed in the commit. commit) r6Z CommitRequestZ TRANSACTIONALmoderHZNON_TRANSACTIONALr(ZCommitResponse_parse_commit_response)rrrr@r'rrrrJ6s   zConnection.commitcCs$t}||_||d|tjdS)a{Rollback the connection's existing transaction. Maps the ``DatastoreService.Rollback`` protobuf RPC. :type project: string :param project: The project to which the transaction belongs. :type transaction_id: string :param transaction_id: The transaction ID returned from :meth:`begin_transaction`. rollbackN)r6ZRollbackRequestrHr(ZRollbackResponse)rrr@rrrrrMYs  zConnection.rollbackcCs0t}t|j|||d|tj}t|jS)a1Obtain backend-generated IDs for a set of keys. Maps the ``DatastoreService.AllocateIds`` protobuf RPC. :type project: string :param project: The project to which the transaction belongs. :type key_pbs: list of :class:`gcloud.datastore._generated.entity_pb2.Key` :param key_pbs: The keys for which the backend should allocate IDs. :rtype: list of :class:`gcloud.datastore._generated.entity_pb2.Key` :returns: An equal number of keys, with IDs filled in by the backend. Z allocateIds)r6ZAllocateIdsRequestr8r9r(ZAllocateIdsResponser<)rrr>rr'rrr allocate_idsks   zConnection.allocate_ids)NNN)NN)FN)NFN)__name__ __module__ __qualname____doc__rr,r*ZSCOPEr r&r(r r.rGrIrJrMrN __classcell__rrrrrs( #  ; N#rcCs8|r|durtd|j}|r*tjj|_n |r4||_dS)zValidate rules for read options, and assign to the request. Helper method for ``lookup()`` and ``run_query``. :raises: :class:`ValueError` if ``eventual`` is ``True`` and the ``transaction_id`` is not ``None``. Nz,eventual must be False when in a transaction) ValueErrorZ read_optionsr6Z ReadOptionsZEVENTUALZread_consistencyrH)rr?r@optsrrrr7s  r7cCs|D]}||qdS)a4Add protobuf keys to a request object. :type request_field_pb: `RepeatedCompositeFieldContainer` :param request_field_pb: A repeated proto field that contains keys. :type key_pbs: list of :class:`gcloud.datastore._generated.entity_pb2.Key` :param key_pbs: The keys to add to a request. N)addrD)Zrequest_field_pbr>Zkey_pbrrrr8s r8cCs"|j}|j}dd|D}||fS)aExtract response data from a commit response. :type commit_response_pb: :class:`._generated.datastore_pb2.CommitResponse` :param commit_response_pb: The protobuf response from a commit request. :rtype: tuple :returns: The pair of the number of index updates and a list of :class:`._generated.entity_pb2.Key` for each incomplete key that was completed in the commit. cSsg|]}|dr|jqS)key)ZHasFieldrW)r2Z mut_resultrrrr4s z*_parse_commit_response..)Zmutation_results index_updates)Zcommit_response_pbZ mut_resultsrXZcompleted_keysrrrrLs rL)rRr ZgcloudrZgcloud.environment_varsrZgcloud.exceptionsrZgcloud.datastore._generatedrr6Z google.rpcrrr7r8rLrrrrs     j