python-etcd3-async 0.1.0__py3-none-any.whl

etcd3/utils.py

@@ -0,0 +1,158 @@
+"""Utility functions for etcd3 operations."""
+
+from enum import Enum
+from typing import Any, AsyncIterator, Iterator, Union
+
+import grpc
+
+
+# Watch filter types - matching etcd protobuf FilterType
+# Use these constants with the filters parameter in watch operations
+#
+# Example usage:
+#     events, cancel = await etcd.watch('/key', filters=[FILTER_DELETE])
+#     # Only PUT events will be received, DELETE events are filtered out
+#
+FILTER_PUT = 0      # Filter out PUT events (only DELETE events will be received)
+FILTER_DELETE = 1   # Filter out DELETE events (only PUT events will be received)
+FILTER_COMMIT = 2   # Filter out all events (no events will be received)
+
+
+class LoadBalancerStrategy(Enum):
+    """Load balancing strategies for multi-endpoint clients.
+
+    Attributes:
+        PRIORITY: Priority-based routing - prefer healthy nodes, failover on failure
+        ROUND_ROBIN: Round-robin - cycle through endpoints sequentially
+        RANDOM: Random - select random healthy endpoint
+        STICKY: Sticky - maintain connection to the same endpoint
+    """
+    PRIORITY = "priority"
+    ROUND_ROBIN = "round_robin"
+    RANDOM = "random"
+    STICKY = "sticky"
+
+
+def is_connection_canceled(error: grpc.RpcError) -> bool:
+    """Check if a connection error indicates the connection was canceled.
+
+    This is similar to Go's clientv3.IsConnCanceled function.
+
+    :param error: The gRPC error to check
+    :type error: grpc.RpcError
+    :returns: True if the connection was canceled
+    :rtype: bool
+    """
+    code = error.code()
+    if code == grpc.StatusCode.UNAVAILABLE:
+        return True
+    if code == grpc.StatusCode.INTERNAL:
+        return True
+    return False
+
+
+def is_channel_ready(channel) -> bool:
+    """Check if a gRPC channel is ready.
+
+    :param channel: The gRPC channel to check
+    :type channel: grpc.aio.Channel
+    :returns: True if the channel is ready
+    :rtype: bool
+    """
+    try:
+        state = channel.get_state()
+        return state == grpc.ChannelConnectivity.READY
+    except Exception:
+        return False
+
+
+def prefix_range_end(prefix: bytes) -> bytes:
+    """Create a bytestring that can be used as a range_end for a prefix query.
+
+    This function calculates the end of a key range that includes all keys
+    starting with the given prefix.
+
+    :param prefix: The key prefix to match
+    :type prefix: bytes
+    :returns: The range end bytes for prefix matching
+    :rtype: bytes
+
+    Example:
+        >>> prefix_range_end(b'/foo/')
+        b'/foo0'  # All keys starting with /foo/ will match
+    """
+    if not prefix:
+        # Empty prefix returns empty range_end (matches nothing)
+        return b""
+    s = bytearray(prefix)
+    for i in reversed(range(len(s))):
+        if s[i] < 0xFF:
+            s[i] = s[i] + 1
+            break
+    return bytes(s)
+
+
+def to_bytes(maybe_bytestring: Union[str, bytes]) -> bytes:
+    """Encode string to bytes.
+
+    Convenience function to do a simple encode('utf-8') if the input is not
+    already bytes. Returns the data unmodified if the input is bytes.
+
+    :param maybe_bytestring: The string or bytes to convert
+    :type maybe_bytestring: str or bytes
+    :returns: The input encoded as bytes
+    :rtype: bytes
+    """
+    if isinstance(maybe_bytestring, bytes):
+        return maybe_bytestring
+    else:
+        return maybe_bytestring.encode("utf-8")
+
+
+def lease_to_id(lease: Any) -> int:
+    """Extract lease ID from a Lease object or return the ID directly.
+
+    :param lease: A Lease object with an 'id' attribute, or a lease ID
+    :type lease: Any (with 'id' attribute) or int
+    :returns: The lease ID as an integer
+    :rtype: int
+
+    Example:
+        >>> lease_to_id(my_lease)  # Lease object
+        12345
+        >>> lease_to_id(12345)  # Direct ID
+        12345
+    """
+    lease_id = 0
+    if hasattr(lease, "id"):
+        lease_id = lease.id
+    else:
+        try:
+            lease_id = int(lease)
+        except TypeError:
+            pass
+    return lease_id
+
+
+def response_to_event_iterator(response_iterator: Iterator[Any]) -> Iterator[Any]:
+    """Convert a watch response iterator to an event iterator.
+
+    :param response_iterator: Iterator of watch responses
+    :type response_iterator: Iterator
+    :yields: Individual events from the watch responses
+    :rtype: Any
+    """
+    for response in response_iterator:
+        for event in response.events:
+            yield event
+
+
+async def async_response_to_event_iterator(response_iterator) -> AsyncIterator[Any]:
+    """Convert an async watch response iterator to an async event iterator.
+
+    :param response_iterator: Async iterator of watch responses
+    :yields: Individual events from the watch responses
+    """
+    async for response in response_iterator:
+        for event in response.events:
+            yield event

