self.options = portage.dispatch_conf.read_config(MANDATORY_OPTS)
- if self.options.has_key("log-file"):
+ if "log-file" in self.options:
if os.path.isfile(self.options["log-file"]):
shutil.copy(self.options["log-file"], self.options["log-file"] + '.old')
if os.path.isfile(self.options["log-file"]) \
show_new_diff = 1
continue
elif c == 'e':
- if not os.environ.has_key('EDITOR'):
+ if 'EDITOR' not in os.environ:
os.environ['EDITOR']='nano'
os.system(os.environ['EDITOR'] + ' ' + newconf)
continue
conf = re.sub (r'\._cfg\d+_', '', nconf)
dir = re.match (r'^(.+)/', nconf).group (1)
- if h.has_key (conf):
+ if conf in h:
mrgconf = re.sub(r'\._cfg', '._mrg', h[conf]['new'])
if os.path.exists(mrgconf):
os.unlink(mrgconf)
self.ED = ""
self.DOCDESTTREE = ""
- if os.environ.has_key("PF"):
+ if "PF" in os.environ:
self.PF = os.environ["PF"]
if os.environ.has_key("ED"):
self.ED = os.environ["ED"]
- if os.environ.has_key("_E_DOCDESTTREE_"):
+ if "_E_DOCDESTTREE_" in os.environ:
self.DOCDESTTREE = os.environ["_E_DOCDESTTREE_"]
self.allowed_exts = [ 'htm', 'html', 'css', 'js',
# color doesn't make any sense for mail
nocolor()
- if portage.settings.has_key("PORTAGE_ELOG_MAILURI"):
+ if "PORTAGE_ELOG_MAILURI" in portage.settings:
myrecipient = portage.settings["PORTAGE_ELOG_MAILURI"].split()[0]
else:
myrecipient = "root@localhost"
- if portage.settings.has_key("PORTAGE_ELOG_MAILFROM"):
+ if "PORTAGE_ELOG_MAILFROM" in portage.settings:
myfrom = portage.settings["PORTAGE_ELOG_MAILFROM"]
else:
myfrom = "glsa-check"
if not os.path.isdir(portdir+"/profiles/"+arch[1]):
print "Invalid "+arch[2]+" profile ("+arch[1]+") for arch "+arch[0]
continue
- if profiles.has_key(arch[0]):
+ if arch[0] in profiles:
profiles[arch[0]]+= [[arch[1], arch[2]]]
else:
profiles[arch[0]] = [[arch[1], arch[2]]]
for x in repoman_settings.archlist():
if x[0] == "~":
continue
- if not profiles.has_key(x):
+ if x not in profiles:
print red("\""+x+"\" doesn't have a valid profile listed in profiles.desc.")
print red("You need to either \"cvs update\" your profiles dir or follow this")
print red("up with the "+x+" team.")
# uselist checks - local
mykey = portage.dep_getkey(catpkg)
- if luselist.has_key(mykey):
+ if mykey in luselist:
for mypos in range(len(myuse)-1,-1,-1):
if myuse[mypos] and (myuse[mypos] in luselist[mykey]):
del myuse[mypos]
if myskey not in kwlist:
stats["KEYWORDS.invalid"] += 1
fails["KEYWORDS.invalid"].append(x+"/"+y+".ebuild: %s" % mykey)
- elif not profiles.has_key(myskey):
+ elif myskey not in profiles:
stats["KEYWORDS.invalid"] += 1
fails["KEYWORDS.invalid"].append(x+"/"+y+".ebuild: %s (profile invalid)" % mykey)
for keyword,arch,groups in arches:
- if not profiles.has_key(arch):
+ if arch not in profiles:
# A missing profile will create an error further down
# during the KEYWORDS verification.
continue
if "PORTAGE_GPG_KEY" not in repoman_settings:
raise portage.exception.MissingParameter("PORTAGE_GPG_KEY is unset!")
if "PORTAGE_GPG_DIR" not in repoman_settings:
- if os.environ.has_key("HOME"):
+ if "HOME" in os.environ:
repoman_settings["PORTAGE_GPG_DIR"] = os.path.join(os.environ["HOME"], ".gnupg")
logging.info("Automatically setting PORTAGE_GPG_DIR to %s" % repoman_settings["PORTAGE_GPG_DIR"])
else:
repoman_settings["PORTAGE_GPG_DIR"])
gpgcmd = "gpg --sign --clearsign --yes "
gpgcmd+= "--default-key "+repoman_settings["PORTAGE_GPG_KEY"]
- if repoman_settings.has_key("PORTAGE_GPG_DIR"):
+ if "PORTAGE_GPG_DIR" in repoman_settings:
gpgcmd += " --homedir "+repoman_settings["PORTAGE_GPG_DIR"]
if options.pretend:
print "("+gpgcmd+" "+filename+")"
emergelog(xterm_titles, " *** Finished. Cleaning up...")
# We're out of the loop... We're done. Delete the resume data.
- if mtimedb.has_key("resume"):
+ if "resume" in mtimedb:
del mtimedb["resume"]
mtimedb.commit()
# since we're pruning, we don't care about slots
# and put all the pkgs in together
myslot = 0
- if not slotmap.has_key(myslot):
+ if myslot not in slotmap:
slotmap[myslot] = {}
slotmap[myslot][localtree.dbapi.cpv_counter(mypkg)] = mypkg
rsync_initial_timeout = 15
try:
- if settings.has_key("RSYNC_RETRIES"):
+ if "RSYNC_RETRIES" in settings:
print yellow("WARNING:")+" usage of RSYNC_RETRIES is deprecated, use PORTAGE_RSYNC_RETRIES instead"
maxretries=int(settings["RSYNC_RETRIES"])
else:
import UserDict
from itertools import chain, izip
import platform
+ import warnings
except ImportError, e:
sys.stderr.write("\n\n")
sys.stderr.write("!!! Failed to complete python imports. These are internal modules for\n")
def best_from_dict(key, top_dict, key_order, EmptyOnError=1, FullCopy=1, AllowEmpty=1):
for x in key_order:
- if top_dict.has_key(x) and top_dict[x].has_key(key):
+ if x in top_dict and key in top_dict[x]:
if FullCopy:
return copy.deepcopy(top_dict[x][key])
else:
def cacheddir(my_original_path, ignorecvs, ignorelist, EmptyOnError, followSymlinks=True):
global cacheHit,cacheMiss,cacheStale
mypath = normalize_path(my_original_path)
- if dircache.has_key(mypath):
+ if mypath in dircache:
cacheHit += 1
cached_mtime, list, ftype = dircache[mypath]
else:
return None, None
# Python retuns mtime in seconds, so if it was changed in the last few seconds, it could be invalid
if mtime != cached_mtime or time.time() - mtime < 4:
- if dircache.has_key(mypath):
+ if mypath in dircache:
cacheStale += 1
try:
list = os.listdir(mypath)
# Check the .config for a CONFIG_LOCALVERSION and append that too, also stripping whitespace
kernelconfig = getconfig(base_dir+"/.config")
- if kernelconfig and kernelconfig.has_key("CONFIG_LOCALVERSION"):
+ if kernelconfig and "CONFIG_LOCALVERSION" in kernelconfig:
version += "".join(kernelconfig["CONFIG_LOCALVERSION"].split())
return (version,None)
self.prevmaskdict={}
for x in self.packages:
mycatpkg=dep_getkey(x)
- if not self.prevmaskdict.has_key(mycatpkg):
+ if mycatpkg not in self.prevmaskdict:
self.prevmaskdict[mycatpkg]=[x]
else:
self.prevmaskdict[mycatpkg].append(x)
os.path.join(abs_user_config, "package.use"), recursive=1)
for key in pusedict.keys():
cp = dep_getkey(key)
- if not self.pusedict.has_key(cp):
+ if cp not in self.pusedict:
self.pusedict[cp] = {}
self.pusedict[cp][key] = pusedict[key]
# default to ~arch if no specific keyword is given
if not pkgdict[key]:
mykeywordlist = []
- if self.configdict["defaults"] and self.configdict["defaults"].has_key("ACCEPT_KEYWORDS"):
+ if self.configdict["defaults"] and \
+ "ACCEPT_KEYWORDS" in self.configdict["defaults"]:
groups = self.configdict["defaults"]["ACCEPT_KEYWORDS"].split()
else:
groups = []
mykeywordlist.append("~"+keyword)
pkgdict[key] = mykeywordlist
cp = dep_getkey(key)
- if not self.pkeywordsdict.has_key(cp):
+ if cp not in self.pkeywordsdict:
self.pkeywordsdict[cp] = {}
self.pkeywordsdict[cp][key] = pkgdict[key]
recursive=1)
for x in pkgunmasklines:
mycatpkg=dep_getkey(x)
- if self.punmaskdict.has_key(mycatpkg):
+ if mycatpkg in self.punmaskdict:
self.punmaskdict[mycatpkg].append(x)
else:
self.punmaskdict[mycatpkg]=[x]
self.pmaskdict = {}
for x in pkgmasklines:
mycatpkg=dep_getkey(x)
- if self.pmaskdict.has_key(mycatpkg):
+ if mycatpkg in self.pmaskdict:
self.pmaskdict[mycatpkg].append(x)
else:
self.pmaskdict[mycatpkg]=[x]
if not x:
continue
mycatpkg=dep_getkey(x)
- if self.pprovideddict.has_key(mycatpkg):
+ if mycatpkg in self.pprovideddict:
self.pprovideddict[mycatpkg].append(x)
else:
self.pprovideddict[mycatpkg]=[x]
def backup_changes(self,key=None):
self.modifying()
- if key and self.configdict["env"].has_key(key):
+ if key and key in self.configdict["env"]:
self.backupenv[key] = copy.deepcopy(self.configdict["env"][key])
else:
raise KeyError, "No such key defined in environment: %s" % key
if virts:
for x in virts:
vkeysplit = x.split("/")
- if not self.virts_p.has_key(vkeysplit[1]):
+ if vkeysplit[1] not in self.virts_p:
self.virts_p[vkeysplit[1]] = virts[x]
return self.virts_p
return v
def has_key(self,mykey):
+ warnings.warn("portage.config.has_key() is deprecated, "
+ "use the in operator instead",
+ DeprecationWarning)
return mykey in self
def __contains__(self, mykey):
# remain unset.
continue
mydict[x] = myvalue
- if not mydict.has_key("HOME") and mydict.has_key("BUILD_PREFIX"):
+ if "HOME" not in mydict and "BUILD_PREFIX" in mydict:
writemsg("*** HOME not set. Setting to "+mydict["BUILD_PREFIX"]+"\n")
mydict["HOME"]=mydict["BUILD_PREFIX"][:]
# use_locks = 0
# local mirrors are always added
- if custommirrors.has_key("local"):
+ if "local" in custommirrors:
mymirrors += custommirrors["local"]
if "nomirror" in restrict or \
primaryuri_dict = {}
for myuri in myuris:
myfile=os.path.basename(myuri)
- if not filedict.has_key(myfile):
+ if myfile not in filedict:
filedict[myfile]=[]
for y in range(0,len(locations)):
filedict[myfile].append(locations[y]+"/distfiles/"+myfile)
mirrorname = myuri[9:eidx]
# Try user-defined mirrors first
- if custommirrors.has_key(mirrorname):
+ if mirrorname in custommirrors:
for cmirr in custommirrors[mirrorname]:
filedict[myfile].append(cmirr+"/"+myuri[eidx+1:])
# remove the mirrors we tried from the list of official mirrors
if cmirr.strip() in thirdpartymirrors[mirrorname]:
thirdpartymirrors[mirrorname].remove(cmirr)
# now try the official mirrors
- if thirdpartymirrors.has_key(mirrorname):
+ if mirrorname in thirdpartymirrors:
shuffle(thirdpartymirrors[mirrorname])
for locmirr in thirdpartymirrors[mirrorname]:
continue
if "primaryuri" in restrict:
# Use the source site first.
- if primaryuri_indexes.has_key(myfile):
+ if myfile in primaryuri_indexes:
primaryuri_indexes[myfile] += 1
else:
primaryuri_indexes[myfile] = 0
continue
# allow different fetchcommands per protocol
protocol = loc[0:loc.find("://")]
- if mysettings.has_key("FETCHCOMMAND_"+protocol.upper()):
+ if "FETCHCOMMAND_" + protocol.upper() in mysettings:
fetchcommand=mysettings["FETCHCOMMAND_"+protocol.upper()]
else:
fetchcommand=mysettings["FETCHCOMMAND"]
- if mysettings.has_key("RESUMECOMMAND_"+protocol.upper()):
+ if "RESUMECOMMAND_" + protocol.upper() in mysettings:
resumecommand=mysettings["RESUMECOMMAND_"+protocol.upper()]
else:
resumecommand=mysettings["RESUMECOMMAND"]
except EnvironmentError:
pass
- if mydigests!=None and mydigests.has_key(myfile):
+ if mydigests is not None and myfile in mydigests:
try:
mystat = os.stat(myfile_path)
except OSError, e:
ebuild_path = os.path.abspath(myebuild)
pkg_dir = os.path.dirname(ebuild_path)
- if mysettings.configdict["pkg"].has_key("CATEGORY"):
+ if "CATEGORY" in mysettings.configdict["pkg"]:
cat = mysettings.configdict["pkg"]["CATEGORY"]
else:
cat = os.path.basename(normalize_path(os.path.join(pkg_dir, "..")))
else:
mysettings["PVR"]=mysplit[1]+"-"+mysplit[2]
- if mysettings.has_key("PATH"):
+ if "PATH" in mysettings:
mysplit=mysettings["PATH"].split(":")
else:
mysplit=[]
pass
else:
mykey = dep_getkey(deplist[mypos])
- if mysettings and mysettings.pprovideddict.has_key(mykey) and \
+ if mysettings and mykey in mysettings.pprovideddict and \
match_from_list(deplist[mypos], mysettings.pprovideddict[mykey]):
deplist[mypos]=True
elif mydbapi is None:
for x in mydb.categories:
if mydb.cp_list(x+"/"+mykey,use_cache=use_cache):
return x+"/"+mykey
- if virts_p.has_key(mykey):
+ if mykey in virts_p:
return(virts_p[mykey][0])
return "null/"+mykey
elif mydb:
if hasattr(mydb, "cp_list"):
- if (not mydb.cp_list(mykey,use_cache=use_cache)) and virts and virts.has_key(mykey):
+ if not mydb.cp_list(mykey, use_cache=use_cache) and \
+ virts and mykey in virts:
return virts[mykey][0]
return mykey
mykey=matches[0]
if not mykey and not isinstance(mydb, list):
- if virts_p.has_key(myp):
+ if myp in virts_p:
mykey=virts_p[myp][0]
#again, we only perform virtual expansion if we have a dbapi (not a list)
if not mykey:
locations.reverse()
pmasklists = [(x, grablines(os.path.join(x, "package.mask"), recursive=1)) for x in locations]
- if settings.pmaskdict.has_key(mycp):
+ if mycp in settings.pmaskdict:
for x in settings.pmaskdict[mycp]:
if match_from_list(x, cpv_slot_list):
comment = ""
def portageexit():
global uid,portage_gid,portdb,db
- if secpass and not os.environ.has_key("SANDBOX_ACTIVE"):
+ if secpass and os.environ.get("SANDBOX_ON") != "1":
close_portdbapi_caches()
commit_mtimedb()
# $Id$
import UserDict
+import warnings
import weakref
class ProtectedDict(UserDict.DictMixin):
return list(self.__iter__())
- def has_key(self, key):
+ def __contains__(self, key):
return key in self.new or (key not in self.blacklist and key in self.orig)
+ def has_key(self, key):
+ warnings.warn("portage.cache.mapping.ProtectedDict.has_key() is"
+ " deprecated, use the in operator instead",
+ DeprecationWarning)
+ return key in self
class LazyLoad(UserDict.DictMixin):
"""
def has_key(self, key):
+ warnings.warn("portage.cache.mappings.LazyLoad.has_key() is "
+ "deprecated, use the in operator instead",
+ DeprecationWarning)
return key in self
def _delitem(self, cpv):
value = self[cpv] # validates whiteout and/or raises a KeyError when necessary
- if self.db_ro.has_key(cpv):
+ if cpv in self.db_ro:
self.db_rw[cpv] = self._create_whiteout(value)
else:
del self.db_rw[cpv]
# so we store only what's handed to us and is a known key
db_values = []
for key in self._known_keys:
- if values.has_key(key) and values[key] != '':
+ if key in values and values[key]:
db_values.append({"key":key, "value":values[key]})
if len(db_values) > 0:
from portage.cache import cache_errors
from portage.cache.cache_errors import InvalidRestriction
from portage.cache.mappings import ProtectedDict
+import warnings
class database(object):
# this is for metadata/cache transfer.
if self.has_key is database.has_key:
# prevent a possible recursive loop
raise NotImplementedError
+ warnings.warn("portage.cache.template.database.has_key() is "
+ "deprecated, override __contains__ instead",
+ DeprecationWarning)
return self.has_key(cpv)
def __iter__(self):
mytarget=mysplit[-1]
mysplit=mysplit[:-1]
for mys in mysplit:
- if myentries["dirs"].has_key(mys):
+ if mys in myentries["dirs"]:
myentries=myentries["dirs"][mys]
else:
return None
- if myentries["dirs"].has_key(mytarget):
+ if mytarget in myentries["dirs"]:
return myentries["dirs"][mytarget]
- elif myentries["files"].has_key(mytarget):
+ elif mytarget in myentries["files"]:
return myentries["files"][mytarget]
else:
return None
if file=="digest-framerd-2.4.3":
print mydir,file
if os.path.isdir(mydir+"/"+file):
- if not entries["dirs"].has_key(file):
+ if file not in entries["dirs"]:
entries["dirs"][file]={"dirs":{},"files":{}}
- if entries["dirs"][file].has_key("status"):
+ if "status" in entries["dirs"][file]:
if "exists" not in entries["dirs"][file]["status"]:
entries["dirs"][file]["status"]+=["exists"]
else:
elif os.path.isfile(mydir+"/"+file):
if file=="digest-framerd-2.4.3":
print "isfile"
- if not entries["files"].has_key(file):
+ if file not in entries["files"]:
entries["files"][file]={"revision":"","date":"","flags":"","tags":""}
- if entries["files"][file].has_key("status"):
+ if "status" in entries["files"][file]:
if file=="digest-framerd-2.4.3":
print "has status"
if "exists" not in entries["files"][file]["status"]:
print "stat'ing"
mystat=os.stat(mydir+"/"+file)
mytime=time.asctime(time.gmtime(mystat[ST_MTIME]))
- if not entries["files"][file].has_key("status"):
+ if "status" not in entries["files"][file]:
if file=="digest-framerd-2.4.3":
print "status not set"
entries["files"][file]["status"]=[]
def invalidentry(self, mypath):
if mypath.endswith('portage_lockfile'):
- if not os.environ.has_key("PORTAGE_MASTER_PID"):
+ if "PORTAGE_MASTER_PID" not in os.environ:
writemsg("Lockfile removed: %s\n" % mypath, 1)
unlockfile((mypath, None, None))
else:
#writemsg(green(" -- DONE!\n\n"))
for mypkg in self.remotepkgs.keys():
- if not self.remotepkgs[mypkg].has_key("CATEGORY"):
+ if "CATEGORY" not in self.remotepkgs[mypkg]:
#old-style or corrupt package
writemsg("!!! Invalid remote binary package: "+mypkg+"\n",
noiselevel=-1)
"""
cp = "/".join(catpkgsplit(cpv)[:2])
cps = cp+":"+slot
- if len(paths) == 0 and self._data.has_key(cps) \
+ if len(paths) == 0 and cps in self._data \
and self._data[cps][0] == cpv and int(self._data[cps][1]) == int(counter):
del self._data[cps]
elif len(paths) > 0:
mystat = os.stat(self.getpath(mysplit[0]))[stat.ST_MTIME]
except OSError:
mystat = 0
- if use_cache and self.cpcache.has_key(mycp):
+ if use_cache and mycp in self.cpcache:
cpc = self.cpcache[mycp]
if cpc[0] == mystat:
return cpc[1][:]
self._cpv_sort_ascending(returnme)
if use_cache:
self.cpcache[mycp] = [mystat, returnme[:]]
- elif self.cpcache.has_key(mycp):
+ elif mycp in self.cpcache:
del self.cpcache[mycp]
return returnme
mykey = dep_getkey(mydep)
mycat = catsplit(mykey)[0]
if not use_cache:
- if self.matchcache.has_key(mycat):
+ if mycat in self.matchcache:
del self.mtdircache[mycat]
del self.matchcache[mycat]
return list(self._iter_match(mydep,
except (IOError, OSError):
curmtime=0
- if not self.matchcache.has_key(mycat) or not self.mtdircache[mycat]==curmtime:
+ if mycat not in self.matchcache or \
+ self.mtdircache[mycat] != curmtime:
# clear cache entry
self.mtdircache[mycat] = curmtime
self.matchcache[mycat] = {}
- if not self.matchcache[mycat].has_key(mydep):
+ if mydep not in self.matchcache[mycat]:
mymatch = list(self._iter_match(mydep,
self.cp_list(mydep.cp, use_cache=use_cache)))
self.matchcache[mycat][mydep] = mymatch
myprovides = {}
for node in self.getallcpv():
for mykey in self.get_provide(node):
- if myprovides.has_key(mykey):
+ if mykey in myprovides:
myprovides[mykey] += [node]
else:
myprovides[mykey] = [node]
#if we have a file containing previously-merged config file md5sums, grab it.
conf_mem_file = os.path.join(destroot, CONFIG_MEMORY_FILE)
cfgfiledict = grabdict(conf_mem_file)
- if self.settings.has_key("NOCONFMEM"):
+ if "NOCONFMEM" in self.settings:
cfgfiledict["IGNORE"]=1
else:
cfgfiledict["IGNORE"]=0
return result[:]
def cpv_exists(self, mycpv):
- return self.cpvdict.has_key(mycpv)
+ return mycpv in self.cpvdict
def cp_list(self, mycp, use_cache=1):
cachelist = self._match_cache.get(mycp)
"""Removes a cpv from the list of available packages."""
self._clear_cache()
mycp = cpv_getkey(mycpv)
- if self.cpvdict.has_key(mycpv):
+ if mycpv in self.cpvdict:
del self.cpvdict[mycpv]
- if not self.cpdict.has_key(mycp):
+ if mycp not in self.cpdict:
return
while mycpv in self.cpdict[mycp]:
del self.cpdict[mycp][self.cpdict[mycp].index(mycpv)]
fake_api = dir(dbapi)
for call in fake_api:
if not hasattr(self, call):
- setattr(self, call, f)
\ No newline at end of file
+ setattr(self, call, f)
sys.exit(1)
for key in mandatory_opts:
- if not opts.has_key(key):
+ if key not in opts:
if key == "merge":
opts["merge"] = "sdiff --suppress-common-lines --output='%s' '%s' '%s'"
else:
ebuild_logentries = collect_ebuild_messages(os.path.join(mysettings["T"], "logging"))
all_logentries = collect_messages()
- if all_logentries.has_key(cpv):
+ if cpv in all_logentries:
all_logentries[cpv] = _merge_logentries(ebuild_logentries, all_logentries[cpv])
else:
all_logentries[cpv] = ebuild_logentries
for key in _preserve_logentries.keys():
- if all_logentries.has_key(key):
+ if key in all_logentries:
all_logentries[key] = _merge_logentries(_preserve_logentries[key], all_logentries[key])
else:
all_logentries[key] = _preserve_logentries[key]
for phase in logentries:
for msgtype, msgcontent in logentries[phase]:
if msgtype.upper() in loglevels or "*" in loglevels:
- if not rValue.has_key(phase):
+ if phase not in rValue:
rValue[phase] = []
rValue[phase].append((msgtype, msgcontent))
return rValue
if color == None:
color = "GOOD"
print colorize(color, " * ")+msg
- if not _msgbuffer.has_key(key):
+ if key not in _msgbuffer:
_msgbuffer[key] = {}
- if not _msgbuffer[key].has_key(phase):
+ if phase not in _msgbuffer[key]:
_msgbuffer[key][phase] = []
_msgbuffer[key][phase].append((level, msg))
from portage.util import writemsg
def process(mysettings, key, logentries, fulltext):
- if mysettings.has_key("PORTAGE_ELOG_MAILURI"):
+ if "PORTAGE_ELOG_MAILURI" in mysettings:
myrecipient = mysettings["PORTAGE_ELOG_MAILURI"].split()[0]
else:
myrecipient = "root@localhost"
count = "one package"
else:
count = "multiple packages"
- if mysettings.has_key("PORTAGE_ELOG_MAILURI"):
+ if "PORTAGE_ELOG_MAILURI" in mysettings:
myrecipient = mysettings["PORTAGE_ELOG_MAILURI"].split()[0]
else:
myrecipient = "root@localhost"
metadatafile.close()
except (cPickle.UnpicklingError, OSError, IOError, EOFError):
metadata = {}
- if not metadata.has_key(baseurl):
+ if baseurl not in metadata:
metadata[baseurl]={}
- if not metadata[baseurl].has_key("indexname"):
+ if "indexname" not in metadata[baseurl]:
metadata[baseurl]["indexname"]=""
- if not metadata[baseurl].has_key("timestamp"):
+ if "timestamp" not in metadata[baseurl]:
metadata[baseurl]["timestamp"]=0
- if not metadata[baseurl].has_key("unmodified"):
+ if "unmodified" not in metadata[baseurl]:
metadata[baseurl]["unmodified"]=0
- if not metadata[baseurl].has_key("data"):
+ if "data" not in metadata[baseurl]:
metadata[baseurl]["data"]={}
if not os.access(cache_path, os.W_OK):
out.flush()
try:
- if metadata[baseurl].has_key("modified") and metadata[baseurl]["modified"]:
+ if "modified" in metadata[baseurl] and metadata[baseurl]["modified"]:
metadata[baseurl]["timestamp"] = int(time.time())
metadatafile = open(CACHE_PATH+"/remote_metadata.pickle", "w+")
cPickle.dump(metadata,metadatafile)
"""
rValue = []
- if myconfig.has_key("GLSA_DIR"):
+ if "GLSA_DIR" in myconfig:
repository = myconfig["GLSA_DIR"]
else:
repository = os.path.join(myconfig["PORTDIR"], "metadata", "glsa")
@rtype: None
@return: None
"""
- if self.config.has_key("GLSA_DIR"):
+ if "GLSA_DIR" in self.config:
repository = "file://" + self.config["GLSA_DIR"]+"/"
else:
repository = "file://" + self.config["PORTDIR"] + "/metadata/glsa/"
self.packages = {}
for p in self.affected.getElementsByTagName("package"):
name = p.getAttribute("name")
- if not self.packages.has_key(name):
+ if name not in self.packages:
self.packages[name] = []
tmp = {}
tmp["arch"] = p.getAttribute("arch")
host = "-".join(hostpid[:-1])
pid = hostpid[-1]
- if not mylist.has_key(filename):
+ if filename not in mylist:
mylist[filename] = {}
- if not mylist[filename].has_key(host):
+ if host not in mylist[filename]:
mylist[filename][host] = []
mylist[filename][host].append(pid)
results.append("Found %(count)s locks" % {"count":mycount})
for x in mylist:
- if mylist[x].has_key(myhost) or remove_all_locks:
+ if myhost in mylist[x] or remove_all_locks:
mylockname = hardlock_name(path+"/"+x)
if hardlink_is_mine(mylockname, path+"/"+x) or \
not os.path.exists(path+"/"+x) or \
""" Regenerate hashes for the given file """
if checkExisting:
self.checkFileHashes(ftype, fname, ignoreMissing=ignoreMissing)
- if not ignoreMissing and not self.fhashdict[ftype].has_key(fname):
+ if not ignoreMissing and fname not in self.fhashdict[ftype]:
raise FileNotInManifestException(fname)
- if not self.fhashdict[ftype].has_key(fname):
+ if fname not in self.fhashdict[ftype]:
self.fhashdict[ftype][fname] = {}
myhashkeys = list(self.hashes)
if reuseExisting:
final_dict = {}
for y in mydict.keys():
if True:
- if final_dict.has_key(y) and (incremental or (y in incrementals)):
+ if y in final_dict and (incremental or (y in incrementals)):
final_dict[y] += " "+mydict[y][:]
else:
final_dict[y] = mydict[y][:]
cexpand[mystring]=""
return ""
numvars=numvars+1
- if mydict.has_key(myvarname):
+ if myvarname in mydict:
newstring=newstring+mydict[myvarname]
else:
newstring=newstring+mystring[pos]
projects / portage.git / commitdiff