a !fG@s(dZddlZddlZddlZddlmZddlmZzddlm Z Wne ybddl m Z Yn0ddl mZddlmZdd lmZdd lmZdd lmZdd lmZdZdZdZdZdZdZdZdZed Z ej!Z"d Z#de#Z$de#Z%de#Z&de#Z'dZ(dddZ)Gddde*Z+ddZ,dS)z2Google Cloud Bigtable HappyBase connection module.N) interfaces)face) AlreadyExists)Conflict)Client)GCRuleIntersection) MaxAgeGCRule)MaxVersionsGCRule)Table)hostportcompat transportprotocolz;Cloud Bigtable has no concept of enabled / disabled tables.z;The disable argument should not be used in delete_table(). z,Connection.enable_table(%r) was called, but z-Connection.disable_table(%r) was called, but z0Connection.is_table_enabled(%r) was called, but zConnection.compact_table(%r, major=%r) was called, but the Cloud Bigtable API handles table compactions automatically and does not expose an API for it.cCsddi}|dur|d|d<tfi|}z ||\}}W|n |0t|dkrjtdt|dkr~tdt|d krtd |dS) aGets instance for the default project. Creates a client with the inferred credentials and project ID from the local environment. Then uses :meth:`.bigtable.client.Client.list_instances` to get the unique instance owned by the project. If the request fails for any reason, or if there isn't exactly one instance owned by the project, then this function will fail. :type timeout: int :param timeout: (Optional) The socket timeout in milliseconds. :rtype: :class:`gcloud.bigtable.instance.Instance` :returns: The unique instance owned by the project inferred from the environment. :raises ValueError: if there is a failed location or any number of instances other than one. ZadminTNg@@Ztimeout_secondsrzDDetermining instance via ListInstances encountered failed locations.z1This client doesn't have access to any instances.zfThis client has access to more than one instance. Please directly pass the instance you'd like to use.)rstartZlist_instancesstoplen ValueError)timeoutZ client_kwargsclientZ instancesZfailed_locationsre/var/www/html/python-backend/venv/lib/python3.9/site-packages/gcloud/bigtable/happybase/connection.py _get_instance@s    rc@seZdZdZdZd"ddZeddZd d Zd d Z d dZ ddZ d#ddZ ddZ ddZd$ddZeddZeddZeddZed%d d!ZdS)& ConnectionaHConnection to Cloud Bigtable backend. .. note:: If you pass a ``instance``, it will be :meth:`.Instance.copy`-ed before being stored on the new connection. This also copies the :class:`Client ` that created the :class:`Instance ` instance and the :class:`Credentials ` stored on the client. The arguments ``host``, ``port``, ``compat``, ``transport`` and ``protocol`` are allowed (as keyword arguments) for compatibility with HappyBase. However, they will not be used in any way, and will cause a warning if passed. :type timeout: int :param timeout: (Optional) The socket timeout in milliseconds. :type autoconnect: bool :param autoconnect: (Optional) Whether the connection should be :meth:`open`-ed during construction. :type table_prefix: str :param table_prefix: (Optional) Prefix used to construct table names. :type table_prefix_separator: str :param table_prefix_separator: (Optional) Separator used with ``table_prefix``. Defaults to ``_``. :type instance: :class:`Instance ` :param instance: (Optional) A Cloud Bigtable instance. The instance also owns a client for making gRPC requests to the Cloud Bigtable API. If not passed in, defaults to creating client with ``admin=True`` and using the ``timeout`` here for the ``timeout_seconds`` argument to the :class:`Client ` constructor. The credentials for the client will be the implicit ones loaded from the environment. Then that client is used to retrieve all the instances owned by the client's project. :type kwargs: dict :param kwargs: Remaining keyword arguments. Provided for HappyBase compatibility. NT_cKs|||dur0t|tjs0tdd|t|t|tjsNtdd|t|||_||_|durpt|d|_ n|durt d| |_ |r| d|_ dS)Nztable_prefix must be a stringZreceivedz'table_prefix_separator must be a string)rz:Timeout cannot be used when an existing instance is passedT)_handle_legacy_args isinstancesix string_types TypeErrortype table_prefixtable_prefix_separatorr _instancercopyopen _initialized)selfrZ autoconnectr"r#instancekwargsrrr__init__s*    zConnection.__init__cCs^tt|}|r0d|}d|f}t||D]}||q4|rZ|}td|dS)a-Check legacy HappyBase arguments and warn if set. :type arguments_dict: dict :param arguments_dict: Unused keyword arguments. :raises TypeError: if a keyword other than ``host``, ``port``, ``compat``, ``transport`` or ``protocol`` is used. , zRThe HappyBase legacy arguments %s were used. These arguments are unused by gcloud.zReceived unexpected argumentsN) _LEGACY_ARGS intersectionriterkeysjoin_WARNpopkeysr )Zarguments_dictZ common_argsall_argsmessageZarg_nameZunexpected_namesrrrrs   zConnection._handle_legacy_argscCs|jjdS)a'Open the underlying transport to Cloud Bigtable. This method opens the underlying HTTP/2 gRPC connection using a :class:`Client ` bound to the :class:`Instance ` owned by this connection. N)r$_clientrr(rrrr&szConnection.opencCs|jjdS)a)Close the underlying transport to Cloud Bigtable. This method closes the underlying HTTP/2 gRPC connection using a :class:`Client ` bound to the :class:`Instance ` owned by this connection. N)r$r6rr7rrrcloseszConnection.closecCs|jdur|dSN)r$r8r7rrr__del__s zConnection.__del__cCs|jdur|S|j|j|S)aConstruct a table name by optionally adding a table name prefix. :type name: str :param name: The name to have a prefix added to it. :rtype: str :returns: The prefixed name, if the current connection has a table prefix set. N)r"r#)r(namerrr _table_names zConnection._table_namecCs|r||}t||S)aRTable factory. :type name: str :param name: The name of the table to be created. :type use_prefix: bool :param use_prefix: Whether to use the table prefix (if any). :rtype: :class:`Table ` :returns: Table instance owned by this connection. )r<r )r(r;Z use_prefixrrrtables  zConnection.tablecsL|j}dd|D}|jdurH|dtfdd|D}|S)aReturn a list of table names available to this connection. .. note:: This lists every table in the instance owned by this connection, **not** every table that a given user may have access to. .. note:: If ``table_prefix`` is set on this connection, only returns the table names which match that prefix. :rtype: list :returns: List of string table names. cSsg|] }|jqSr)Ztable_id).0Ztable_instancerrr sz%Connection.tables..Ncs"g|]}|r|dqSr9) startswith)r>r;offsetprefixrrr?s )r$Z list_tablesr"r<r)r(Zlow_level_table_instancesZ table_namesrrBrtabless   zConnection.tablesc st|tstd|s$td|fi}|D]@\}}t|tjrN|d}|drd|dd}t |||<q0| |}t ||j fddt |D}zj|d Wn@tjy}z&|jtjjkrt|nWYd}~n d}~00dS) aCreate a table. .. warning:: The only column family options from HappyBase that are able to be used with Cloud Bigtable are ``max_versions`` and ``time_to_live``. Values in ``families`` represent column family options. In HappyBase, these are dictionaries, corresponding to the ``ColumnDescriptor`` structure in the Thrift API. The accepted keys are: * ``max_versions`` (``int``) * ``compression`` (``str``) * ``in_memory`` (``bool``) * ``bloom_filter_type`` (``str``) * ``bloom_filter_vector_size`` (``int``) * ``bloom_filter_nb_hashes`` (``int``) * ``block_cache_enabled`` (``bool``) * ``time_to_live`` (``int``) :type name: str :param name: The name of the table to be created. :type families: dict :param families: Dictionary with column family names as keys and column family options as the values. The options can be among * :class:`dict` * :class:`.GarbageCollectionRule` :raises TypeError: If ``families`` is not a dictionary. :raises ValueError: If ``families`` has no entries. :raises AlreadyExists: If creation fails due to an already existing table. :raises NetworkError: If creation fails for a reason other than table exists. z!families arg must be a dictionaryz5Cannot create table %r (no column families specified)zutf-8:Nc3s |]\}}j||dVqdS))gc_ruleN)Z column_family)r>column_family_namerHZlow_level_tablerr \sz*Connection.create_table..)column_families)rdictr ritemsr binary_typedecodeendswith_parse_family_optionr<_LowLevelTabler$ iteritemscreaterZ NetworkErrorcoderZ StatusCodeZALREADY_EXISTSr)r(r;ZfamiliesZ gc_rule_dictrIoptionrLZ network_errrrJr create_table#s0&         zConnection.create_tableFcCs*|r tt||}t||jdS)a Delete the specified table. :type name: str :param name: The name of the table to be deleted. If ``table_prefix`` is set, a prefix will be added to the ``name``. :type disable: bool :param disable: Whether to first disable the table if needed. This is provided for compatibility with HappyBase, but is not relevant for Cloud Bigtable since it has no concept of enabled / disabled tables. N)r1_DISABLE_DELETE_MSGr<rSr$delete)r(r;disablerrr delete_tablehs  zConnection.delete_tablecCstt|fdS)a'Enable the specified table. .. warning:: Cloud Bigtable has no concept of enabled / disabled tables so this method does nothing. It is provided simply for compatibility. :type name: str :param name: The name of the table to be enabled. N)r1 _ENABLE_TMPLr;rrr enable_table{s zConnection.enable_tablecCstt|fdS)a)Disable the specified table. .. warning:: Cloud Bigtable has no concept of enabled / disabled tables so this method does nothing. It is provided simply for compatibility. :type name: str :param name: The name of the table to be disabled. N)r1 _DISABLE_TMPLr^rrr disable_tables zConnection.disable_tablecCstt|fdS)aReturn whether the specified table is enabled. .. warning:: Cloud Bigtable has no concept of enabled / disabled tables so this method always returns :data:`True`. It is provided simply for compatibility. :type name: str :param name: The name of the table to check enabled / disabled status. :rtype: bool :returns: The value :data:`True` always. T)r1_IS_ENABLED_TMPLr^rrris_table_enabledszConnection.is_table_enabledcCstt||fdS)aCompact the specified table. .. warning:: Cloud Bigtable supports table compactions, it just doesn't expose an API for that feature, so this method does nothing. It is provided simply for compatibility. :type name: str :param name: The name of the table to compact. :type major: bool :param major: Whether to perform a major compaction. N)r1 _COMPACT_TMPL)r;majorrrr compact_tableszConnection.compact_table)NTNrN)T)F)F)__name__ __module__ __qualname____doc__r$r+ staticmethodrr&r8r:r<r=rErXr\r_rarcrfrrrrrjs./     E    rcCs|}t|trt|tddgksPddd|D}d|f}t||d}d}d|vrvtj|dd}d}}|durt |}|durt |}|dur|}n|dur|}nt ||gd }|S) arParses a column family option into a garbage collection rule. .. note:: If ``option`` is not a dictionary, the type is not checked. If ``option`` is :data:`None`, there is nothing to do, since this is the correct output. :type option: :class:`dict`, :data:`NoneType `, :class:`.GarbageCollectionRule` :param option: A column family option passes as a dictionary value in :meth:`Connection.create_table`. :rtype: :class:`.GarbageCollectionRule` :returns: A garbage collection rule parsed from the input. Z max_versionsZ time_to_liver,css|]}t|VqdSr9)repr)r>keyrrrrKz'_parse_family_option..z_Cloud Bigtable only supports max_versions and time_to_live column family settings. Received: %sN)seconds)rules) rrMsetr3r0r1getdatetime timedeltar rr)rWresultall_keysZ warning_msgZmax_num_versionsZmax_ageZ versions_ruleZage_rulerrrrRs.  rR)N)-rjrswarningsrZ grpc.betarZgrpc.framework.interfaces.facerZhappybase.hbase.ttypesr ImportErrorZgcloud.exceptionsrZgcloud.bigtable.clientrZgcloud.bigtable.column_familyrrr Zgcloud.bigtable.happybase.tabler Zgcloud.bigtable.tablerSZ COMPAT_MODESZTHRIFT_TRANSPORTSZTHRIFT_PROTOCOLSZ DEFAULT_HOSTZ DEFAULT_PORTZDEFAULT_TRANSPORTZDEFAULT_COMPATDEFAULT_PROTOCOL frozensetr-warnr1Z _BASE_DISABLErYr]r`rbrdrobjectrrRrrrrsP          *U