etcd3/watch.py

@@ -0,0 +1,270 @@
+import logging
+import threading
+import time
+
+import grpc
+import queue
+
+import etcdrpc
+import etcd3.events as events
+import etcd3.exceptions as exceptions
+import etcd3.utils as utils
+
+
+_log = logging.getLogger(__name__)
+
+
+class Watch(object):
+    def __init__(self, watch_id, iterator=None, etcd_client=None):
+        self.watch_id = watch_id
+        self.etcd_client = etcd_client
+        self.iterator = iterator
+
+    def cancel(self):
+        self.etcd_client.cancel_watch(self.watch_id)
+
+    def iterator(self):
+        if self.iterator is not None:
+            return self.iterator
+
+        raise ValueError("Undefined iterator")
+
+
+class Watcher(object):
+    def __init__(self, watchstub, timeout=None, call_credentials=None, metadata=None):
+        self.timeout = timeout
+        self._watch_stub = watchstub
+        self._credentials = call_credentials
+        self._metadata = metadata
+
+        self._lock = threading.Lock()
+        self._request_queue = queue.Queue(maxsize=10)
+        self._callbacks = {}
+        self._callback_thread = None
+        self._new_watch_cond = threading.Condition(lock=self._lock)
+        self._new_watch = None
+        self._stopping = False
+
+    def _create_watch_request(
+        self,
+        key,
+        range_end=None,
+        start_revision=None,
+        progress_notify=False,
+        filters=None,
+        prev_kv=False,
+    ):
+        create_watch = etcdrpc.WatchCreateRequest()
+        create_watch.key = utils.to_bytes(key)
+        if range_end is not None:
+            create_watch.range_end = utils.to_bytes(range_end)
+        if start_revision is not None:
+            create_watch.start_revision = start_revision
+        if progress_notify:
+            create_watch.progress_notify = progress_notify
+        if filters is not None:
+            create_watch.filters.extend(filters)
+        if prev_kv:
+            create_watch.prev_kv = prev_kv
+        return etcdrpc.WatchRequest(create_request=create_watch)
+
+    def add_callback(
+        self,
+        key,
+        callback,
+        range_end=None,
+        start_revision=None,
+        progress_notify=False,
+        filters=None,
+        prev_kv=False,
+    ):
+        rq = self._create_watch_request(
+            key,
+            range_end=range_end,
+            start_revision=start_revision,
+            progress_notify=progress_notify,
+            filters=filters,
+            prev_kv=prev_kv,
+        )
+
+        with self._lock:
+            # Wait for exiting thread to close
+            if self._stopping:
+                self._callback_thread.join()
+                self._callback_thread = None
+                self._stopping = False
+
+            # Start the callback thread if it is not yet running.
+            if not self._callback_thread:
+                thread_name = "etcd3_watch_%x" % (id(self),)
+                self._callback_thread = threading.Thread(
+                    name=thread_name, target=self._run
+                )
+                self._callback_thread.daemon = True
+                self._callback_thread.start()
+
+            # Only one create watch request can be pending at a time, so if
+            # there one already, then wait for it to complete first.
+            while self._new_watch:
+                self._new_watch_cond.wait()
+
+            # Submit a create watch request.
+            new_watch = _NewWatch(callback)
+            self._request_queue.put(rq)
+            self._new_watch = new_watch
+
+            try:
+                # Wait for the request to be completed, or timeout.
+                # Use a loop to handle spurious wakeups (Mesa semantics)
+                wait_deadline = time.time() + self.timeout if self.timeout else None
+                while new_watch.id is None and new_watch.err is None:
+                    if wait_deadline is not None:
+                        remaining = wait_deadline - time.time()
+                        if remaining <= 0:
+                            break
+                        self._new_watch_cond.wait(timeout=remaining)
+                    else:
+                        self._new_watch_cond.wait()
+
+                # If the request not completed yet, then raise a timeout
+                # exception.
+                if new_watch.id is None and new_watch.err is None:
+                    raise exceptions.WatchTimedOut()
+
+                # Raise an exception if the watch request failed.
+                if new_watch.err:
+                    raise new_watch.err
+            finally:
+                # Wake up threads stuck on add_callback call if any.
+                self._new_watch = None
+                self._new_watch_cond.notify_all()
+
+            return new_watch.id
+
+    def cancel(self, watch_id):
+        with self._lock:
+            callback = self._callbacks.pop(watch_id, None)
+            if not callback:
+                return
+
+            self._cancel_no_lock(watch_id)
+
+    def _run(self):
+        callback_err = None
+        try:
+            response_iter = self._watch_stub.Watch(
+                _new_request_iter(self._request_queue),
+                credentials=self._credentials,
+                metadata=self._metadata,
+            )
+            for rs in response_iter:
+                self._handle_response(rs)
+
+        except grpc.RpcError as err:
+            callback_err = err
+
+        finally:
+            with self._lock:
+                self._stopping = True
+                if self._new_watch:
+                    self._new_watch.err = callback_err
+                    self._new_watch_cond.notify_all()
+
+                callbacks = self._callbacks
+                self._callbacks = {}
+
+                # Rotate request queue. This way we can terminate one gRPC
+                # stream and initiate another one whilst avoiding a race
+                # between them over requests in the queue.
+                self._request_queue.put(None)
+                self._request_queue = queue.Queue(maxsize=10)
+
+            for callback in callbacks.values():
+                _safe_callback(callback, callback_err)
+
+    def _handle_response(self, rs):
+        with self._lock:
+            if rs.created:
+                # Store reference locally to avoid race with other threads
+                new_watch = self._new_watch
+
+                # If the new watch request has already expired then cancel the
+                # created watch right away.
+                if not new_watch:
+                    self._cancel_no_lock(rs.watch_id)
+                    return
+
+                if rs.compact_revision != 0:
+                    new_watch.err = exceptions.RevisionCompactedError(
+                        rs.compact_revision
+                    )
+                    return
+
+                self._callbacks[rs.watch_id] = new_watch.callback
+                new_watch.id = rs.watch_id
+                self._new_watch_cond.notify_all()
+
+            callback = self._callbacks.get(rs.watch_id)
+
+        # Ignore leftovers from canceled watches.
+        if not callback:
+            return
+
+        # The watcher can be safely reused, but adding a new event
+        # to indicate that the revision is already compacted
+        # requires api change which would break all users of this
+        # module. So, raising an exception if a watcher is still
+        # alive.
+        if rs.compact_revision != 0:
+            err = exceptions.RevisionCompactedError(rs.compact_revision)
+            _safe_callback(callback, err)
+            self.cancel(rs.watch_id)
+            return
+
+        # Call the callback even when there are no events in the watch
+        # response so as not to ignore progress notify responses.
+        if rs.events or not (rs.created or rs.canceled):
+            new_events = [events.new_event(event) for event in rs.events]
+            response = WatchResponse(rs.header, new_events)
+            _safe_callback(callback, response)
+
+    def _cancel_no_lock(self, watch_id):
+        cancel_watch = etcdrpc.WatchCancelRequest()
+        cancel_watch.watch_id = watch_id
+        rq = etcdrpc.WatchRequest(cancel_request=cancel_watch)
+        self._request_queue.put(rq)
+
+    def close(self):
+        with self._lock:
+            if self._callback_thread and not self._stopping:
+                self._request_queue.put(None)
+
+
+class WatchResponse(object):
+    def __init__(self, header, events):
+        self.header = header
+        self.events = events
+
+
+class _NewWatch(object):
+    def __init__(self, callback):
+        self.callback = callback
+        self.id = None
+        self.err = None
+
+
+def _new_request_iter(_request_queue):
+    while True:
+        rq = _request_queue.get()
+        if rq is None:
+            return
+
+        yield rq
+
+
+def _safe_callback(callback, response_or_err):
+    try:
+        callback(response_or_err)
+
+    except Exception:
+        _log.exception("Watch callback failed")

