ó ,áÒNc@sidZddlZddlZddlZddlZddlZyddlZWnek rqddlZnXddl m Z d„Z e a d„Z y ddlmZmZeZWn ek rÜeZd„ZnXyddlmZWn!ek rddlmZnXd Zd Zd Zd Zd ZddZdefd„ƒYZdefd„ƒYZyddlm Z Wn'ek r¦de!fd„ƒYZ nXdZ"dZ#de fd„ƒYZ$de!fd„ƒYZ%d„Z&e'dkreda(dGHe&ƒd GHHd!ggZ)d"ej*krOe)j+ej,j-ej.ƒd#ƒgƒnxâe)D]ÚZ/e$e/d$d%ƒZ0d&„Z1d'„Z2d(e!fd)„ƒYZ3e2d*d+ƒe2d,d-ƒe2d.e4d%d>ƒƒr'd/Ge0j5d.ƒräd0GHnd1GHt(d%a(d2GHe0j6d.ƒe7krd0GHnd1GHt(d%a(nd3Ge0j8d*d,gƒGHd4Ge1e0j6d5ƒƒGHe3ƒZ9e2d6e9ƒd7Ge0j:d,d%ƒZ;e;d8kr—d0GHnd1GHt(d%a(d9Ge0j<d,d%ƒZ;e;d-krÐd0GHnd1GHt(d%a(ej=j>ƒd:Gej=j>ƒye0j?d;d%ƒZ;Wne$j@k r0ZAd0GHnXd1GHt(d%a(d<Gye0j?d=d%ƒZ;Wne$j@k rwZAd0GHnXd1GHt(d%a(d>Gye0j?d?ed%ƒZ;Wn%e$jBk rÌZAd1GHt(d%a(nXd0GHye0j?d?ed?d%ƒZ;Wne$jBk r ZAd0GHnXd1GHt(d%a(d@Gye0j?dAd%ƒZ;Wne$jCk rSZAd0GnXd1Gt(d%a(y#e0j?dBejDdCƒd%ƒZ;Wnd1Gt(d%a(nXd0GddlZejEdDƒZFy#e0j?eFejDdCƒd%ƒZ;Wne$jBk rúd0GHnXd1GHt(d%a(dEGe0j?dFd?eƒZ;e0j6dFƒe7kr@d0Gnd1Gt(d%a(e0j?dFd?edGƒZ;e0j6dFƒe7kr…d0GHnd1GHt(d%a(dHGe0jGƒe0jHid?dF6dIdJ6ƒZIeIgkrÝd1GHt(d%a(nd0GHdKGe0jGƒe0jJid?dF6dIdJ6ƒZKeKd%kr+d1GHt(d%a(nd0GHqVWt(dkrUdLGHejLd%ƒnejLdƒndS(MsÒ client module for memcached (memory cache daemon) Overview ======== See U{the MemCached homepage} for more about memcached. Usage summary ============= This should give you a feel for how this module operates:: import memcache mc = memcache.Client(['127.0.0.1:11211'], debug=0) mc.set("some_key", "Some value") value = mc.get("some_key") mc.set("another_key", 3) mc.delete("another_key") mc.set("key", "1") # note that the key used for incr/decr must be a string. mc.incr("key") mc.decr("key") The standard way to use memcache with a database is like this:: key = derive_key(obj) obj = mc.get(key) if not obj: obj = backend_api.get(...) mc.set(key, obj) # we now have obj, and future passes through this code # will use the object from the cache. Detailed Documentation ====================== More detailed documentation is available in the L{Client} class. iÿÿÿÿN(tcrc32cCst|ƒd@d?d@pdS(Nlÿÿiiÿi(R(tkey((s ./memcache.pytcmemcache_hash9scCs tadS(s1Use the old python-memcache server hash function.N(RtserverHashFunction(((s ./memcache.pytuseOldServerHashFunction=s(tcompresst decompresscCstdƒ‚dS(NsGreceived compressed data but I don't support compression (import error)(t_Error(tval((s ./memcache.pyRHs(tStringIOs-Sean Reifschneider s1.48s$Copyright (C) 2003 Danga Interactives"Python Software Foundation LicenseiúiRcBseZRS((t__name__t __module__(((s ./memcache.pyR_st_ConnectionDeadErrorcBseZRS((R R (((s ./memcache.pyR cs(tlocalR cBseZRS((R R (((s ./memcache.pyR lsiitClientc Bs`eZdZd6Zd7Zd8Zd9ZdZdefd„ƒYZ de fd „ƒYZ d e fd „ƒYZ d e fd „ƒYZ de fd„ƒYZ defd„ƒYZddejejd:d:eeeeed„ Zd„Zd„Zd:d„Zd„Zd„Zd„Zd„Zd„Z d„Z!d„Z"d„Z#ddd„Z$dd „Z%dd!„Z&dd"„Z'd#„Z(ddd$„Z)ddd%„Z*ddd&„Z+ddd'„Z,ddd(„Z-ddd)„Z.d*„Z/dddd+„Z0d,„Z1dd-„Z2d.„Z3d/„Z4d0„Z5dd1„Z6d:d2„Z7d:d3„Z8d4„Z9dd5„Z:RS(;s¤ Object representing a pool of memcache servers. See L{memcache} for an overview. In all cases where a key is used, the key can be either: 1. A simple hashable type (string, integer, etc.). 2. A tuple of C{(hashvalue, key)}. This is useful if you want to avoid making this module calculate a hash value. You may prefer, for example, to keep all of a given user's objects on the same memcache server, so you could use the user's unique id as the hash value. @group Setup: __init__, set_servers, forget_dead_hosts, disconnect_all, debuglog @group Insertion: set, add, replace, set_multi @group Retrieval: get, get_multi @group Integers: incr, decr @group Removal: delete, delete_multi @sort: __init__, set_servers, forget_dead_hosts, disconnect_all, debuglog, set, set_multi, add, replace, get, get_multi, incr, decr, delete, delete_multi iiiii tMemcachedKeyErrorcBseZRS((R R (((s ./memcache.pyR‘stMemcachedKeyLengthErrorcBseZRS((R R (((s ./memcache.pyR“stMemcachedKeyCharacterErrorcBseZRS((R R (((s ./memcache.pyR•stMemcachedKeyNoneErrorcBseZRS((R R (((s ./memcache.pyR—stMemcachedKeyTypeErrorcBseZRS((R R (((s ./memcache.pyR™stMemcachedStringEncodingErrorcBseZRS((R R (((s ./memcache.pyR›sc Csßtj|ƒ||_| |_| |_|j|ƒi|_| |_|jƒ||_ ||_ ||_ ||_ ||_ ||_| |_tƒ} y%|j | d|j ƒ}t|_Wntk rÚt|_nXdS(s Create a new Client object with the given list of servers. @param servers: C{servers} is passed to L{set_servers}. @param debug: whether to display error messages when a server can't be contacted. @param pickleProtocol: number to mandate protocol used by (c)Pickle. @param pickler: optional override of default Pickler to allow subclassing. @param unpickler: optional override of default Unpickler to allow subclassing. @param pload: optional persistent_load function to call on pickle loading. Useful for cPickle since subclassing isn't allowed. @param pid: optional persistent_id function to call on pickle storing. Useful for cPickle since subclassing isn't allowed. @param dead_retry: number of seconds before retrying a blacklisted server. Default to 30 s. @param socket_timeout: timeout in seconds for all calls to a server. Defaults to 3 seconds. @param cache_cas: (default False) If true, cas operations will be cached. WARNING: This cache is not expired internally, if you have a long-running process you will need to expire it manually via "client.reset_cas(), or the cache can grow unlimited. @param server_max_key_length: (default SERVER_MAX_KEY_LENGTH) Data that is larger than this will not be sent to the server. @param server_max_value_length: (default SERVER_MAX_VALUE_LENGTH) Data that is larger than this will not be sent to the server. tprotocolN(R t__init__tdebugt dead_retrytsocket_timeoutt set_serverststatst cache_cast reset_castpickleProtocoltpicklert unpicklertpersistent_loadt persistent_idtserver_max_key_lengthtserver_max_value_lengthR tTruetpicklerIsKeywordt TypeErrortFalse(tselftserversRRRR tploadtpidR#R$RRRtfile((s ./memcache.pyRžs*!                  cCs i|_dS(sö Reset the cas cache. This is only used if the Client() object was created with "cache_cas=True". If used, this cache does not expire internally, so it can grow unbounded if you do not clear it yourself. N(tcas_ids(R)((s ./memcache.pyRÙsc CsHg|D]*}t||jd|jd|jƒ^q|_|jƒdS(sd Set the pool of servers used by this client. @param servers: an array of servers. Servers can be passed in two forms: 1. Strings of the form C{"host:port"}, which implies a default weight of 1. 2. Tuples of the form C{("host:port", weight)}, where C{weight} is an integer weight value. RRN(t_HostRRRR*t _init_buckets(R)R*ts((s ./memcache.pyRãs 7c Csg}x|jD]ø}|jƒs(qn|jtjkrYd|j|j|jf}nd|j|jf}|s…|j dƒn|j d|ƒi}|j ||fƒ|j }xM|ƒ}| sÝ|j ƒdkráPn|j ddƒ}|d||dtlineR((s ./memcache.pyt get_statsòs(    c Cs5g}x(|jD]}|jƒs(qn|jtjkrYd|j|j|jf}nd|j|jf}i}|j ||fƒ|j dƒ|j }xŒ|ƒ}| sÃ|j ƒdkrÇPn|j ddƒ}|dj ddƒ}|d|kri||dR?R@( R)RBR1RCRDR>REtitemtslab((s ./memcache.pyt get_slabss*    !cCsDx=|jD]2}|jƒs"q n|jdƒ|jdƒq WdS(s2Expire all data currently in the memcache servers.t flush_alltOKN(R*R4R<texpect(R)R1((s ./memcache.pyRK+s   cCs$|jr tjjd|ƒndS(NsMemCached: %s (Rtsyststderrtwrite(R)tstr((s ./memcache.pytdebuglog2s cCs6||jkrd|j|tjk r} d}t | t ƒrÿ| d} n|j | ƒ|j|ƒq>Xq>Wx|D] }||=q(Wx„|j ƒD]v\}}y"x|D]} |j dƒq\WWqFtjk r»} t | t ƒr¥| d} n|j | ƒd}qFXqFW|S( sÕ Delete multiple keys in the memcache doing just one query. >>> notset_keys = mc.set_multi({'key1' : 'val1', 'key2' : 'val2'}) >>> mc.get_multi(['key1', 'key2']) == {'key1' : 'val1', 'key2' : 'val2'} 1 >>> mc.delete_multi(['key1', 'key2']) 1 >>> mc.get_multi(['key1', 'key2']) == {} 1 This method is recommended over iterated regular L{delete}s as it reduces total latency, since your app doesn't have to wait for each round-trip of L{delete} before sending the next one. @param keys: An iterable of keys to clear @param time: number of seconds any subsequent set / update commands should fail. Defaults to 0 for no delay. @param key_prefix: Optional string to prepend to each key when sending to memcache. See docs for L{get_multi} and L{set_multi}. @return: 1 if no failure in communication with any memcacheds. @rtype: int t delete_multiisdelete %s %d s delete %s RditDELETEDN(RTt_map_and_prefix_keystiterkeysR=R_t send_cmdstjoinR6terrorR[R\t mark_deadt iteritemsRM( R)tkeysttimet key_prefixt server_keystprefixed_to_orig_keyt dead_serverstrcRYtbigcmdRPRtmsg((s ./memcache.pyRe[s@          cCs|j|ƒ|j|ƒ\}}|s,dS|jdƒ|d krd|dkrdd||f}n d|}yP|j|ƒ|jƒ}|r¦|jƒd kr¦dS|jdt|ƒƒWn?t j k rÿ}t |t ƒrï|d}n|j |ƒnXdS( sãDeletes a key from the memcache. @return: Nonzero on success. @param time: number of seconds any subsequent set / update commands should fail. Defaults to None for no delay. @rtype: int itdeletes delete %s %ds delete %sRft NOT_FOUNDis-Delete expected DELETED or NOT_FOUND, got: %sN(sDELETEDRx(t check_keyRaRTR_R<R>R?RRtreprR6RkR[R\Rl(R)RRoRYtcmdRERv((s ./memcache.pyRws(       cCs|jd||ƒS(s; Sends a command to the server to atomically increment the value for C{key} by C{delta}, or by 1 if C{delta} is unspecified. Returns None if C{key} doesn't exist on server, otherwise it returns the new value after incrementing. Note that the value for C{key} must already exist in the memcache, and it must be the string representation of an integer. >>> mc.set("counter", "20") # returns 1, indicating success 1 >>> mc.incr("counter") 21 >>> mc.incr("counter") 22 Overflow on server is not checked. Be aware of values approaching 2**32. See L{decr}. @param delta: Integer amount to increment by (should be zero or greater). @return: New value after incrementing. @rtype: int tincr(t _incrdecr(R)Rtdelta((s ./memcache.pyR|ºscCs|jd||ƒS(sV Like L{incr}, but decrements. Unlike L{incr}, underflow is checked and new values are capped at 0. If server value is 1, a decrement of 2 returns 0, not -1. @param delta: Integer amount to decrement by (should be zero or greater). @return: New value after decrementing. @rtype: int tdecr(R}(R)RR~((s ./memcache.pyRÔs cCsÜ|j|ƒ|j|ƒ\}}|s,dS|j|ƒd|||f}yI|j|ƒ|jƒ}|dks†|jƒdkrŠdSt|ƒSWn@tj k r×}t |t ƒrÆ|d}n|j |ƒdSXdS(Nis%s %s %dRxi( RyRaRTR<R>R_R?tintR6RkR[R\Rl(R)R{RR~RYRERv((s ./memcache.pyR}às"      cCs|jd||||ƒS(s· Add new key with value. Like L{set}, but only stores in memcache if the key doesn't already exist. @return: Nonzero on success. @rtype: int tadd(t_set(R)RRRotmin_compress_len((s ./memcache.pyRñs cCs|jd||||ƒS(sÐAppend the value to the end of the existing key's value. Only stores in memcache if key already exists. Also see L{prepend}. @return: Nonzero on success. @rtype: int R=(R‚(R)RRRoRƒ((s ./memcache.pyR=üs cCs|jd||||ƒS(sÖPrepend the value to the beginning of the existing key's value. Only stores in memcache if key already exists. Also see L{append}. @return: Nonzero on success. @rtype: int tprepend(R‚(R)RRRoRƒ((s ./memcache.pyR„s cCs|jd||||ƒS(sÐReplace existing key with value. Like L{set}, but only stores in memcache if the key already exists. The opposite of L{add}. @return: Nonzero on success. @rtype: int treplace(R‚(R)RRRoRƒ((s ./memcache.pyR…s cCs|jd||||ƒS(sRUnconditionally sets a key to a given value in the memcache. The C{key} can optionally be an tuple, with the first element being the server hash value and the second being the key. If you want to avoid making this module calculate a hash value. You may prefer, for example, to keep all of a given user's objects on the same memcache server, so you could use the user's unique id as the hash value. @return: Nonzero on success. @rtype: int @param time: Tells memcached the time which this value should expire, either as a delta number of seconds, or an absolute unix time-since-the-epoch value. See the memcached protocol docs section "Storage Commands" for more info on . We default to 0 == cache forever. @param min_compress_len: The threshold length to kick in auto-compression of the value using the zlib.compress() routine. If the value being cached is a string, then the length of the string is measured, else if the value is an object, then the length of the pickle result is measured. If the resulting attempt at compression yeilds a larger string than the input, then it is discarded. For backwards compatability, this parameter defaults to 0, indicating don't ever try to compress. tset(R‚(R)RRRoRƒ((s ./memcache.pyR†scCs|jd||||ƒS(s–Sets a key to a given value in the memcache if it hasn't been altered since last fetched. (See L{gets}). The C{key} can optionally be an tuple, with the first element being the server hash value and the second being the key. If you want to avoid making this module calculate a hash value. You may prefer, for example, to keep all of a given user's objects on the same memcache server, so you could use the user's unique id as the hash value. @return: Nonzero on success. @rtype: int @param time: Tells memcached the time which this value should expire, either as a delta number of seconds, or an absolute unix time-since-the-epoch value. See the memcached protocol docs section "Storage Commands" for more info on . We default to 0 == cache forever. @param min_compress_len: The threshold length to kick in auto-compression of the value using the zlib.compress() routine. If the value being cached is a string, then the length of the string is measured, else if the value is an object, then the length of the pickle result is measured. If the resulting attempt at compression yeilds a larger string than the input, then it is discarded. For backwards compatability, this parameter defaults to 0, indicating don't ever try to compress. tcas(R‚(R)RRRoRƒ((s ./memcache.pyR‡8sc Cst|ƒ}|r"|j|ƒni}i}xË|D]Ã}t|tƒr€t|dƒ}|j|d||fƒ\}} n%t|ƒ}|j||ƒ\}} |j|d|ƒ|sÄq5n||krÝg|| list of keys to stuff onto that server, as well as the mapping of prefixed key -> original key. iit key_extra_len(R^RyR[R\RQRaR=( R)t key_iterableRpRˆRqRrtorig_keyt str_orig_keyRYR((s ./memcache.pyRgVs&  &   c Cs |jdƒ|j|jƒ|ƒ\}}g}g}xþ|jƒD]ð} g} | j} yŒxo|| D]c} |j||| |ƒ} | r¹| d| | d|| d| dfƒqg|j|| ƒqgW| jdj| ƒƒWqDtjk r3}t |t ƒr|d}n| j |ƒ|j| ƒqDXqDWx|D] } || =q?W|s`|j ƒSx¦|j ƒD]˜\} }yDx=|D]5} | jƒ}|dkr§qƒqƒ|j|| ƒqƒWWqmttjfk r}t |t ƒrô|d}n| j |ƒqmXqmW|S(sà Sets multiple keys in the memcache doing just one query. >>> notset_keys = mc.set_multi({'key1' : 'val1', 'key2' : 'val2'}) >>> mc.get_multi(['key1', 'key2']) == {'key1' : 'val1', 'key2' : 'val2'} 1 This method is recommended over regular L{set} as it lowers the number of total packets flying around your network, reducing total latency, since your app doesn't have to wait for each round-trip of L{set} before sending the next one. @param mapping: A dict of key/value pairs to set. @param time: Tells memcached the time which this value should expire, either as a delta number of seconds, or an absolute unix time-since-the-epoch value. See the memcached protocol docs section "Storage Commands" for more info on . We default to 0 == cache forever. @param key_prefix: Optional string to prepend to each key when sending to memcache. Allows you to efficiently stuff these keys into a pseudo-namespace in memcache: >>> notset_keys = mc.set_multi({'key1' : 'val1', 'key2' : 'val2'}, key_prefix='subspace_') >>> len(notset_keys) == 0 True >>> mc.get_multi(['subspace_key1', 'subspace_key2']) == {'subspace_key1' : 'val1', 'subspace_key2' : 'val2'} True Causes key 'subspace_key1' and 'subspace_key2' to be set. Useful in conjunction with a higher-level layer which applies namespaces to data in memcache. In this case, the return result would be the list of notset original keys, prefix not applied. @param min_compress_len: The threshold length to kick in auto-compression of the value using the zlib.compress() routine. If the value being cached is a string, then the length of the string is measured, else if the value is an object, then the length of the pickle result is measured. If the resulting attempt at compression yeilds a larger string than the input, then it is discarded. For backwards compatability, this parameter defaults to 0, indicating don't ever try to compress. @return: List of keys which failed to be stored [ memcache out of memory, etc. ]. @rtype: list t set_multisset %s %d %d %d %s iiiRdtSTORED(RTRgRhR=t_val_to_store_infoRiRjR6RkR[R\RlRnRmR>R(R)tmappingRoRpRƒRqRrRst notstoredRYRuRPRt store_infoRvRnRE((s ./memcache.pyRŒ}sL)             cCsŒd}t|tƒrnÞt|tƒrG|tjO}d|}d}n¯t|tƒrv|tjO}d|}d}n€|tjO}tƒ}|j r°|j |d|j ƒ}n|j ||j ƒ}|j rÝ|j |_ n|j |ƒ|jƒ}t|ƒ}|rQtrQ||krQt|ƒ}t|ƒ|krQ|tjO}|}qQn|jdkryt|ƒ|jkrydS|t|ƒ|fS(s— Transform val to a storable representation, returning a tuple of the flags, the length of the new value, and the new value itself. is%dR(R[RQR€Rt _FLAG_INTEGERtlongt _FLAG_LONGt _FLAG_PICKLER R&RRR"tdumptgetvalueR^t_supports_compressRt_FLAG_COMPRESSEDR$(R)RRƒtflagsR-Rtlvtcomp_val((s ./memcache.pyRŽÕs<                cs²ˆjˆƒˆjˆƒ\‰‰ˆs,dS‡‡‡‡‡‡‡fd†}y |ƒSWnStk r­yˆjƒ|ƒSWn)ttjfk r¨}ˆj|ƒnXdSXdS(Nic s$ˆjˆƒˆjˆˆƒ}|s)dSˆdkr’ˆˆjkr]ˆjdˆˆˆˆƒSdˆˆ|dˆ|dˆjˆ|df}n(dˆˆ|dˆ|d|df}y$ˆj|ƒˆjdƒdkSWn?tjk r}t|t ƒr|d}nˆj |ƒnXdS( NiR‡R†s%s %s %d %d %d %d %siis%s %s %d %d %d %sR( RTRŽR.R‚R<RMR6RkR[R\Rl(R‘tfullcmdRv(RƒRR)R{RYRRo(s ./memcache.pyt _unsafe_set s(  %  (RyRaR t _get_socketR6RkRl(R)R{RRRoRƒRžRv((RƒRR)R{RYRRos ./memcache.pyR‚s !    cs¯ˆjˆƒˆjˆƒ\‰‰ˆs,dS‡‡‡‡fd†}y |ƒSWnYtk rªyˆjƒru|ƒSdSWn)ttjfk r¥}ˆj|ƒnXdSXdS(Ncsˆjˆƒyˆjdˆˆfƒd}}}}ˆdkr‚ˆjˆƒ\}}}}|ršˆjrš|ˆj|>> success = mc.set("foo", "bar") >>> success = mc.set("baz", 42) >>> mc.get_multi(["foo", "baz", "foobar"]) == {"foo": "bar", "baz": 42} 1 >>> mc.set_multi({'k1' : 1, 'k2' : 2}, key_prefix='pfx_') == [] 1 This looks up keys 'pfx_k1', 'pfx_k2', ... . Returned dict will just have unprefixed keys 'k1', 'k2'. >>> mc.get_multi(['k1', 'k2', 'nonexist'], key_prefix='pfx_') == {'k1' : 1, 'k2' : 2} 1 get_mult [ and L{set_multi} ] can take str()-ables like ints / longs as keys too. Such as your db pri key fields. They're rotored through str() before being passed off to memcache, with or without the use of a key_prefix. In this mode, the key_prefix could be a table name, and the key itself a db primary key number. >>> mc.set_multi({42: 'douglass adams', 46 : 'and 2 just ahead of me'}, key_prefix='numkeys_') == [] 1 >>> mc.get_multi([46, 42], key_prefix='numkeys_') == {42: 'douglass adams', 46 : 'and 2 just ahead of me'} 1 This method is recommended over regular L{get} as it lowers the number of total packets flying around your network, reducing total latency, since your app doesn't have to wait for each round-trip of L{get} before sending the next one. See also L{set_multi}. @param keys: An array of keys. @param key_prefix: A string to prefix each key when we communicate with memcache. Facilitates pseudo-namespaces within memcache. Returned dictionary keys will not have this prefix. @return: A dictionary of key/value pairs that were available. If key_prefix was provided, the keys in the retured dictionary will not have it present. t get_multisget %sR3iR2N(RTRgRhR<RjR6RkR[R\RlR=R>R¢R_R£R(R)RnRpRqRrRsRYRvtretvalsRER¤RšR¥R((s ./memcache.pyR«gs8& "       cCsp|s|jƒ}n|rh|d dkrh|jƒ\}}}}}|t|ƒt|ƒt|ƒfSdSdS(NitVALUE(NNNN(R>R@R€R_(R)RYREtrespR¤RšR^R¦((s ./memcache.pyR¡¯s "cCsp|s|jƒ}n|rh|d dkrh|jƒ\}}}}t|ƒ}t|ƒ}|||fSdSdS(NiR­(NNN(R>R@R€R_(R)RYRER®R¤RšR^R¥((s ./memcache.pyR¢¹s   c Csq|d7}|j|ƒ}t|ƒ|krJtdt|ƒ|fƒ‚nt|ƒ|kri|d }n|tj@r…t|ƒ}n|dks |tjkr©|}nÄ|tj@rÅt|ƒ}n¨|tj@rát |ƒ}nŒ|tj @r\yCt |ƒ}|j |ƒ}|j r$|j |_ n|jƒ}Wqmtk rX}|jd|ƒdSXn|jd|ƒ|S(Nis#received %d bytes when expecting %diþÿÿÿisPickle error: %s sunknown flags on get: %x (trecvR^RRR™RR’R€R”R“R•R R R!tloadt ExceptionRRR_( R)RYRšR¥tbufRR-R te((s ./memcache.pyR£Ås6         cCst|tƒr|d}n|s4tjdƒ‚nt|tƒrUtjdƒ‚nt|tƒsvtjdƒ‚nt|tƒr|j dkrÆt |ƒ||j krÆtj d|j ƒ‚nxG|D]<}t |ƒdks÷t |ƒdkrÍtj d ƒ‚qÍqÍWnd S( sµChecks sanity of key. Fails if: Key length is > SERVER_MAX_KEY_LENGTH (Raises MemcachedKeyLength). Contains control characters (Raises MemcachedKeyCharacterError). Is not a string (Raises MemcachedStringEncodingError) Is an unicode string (Raises MemcachedStringEncodingError) Is not a string (Raises MemcachedKeyError) Is None (Raises MemcachedKeyError) is Key is Nones`Keys must be str()'s, not unicode. Convert your unicode strings using mystring.encode(charset)!sKey must be str()'sisKey length is > %si!isControl characters not allowedN(R[R\RRtunicodeRRQRt basestringR#R^RtordR(R)RRˆtchar((s ./memcache.pyRyès$     $iiiiN(;R R t__doc__R•R’R”R™R]R±RRRRRRtpickletPicklert UnpicklerR_tSERVER_MAX_KEY_LENGTHtSERVER_MAX_VALUE_LENGTHt _DEAD_RETRYt_SOCKET_TIMEOUTR(RRRRFRJRKRRRTRVR0RaRcReRwR|RR}RR=R„R…R†R‡RgRŒRŽR‚R©RªR R«R¡R¢R£Ry(((s ./memcache.pyRtsj  5  !        B        'X . ) -   H #R/cBs†eZdeed„Zd„Zd„Zd„Zd„Zd„Z d„Z d„Z d „Z d „Z d „Zd „Zd „ZRS(icCsK||_||_||_t|tƒr<|\}|_n d|_tjd|ƒ}|srtjd|ƒ}n|stjd|ƒ}n|s¦td|ƒ‚n|j ƒ}|j dƒdkrãt j |_ |d|_nIt j|_ |d |_t|j d d ƒƒ|_|j|jf|_d |_d|_ d |_dS(Nis^(?Punix):(?P.*)$s5^(?Pinet):(?P[^:]+)(:(?P[0-9]+))?$s%^(?P[^:]+)(:(?P[0-9]+))?$s'Unable to parse connection string: "%s"tprototunixtpaththostR9iË+iRd(RRRR[R\R:tretmatcht ValueErrort groupdictRªR6tAF_UNIXR5R;R7R8R€R9RUR_tbuffer(R)RÃRRRtmthostData((s ./memcache.pyRs2            cCs$|jr tjjd|ƒndS(NsMemCached: %s (RRNRORP(R)RQ((s ./memcache.pyRR*s cCs/|jr"|jtjƒkr"dSd|_dS(Nii(RURo(R)((s ./memcache.pyt _check_dead.s cCs|jƒrdSdS(Nii(RŸ(R)((s ./memcache.pyR44s cCs;|jd||fƒtjƒ|j|_|jƒdS(Ns MemCache: %s: %s. Marking dead.(RRRoRRURb(R)treason((s ./memcache.pyRl9scCsö|jƒrdS|jr |jStj|jtjƒ}t|dƒrZ|j|jƒny|j|j ƒWnotj k r˜}|j d|ƒdStj k rß}t |tƒrÆ|d}n|j d|dƒdSX||_d|_|S(Nt settimeouts connect: %siRd(RÌR_R6R5t SOCK_STREAMthasattrRÎRR4R;ttimeoutRlRkR[R\RÉ(R)R1Rv((s ./memcache.pyRŸ>s(     cCs&|jr"|jjƒd|_ndS(N(R6tcloseR_(R)((s ./memcache.pyRbRs  cCs|jj|dƒdS(Ns (R6tsendall(R)R{((s ./memcache.pyR<WscCs|jj|ƒdS(s( cmds already has trailing 's applied N(R6RÓ(R)tcmds((s ./memcache.pyRiZscCsŒ|j}|jj}x[trr|jdƒ}|dkr=Pn|dƒ}|se|jƒtƒ‚n||7}qW||d|_|| S(Ns iii(RÉR6R¯R%tfindRbR (R)R²R¯tindexRB((s ./memcache.pyR>^s       cCs6|jƒ}||kr2|jd||fƒn|S(Ns2while expecting '%s', got unexpected response '%s'(R>RR(R)ttextRE((s ./memcache.pyRMos    cCs‘|jj}|j}xdt|ƒ|kr{|t|t|ƒdƒƒ}||7}|stdt|ƒ|fƒ‚qqW|||_|| S(Nis9Read %d bytes, expecting %d, read returned 0 length bytes(R6R¯RÉR^tmaxR(R)R¥tself_socket_recvR²tfoo((s ./memcache.pyR¯vs    cCsed}|jrd|j}n|jtjkrPd|jd|jd|fSd|j|fSdS(NRds (dead until %d)s inet:%s:%d%siis unix:%s%s(RUR5R6R7R;(R)td((s ./memcache.pyt__str__‚s  (R R R¾R¿RRRRÌR4RlRŸRbR<RiR>RMR¯RÜ(((s ./memcache.pyR/s !           cCsSddl}ddl}dg}t|ddƒ}i|d6}|j|d|ƒS(Niÿÿÿÿs127.0.0.1:11211Ritmctglobs(tdoctesttmemcacheRttestmod(RßRàR*RÝRÞ((s ./memcache.pyt_doctests   t__main__isTesting docstrings...sRunning tests:s127.0.0.1:11211s --do-unixsmemcached.socketRicCs+t|tƒs#d|t|ƒfSd|S(Ns%s (%s)s%s(R[Rµttype(R((s ./memcache.pytto_s¡scCsedt|ƒt|ƒfGtj||ƒtj|ƒ}||krNdGHdSdGHtdadSdS(NsTesting set/get {'%s': %s} ...RLitFAILi(RåRÝR†Rªtfailures(RRtnewval((s ./memcache.pyt test_setget¥s  t FooStructcBs#eZd„Zd„Zd„ZRS(cCs d|_dS(Ntbaz(tbar(R)((s ./memcache.pyR³scCsdS(Ns A FooStruct((R)((s ./memcache.pyRܵscCs#t|tƒr|j|jkSdS(Ni(R[RêRì(R)tother((s ./memcache.pyt__eq__·s(R R RRÜRî(((s ./memcache.pyRê²s  ta_stringssome random stringt an_integeri*R“sTesting delete ...RLRæsChecking results of delete ...sTesting get_multi ...sTesting get(unknown value) ...t unknown_valuet foostructsTesting incr ...i+sTesting decr ...sTesting sending spaces...sthis has spacess%Testing sending control characters...sthishascontrol characterss"Testing using insanely long key...tas'Testing sending a unicode-string key...ukeyhereuasutf-8s V\u4f1a p0 .s>Testing using a value larger than the memcached value limit...tkeyheretaaas.Testing set_multi() with no memcacheds runningtbtkeytheres1Testing delete_multi() with no memcacheds runnings*** THERE WERE FAILED TESTS(MR¸RNR6RotosRÄtcPickleR¹t ImportErrortbinasciiRRRRtzlibRRR%R˜R(t cStringIOR t __author__t __version__t __copyright__t __license__R¼R½R±RR t threadingR tobjectR¾R¿RR/RâR Rçt serverListtargvR=RÂRjtgetcwdR*RÝRåRéRêR“RwRªR_R«tfR|txRtstdouttflushR†RRvRRtencodetloadsR1RcRŒterrorsRetrettexit(((s ./memcache.pyt,sN              ÿÿÿ•‡   (                      # #