def __setitem__(self, key, value):
if not self.__dict__.has_key(key):
self.__keys__.append(key)
self.__sorted__ = False
UserDict.__setitem__(self, key, value)
def __setitem__(self, key, item):
""" inserts a key, value pair, converting all textual components to unicode and optionally removing junk from strings """
if self.cleanValues:
cleanItem = self.__toUnicode(item)
else:
cleanItem = item
UserDict.__setitem__(self, self.__keytransform(key), cleanItem)
def __setitem__(self, key, item):
if key == None:
raise Exception('I don\'t know how to handle None as a key.')
UserDict.__setitem__(self, key, item)
if self._preferred_order and key in self._preferred_order:
self._keys[self._preferred_order.index(key)] = key
elif key not in self._keys: self._keys.append(key)
def __ParseString(self, str, patt=_CookiePattern):
i = 0 # Our starting point
n = len(str) # Length of string
M = None # Current morsel
while 0 <= i < n:
# Start looking for a cookie
match = patt.search(str, i)
if not match: break # No more cookies
K,V = match.group("key"), match.group("val")
i = match.end(0)
# Parse the key, value in case it's metainfo
if K[0] == "$":
# We ignore attributes which pertain to the cookie
# mechanism as a whole. See RFC 2109.
# (Does anyone care?)
if M:
M[ K[1:] ] = V
else:
M = Morsel()
M.set(K, apply(self.net_setfunc, (V,)), V)
UserDict.__setitem__(self, K, M)
return
def __ParseString(self, str, patt=_CookiePattern):
i = 0 # Our starting point
n = len(str) # Length of string
M = None # Current morsel
while 0 <= i < n:
# Start looking for a cookie
match = patt.search(str, i)
if not match: break # No more cookies
K, V = match.group("key"), match.group("val")
i = match.end(0)
# Parse the key, value in case it's metainfo
if K[0] == "$":
# We ignore attributes which pertain to the cookie
# mechanism as a whole. See RFC 2109.
# (Does anyone care?)
if M:
M[K[1:]] = V
else:
M = Morsel()
M.set(K, apply(self.net_setfunc, (V, )), V)
UserDict.__setitem__(self, K, M)
return
def __init__(self, keyvalues=(), **other):
_base.__init__(self)
try: keyvalues = keyvalues.items()
except AttributeError: pass
for k,v in keyvalues:
_base.__setitem__(self,k,v)
_base.update(self,other)
self._hash = hash(tuple(self.items()))
def addHeader(self, name, value, order=None):
if order is None or order > len(self.headers._order):
sip.Request.addHeader(self, name, value)
else:
if self.headers.has_key(name):
del self.headers._order[name]
self.headers._order.insert(order, name)
UserDict.__setitem__(self.headers, name, [value])
def __setitem__(self, key, item):
if key == None:
raise Exception('I don\'t know how to handle None as a key.')
UserDict.__setitem__(self, key, item)
if self._preferred_order and key in self._preferred_order:
self._keys[self._preferred_order.index(key)] = key
elif key not in self._keys:
self._keys.append(key)
def __init__(self): # Set defaults self.key = self.value = self.coded_value = None UserDict.__init__(self) # Set default attributes for K in self.__reserved_keys: UserDict.__setitem__(self, K, "")
def __init__(self):
# Set defaults
self.key = self.value = self.coded_value = None
UserDict.__init__(self)
# Set default attributes
for K in self.__reserved_keys:
UserDict.__setitem__(self, K, "")
def __setitem__(self, item, val):
UserDict.__setitem__(self, item, val)
try:
self.setenvattr(item, val)
except AttributeError:
# Have to catch this because sometimes __setitem__ gets
# called out of __init__, when we don't have an env
# attribute yet, nor do we want one!
pass
def __setitem__(self, key, item):
UserDict.__setitem__(self, key, item)
if key == "tempdir" and item:
if not os.path.exists(self.data["tempdir"]):
os.makedirs(self.data["tempdir"])
if key in ["stdout","stderr"] and isinstance(item, str):
self.data[key] = open(item,'a')
self['files'].append(item)
if key == 'stdin' and isinstance(item,str):
self.data[key] = open(item)
def __init__(self, keyvalues=(), **other):
_base.__init__(self)
try:
keyvalues = keyvalues.items()
except AttributeError:
pass
for k, v in keyvalues:
_base.__setitem__(self, k, v)
_base.update(self, other)
self._hash = hash(tuple(self.items()))
def __setitem__(self, key, item):
UserDict.__setitem__(self, key, item)
if key == "tempdir" and item:
if not os.path.exists(self.data["tempdir"]):
os.makedirs(self.data["tempdir"])
if key in ["stdout", "stderr"] and isinstance(item, str):
self.data[key] = open(item, 'a')
self['files'].append(item)
if key == 'stdin' and isinstance(item, str):
self.data[key] = open(item)
def __setitem__(self, key, value):
"""Dictionary style assignment."""
M = self.get(key, Morsel())
M.set(key, value, apply(self.user_setfunc, (value,)))
if self.domain: M['domain'] = self.domain
if self.path: M['path'] = self.path
if self.expires: M['expires'] = self.expires
if not self.old_browser and self.maxage: M['max-age'] = self.maxage
UserDict.__setitem__(self, key, M)
def __init__(self, input=None):
# Set defaults
self.key = self.value = self.coded_value = None
UserDict.__init__(self)
self._clear = 0
self._header = None
# Set default attributes
for K in self.__reserved_keys:
UserDict.__setitem__(self, K, "")
if input:
self.parse_set (input)
def __setitem__(self, key, value):
"""Overrides the UserDict.__setitem__ method in order to validate
the key/value and also to set the turns attribute"""
if not self.mutable:
raise ValueError("Cannot update cache unless mutable is True.")
if not self._is_valid_key(key):
raise ValueError("Key must be a tuple of 2 deterministic axelrod Player classes and an integer")
if not self._is_valid_value(value):
raise ValueError("Value must be a list with length equal to turns attribute")
UserDict.__setitem__(self, key, value)
def __setitem__(self, key, item):
child_cls = self.child_classes.get(key)
var_obj = self.conf_vars.get(key)
if child_cls is not None:
if not isinstance(item, child_cls):
item = child_cls(item)
elif self.child_class is not None:
if not isinstance(item, self.child_class):
item = self.child_class(item)
elif var_obj is not None:
var_obj.value = item
return
UserDict.__setitem__(self, key, item)
def __setitem__(self, key, item):
child_cls = self.child_classes.get(key)
var_obj = self.conf_vars.get(key)
if child_cls is not None:
if not isinstance(item, child_cls):
item = child_cls(item)
elif self.child_class is not None:
if not isinstance(item, self.child_class):
item = self.child_class(item)
elif var_obj is not None:
var_obj.value = item
return
UserDict.__setitem__(self, key, item)
def __setitem__(self, varname, value):
self.conf.rewind()
if not self.conf.find_stanza(self.stanza):
raise Exception, "Unvalid stanza " + self.stanza
if not value:
return
if self.conf.find_entry_in_current_stanza(varname):
self.conf.sedline('=.*', '= ' + value)
else:
self.conf.insertline(varname + " = " + value)
UserDict.__setitem__(self, varname, value)
def __ParseString(self, str, patt=_CookiePattern):
ignore_list = {}
## import os
## sys.stderr.write("url %s\n" % os.environ.get('SCRIPT_NAME', ''))
## sys.stderr.write("qs %s\n" % os.environ.get('QUERY_STRING', ''))
## sys.stderr.write("cookie %s\n" % str)
i = 0 # Our starting point
n = len(str) # Length of string
M = None # Current morsel
not_attr = 0 # value wasn't an attribute, start new Morsel
while 0 <= i < n:
# Start looking for a cookie
## sys.stderr.write("str: %s\n" % str)
match = patt.search(str, i)
if not match: break # No more cookies
K,V = match.group("key"), match.group("val")
i = match.end(0)
# remember to ignore null cookies if they come up again
if V is None:
ignore_list[K] = 1
# don't do this!!
# sys.stderr.write("%s %s\n" % (K,V))
#log("Cookie.py: %s %s" % (K,V))
# For case where we're parsing a Set-Cookie, it'll
# have attributes after the key, add them to the Morsel
if M:
try:
M[string.lower(K)] = V
not_attr = 0
except CookieError:
not_attr = 1
if not M or not_attr:
# Parse the key, value in case it's metainfo
if K[0] == "$" and M:
M[string.lower(K[1:])] = V
# We ignore attributes which pertain to the cookie
# mechanism as a whole. See RFC 2109.
# (Does anyone care?)
elif not self.has_key(K) and not ignore_list.has_key(K):
M = Morsel()
M.set(K, apply(self.net_setfunc, (V,)), V)
UserDict.__setitem__(self, K, M)
def __setitem__(self, key, value):
"""Overrides the UserDict.__setitem__ method in order to validate
the key/value and also to set the turns attribute"""
if not self.mutable:
raise ValueError('Cannot update cache unless mutable is True.')
if not self._is_valid_key(key):
raise ValueError(
'Key must be a tuple of 2 deterministic axelrod Player classes and an integer'
)
if not self._is_valid_value(value):
raise ValueError(
'Value must be a list with length equal to turns attribute')
UserDict.__setitem__(self, self._key_transform(key), value)
def setitem(self, key, value,
domain="", path="/",
expires="Thu, 15 Apr 2010 20:00:00 GMT", maxage=None):
"""Dictionary style assignment."""
M = self.get(key, Morsel())
M.set(key, value, apply(self.user_setfunc, (value,)))
if domain != "": M['domain'] = domain
else: M['domain'] = self.domain
if path: M['path'] = path
if expires: M['expires'] = expires
if not self.old_browser:
if maxage == None:
M['max-age'] = self.maxage
else:
M['max-age'] = maxage
UserDict.__setitem__(self, key, M)
def __setitem__(self, key, item):
if key == "__line" and item:
item = item.strip("\n")
self.__parse(item)
if key == "__attrib_str" and item:
getattr(self, "parse_gff%s_attrib" % self["__version"])(item)
if (key == "start" or key == "end") and item:
item = int(item)
if key == "score" and item:
item = item == '.' and item or float(item)
if re.search(r'^attribute_', key):
self.data['attributes'][key[10:]] = item
del key
del item
try:
UserDict.__setitem__(self, key, item)
except NameError:
pass
def __setitem__(self, key, item):
if key == "__line" and item:
item = item.strip("\n")
self.__parse(item)
if key == "__attrib_str" and item:
getattr(self, "parse_gff%s_attrib" % self["__version"])(item)
if (key == "start" or key == "end") and item:
item = int(item)
if key == "score" and item:
item = item == '.' and item or float(item)
if re.search(r'^attribute_',key):
self.data['attributes'][key[10:]] = item
del key
del item
try:
UserDict.__setitem__(self, key, item)
except NameError:
pass
def __setitem__(self, key, item):
"""Case insensitive set item."""
keys = tuple(key.lower() for key in self._keys)
_key = key.lower()
if _key in keys:
for k in self._keys:
if k == _key:
key = k
break
elif k.lower() == _key:
self._keys.remove(k)
key = k
break
UserDict.__setitem__(self, key, item)
if key not in self._keys:
self._keys.append(key)
def __setitem__(self, key, item):
"""Case insensitive set item."""
keys = tuple(key.lower() for key in self._keys)
_key = key.lower()
if _key in keys:
for k in self._keys:
if k == _key:
key = k
break
elif k.lower() == _key:
self._keys.remove(k)
key = k
break
UserDict.__setitem__(self, key, item)
if key not in self._keys:
self._keys.append(key)
def __setitem__(self, key, value):
if self.get(key) != value:
if key in self:
self.del_valu(self[value])
if value in self._reversed:
def self[self.get_key(value)]
self._reversed[value] = key
if PY2:
return UserDict.__setitem__(self,key,value)
else:
return super(TwoWayDict,self).__setitem__(key,value)
def __setitem__(self, key, value):
if self.get(key) != value:
if key in self:
self.del_value(self[key])
if value in self._reversed:
del self[self.get_key(value)]
self._reversed[value] = key
if PY2:
return UserDict.__setitem__(self, key, value)
else:
return super(TwoWayDict, self).__setitem__(key, value)
def __setitem__(self, key, value): self.parent.updateItem(self.instance, key, value) UserDict.__setitem__(self, key, value)
def __setitem__(self, key, value):
self.parent.updateItem(self.instance, key, value)
if value or not self.autoDelete:
UserDict.__setitem__(self, key, value)
elif UserDict.__contains__(self, key):
UserDict.__delitem__(self, key)
def insert( self, index, key, item ):
if key not in self._keys:
self._keys.insert( index, key )
UserDict.__setitem__( self, key, item )
def __setitem__(self, key, value): """Dictionary style assignment.""" M = self.get(key, Morsel()) M.set(key, value, apply(self.user_setfunc, (value,))) UserDict.__setitem__(self, key, M)
def __setitem__(self, K, V):
K = string.lower(K)
if not K in self.__reserved_keys:
raise CookieError("Invalid Attribute %s" % K)
UserDict.__setitem__(self, K, V)
def __getitem__(self, item):
if item not in self:
value = PmfStatDict()
UserDict.__setitem__(self, item, value)
return UserDict.__getitem__(self, item)
def __setitem__(self, key, val):
print('FileInfo: call __setitem__')
UserDict.__setitem__(self, key, val)
def __setitem__(self, K, V):
K = string.lower(K)
if not K in self.__reserved_keys:
raise CookieError("Invalid Attribute %s" % K)
UserDict.__setitem__(self, K, V)
def __setitem__(self, key, item):
UserDict.__setitem__(self, key, item)
if key not in self._keys: self._keys.append(key)
def __setitem__(self, key, item):
UserDict.__setitem__(self, key, item)
if key not in self._keys: self._keys.append(key)
def __setitem__(self, key, value):
if not self.has_key(key):
self._order.append(key)
UserDict.__setitem__(self, key, value)
def __setitem__(self, key, item):
# same failure occurs with the pbs ResourceList
assert item is not None, "attempted to set %s to '%s'" % (key, item)
UserDict.__setitem__(self, key, item)
def __getitem__(self, item):
if item not in self:
value = PmfStatDict()
UserDict.__setitem__(self, item, value)
return UserDict.__getitem__(self, item)
def __setitem__(self, key, item):
if key not in self._keys:
raise KeyError, "The key %s does not exist and OrderedDictionaryFixedKeyList does not allow adding a key with __setitem__." % key
else:
UserDict.__setitem__(self, key, item)
def __setitem__(self, key, value):
if key == "posts":
if _debug:
sys.stderr.write("The value of posts has been changed.\n")
self.__postschanged = 1
return UserDict.__setitem__(self, key, value)
def __setitem__(self, key, item):
if key not in self.data:
self._keys.append(key)
return BaseDict.__setitem__(self, key, item)
def __setitem__(self, key, value):
_dict.__setitem__(self, key, value)
self._dirty = 1
def __setitem__(self, key, value):
if not self.has_key(key):
self._order.append(key)
UserDict.__setitem__(self, key, value)
def __setitem__(self,k,v):
try:
k = k.lower()
except:
pass
_UserDict.__setitem__(self,k,v)
def __setitem__(self, key, item):
if key not in self.data:
self._keys.append(key)
return BaseDict.__setitem__(self, key, item)
def __setitem__(self,k,v):
try:
k = k.lower()
except:
pass
_UserDict.__setitem__(self,k,v)
def __setitem__(self, key, item):
self.__populate()
UserDict.__setitem__( self, self._keyTransform(key), item )
def __setitem__(self, key, value):
data = base64.b64encode(pickle.dumps(value)).decode('ascii')
return UserDict.__setitem__(self, key, data)
def __set(self, key, real_value, coded_value):
"""Private method for setting a cookie's value"""
M = self.get(key, Morsel())
M.set(key, real_value, coded_value)
UserDict.__setitem__(self, key, M)
def __setitem__(self, key, value):
"""Dictionary style assignment."""
M = self.get(key, Morsel())
M.set(key, value, apply(self.user_setfunc, (value, )))
UserDict.__setitem__(self, key, M)
def __setitem__(self, key, value):
self.parent.updateItem(self.instance, key, value)
if value or not self.autoDelete:
UserDict.__setitem__(self, key, value)
elif UserDict.__contains__(self, key):
UserDict.__delitem__(self, key)
def __setitem__(self, key, item):
if key not in self.allkeys: self.allkeys.append(key)
UserDict.__setitem__(self, key, item)
def __setitem__(self, key, value):
self.parent.updateItem(self.instance, key, value)
UserDict.__setitem__(self, key, value)