etcdrpc/__init__.py

@@ -0,0 +1,16 @@
+"""etcdrpc package - uses pre-generated protobuf files."""
+
+# 简单的检查，如果文件不存在则报错提示（防御性编程）
+from pathlib import Path
+_current_dir = Path(__file__).parent
+if not (_current_dir / "rpc_pb2.py").exists():
+    raise ImportError(
+        "Protobuf modules not found. This package might be incorrectly installed."
+    )
+
+# 扁平化导出
+from etcdrpc.rpc_pb2 import *
+from etcdrpc.rpc_pb2_grpc import *
+
+# 获取所有非私有成员
+__all__ = [name for name in globals().keys() if not name.startswith('_')]

etcdrpc/auth.proto

@@ -0,0 +1,49 @@
+//
+// Copyright 2016-2021 The jetcd authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+syntax = "proto3";
+
+package authpb;
+
+option java_multiple_files = true;
+option java_package = "io.etcd.jetcd.api";
+
+// User is a single entry in the bucket authUsers
+message User {
+  bytes name = 1;
+  bytes password = 2;
+  repeated string roles = 3;
+}
+
+// Permission is a single entity
+message Permission {
+  enum Type {
+    READ = 0;
+    WRITE = 1;
+    READWRITE = 2;
+  }
+  Type permType = 1;
+
+  bytes key = 2;
+  bytes range_end = 3;
+}
+
+// Role is a single entry in the bucket authRoles
+message Role {
+  bytes name = 1;
+
+  repeated Permission keyPermission = 2;
+}

etcdrpc/auth_pb2.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: etcdrpc/auth.proto
+# Protobuf Python Version: 6.31.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    1,
+    '',
+    'etcdrpc/auth.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x12\x65tcdrpc/auth.proto\x12\x06\x61uthpb\"5\n\x04User\x12\x0c\n\x04name\x18\x01 \x01(\x0c\x12\x10\n\x08password\x18\x02 \x01(\x0c\x12\r\n\x05roles\x18\x03 \x03(\t\"\x83\x01\n\nPermission\x12)\n\x08permType\x18\x01 \x01(\x0e\x32\x17.authpb.Permission.Type\x12\x0b\n\x03key\x18\x02 \x01(\x0c\x12\x11\n\trange_end\x18\x03 \x01(\x0c\"*\n\x04Type\x12\x08\n\x04READ\x10\x00\x12\t\n\x05WRITE\x10\x01\x12\r\n\tREADWRITE\x10\x02\"?\n\x04Role\x12\x0c\n\x04name\x18\x01 \x01(\x0c\x12)\n\rkeyPermission\x18\x02 \x03(\x0b\x32\x12.authpb.PermissionB\x15\n\x11io.etcd.jetcd.apiP\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'etcdrpc.auth_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\021io.etcd.jetcd.apiP\001'
+  _globals['_USER']._serialized_start=30
+  _globals['_USER']._serialized_end=83
+  _globals['_PERMISSION']._serialized_start=86
+  _globals['_PERMISSION']._serialized_end=217
+  _globals['_PERMISSION_TYPE']._serialized_start=175
+  _globals['_PERMISSION_TYPE']._serialized_end=217
+  _globals['_ROLE']._serialized_start=219
+  _globals['_ROLE']._serialized_end=282
+# @@protoc_insertion_point(module_scope)

etcdrpc/auth_pb2.pyi

@@ -0,0 +1,44 @@
+from google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Iterable as _Iterable, Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class User(_message.Message):
+    __slots__ = ("name", "password", "roles")
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    PASSWORD_FIELD_NUMBER: _ClassVar[int]
+    ROLES_FIELD_NUMBER: _ClassVar[int]
+    name: bytes
+    password: bytes
+    roles: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, name: _Optional[bytes] = ..., password: _Optional[bytes] = ..., roles: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class Permission(_message.Message):
+    __slots__ = ("permType", "key", "range_end")
+    class Type(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+        __slots__ = ()
+        READ: _ClassVar[Permission.Type]
+        WRITE: _ClassVar[Permission.Type]
+        READWRITE: _ClassVar[Permission.Type]
+    READ: Permission.Type
+    WRITE: Permission.Type
+    READWRITE: Permission.Type
+    PERMTYPE_FIELD_NUMBER: _ClassVar[int]
+    KEY_FIELD_NUMBER: _ClassVar[int]
+    RANGE_END_FIELD_NUMBER: _ClassVar[int]
+    permType: Permission.Type
+    key: bytes
+    range_end: bytes
+    def __init__(self, permType: _Optional[_Union[Permission.Type, str]] = ..., key: _Optional[bytes] = ..., range_end: _Optional[bytes] = ...) -> None: ...
+
+class Role(_message.Message):
+    __slots__ = ("name", "keyPermission")
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    KEYPERMISSION_FIELD_NUMBER: _ClassVar[int]
+    name: bytes
+    keyPermission: _containers.RepeatedCompositeFieldContainer[Permission]
+    def __init__(self, name: _Optional[bytes] = ..., keyPermission: _Optional[_Iterable[_Union[Permission, _Mapping]]] = ...) -> None: ...

etcdrpc/auth_pb2_grpc.py

@@ -0,0 +1,24 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+
+GRPC_GENERATED_VERSION = '1.76.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + ' but the generated code in etcdrpc/auth_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )

etcdrpc/kv.proto

@@ -0,0 +1,43 @@
+syntax = "proto3";
+
+package mvccpb;
+
+
+message KeyValue {
+  // key is the key in bytes. An empty key is not allowed.
+  bytes key = 1;
+  // create_revision is the revision of last creation on this key.
+  int64 create_revision = 2;
+  // mod_revision is the revision of last modification on this key.
+  int64 mod_revision = 3;
+  // version is the version of the key. A deletion resets
+  // the version to zero and any modification of the key
+  // increases its version.
+  int64 version = 4;
+  // value is the value held by the key, in bytes.
+  bytes value = 5;
+  // lease is the ID of the lease that attached to key.
+  // When the attached lease expires, the key will be deleted.
+  // If lease is 0, then no lease is attached to the key.
+  int64 lease = 6;
+}
+
+message Event {
+  enum EventType {
+    PUT = 0;
+    DELETE = 1;
+  }
+  // type is the kind of event. If type is a PUT, it indicates
+  // new data has been stored to the key. If type is a DELETE,
+  // it indicates the key was deleted.
+  EventType type = 1;
+  // kv holds the KeyValue for the event.
+  // A PUT event contains current kv pair.
+  // A PUT event with kv.Version=1 indicates the creation of a key.
+  // A DELETE/EXPIRE event contains the deleted key with
+  // its modification revision set to the revision of deletion.
+  KeyValue kv = 2;
+
+  // prev_kv holds the key-value pair before the event happens.
+  KeyValue prev_kv = 3;
+}

etcdrpc/kv_pb2.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: etcdrpc/kv.proto
+# Protobuf Python Version: 6.31.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    1,
+    '',
+    'etcdrpc/kv.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10\x65tcdrpc/kv.proto\x12\x06mvccpb\"u\n\x08KeyValue\x12\x0b\n\x03key\x18\x01 \x01(\x0c\x12\x17\n\x0f\x63reate_revision\x18\x02 \x01(\x03\x12\x14\n\x0cmod_revision\x18\x03 \x01(\x03\x12\x0f\n\x07version\x18\x04 \x01(\x03\x12\r\n\x05value\x18\x05 \x01(\x0c\x12\r\n\x05lease\x18\x06 \x01(\x03\"\x91\x01\n\x05\x45vent\x12%\n\x04type\x18\x01 \x01(\x0e\x32\x17.mvccpb.Event.EventType\x12\x1c\n\x02kv\x18\x02 \x01(\x0b\x32\x10.mvccpb.KeyValue\x12!\n\x07prev_kv\x18\x03 \x01(\x0b\x32\x10.mvccpb.KeyValue\" \n\tEventType\x12\x07\n\x03PUT\x10\x00\x12\n\n\x06\x44\x45LETE\x10\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'etcdrpc.kv_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_KEYVALUE']._serialized_start=28
+  _globals['_KEYVALUE']._serialized_end=145
+  _globals['_EVENT']._serialized_start=148
+  _globals['_EVENT']._serialized_end=293
+  _globals['_EVENT_EVENTTYPE']._serialized_start=261
+  _globals['_EVENT_EVENTTYPE']._serialized_end=293
+# @@protoc_insertion_point(module_scope)