From dbe2c158338752c3d4bb540b53d429ad85e14b83 Mon Sep 17 00:00:00 2001 From: Fabian Groffen Date: Mon, 21 Sep 2009 17:52:39 +0000 Subject: [PATCH] Merged from trunk -r14317:14326 | 14318 | Add deprecation warnings to vartree.exists_specific_cat(), | | zmedico | getnode(), and hasnode(). Use dbapi methods instead. | | 14319 | Make key_expand() always return Atom type. | | zmedico | | | 14320 | Use dep_expand instead of key_expand in the blocker | | zmedico | display, since it seems like a better fit. Also, use | | | str(atom) since we don't want to assume that Atoms are | | | string type (though they happen to be now). This assumption | | | is what caused the traceback in bug 285637, comment #5. | | 14321 | Support both Python 2 and 3 in portage._unicode_encode() | | arfrever | and portage._unicode_decode(). Update decoding in some | | | files. | | 14322 | Deprecate key_expand and | | zmedico | portage.dbapi.porttree.portagetree.resolve_specific which | | | calls it. | | 14323 | Fix breakage in _unicode_encode() for non-string types. | | zmedico | | | 14324 | Show deprecation warnings when dep_* legacy code is | | zmedico | triggered. | | 14325 | Simplify match_to_list(). Thanks to Marat Radchenko | | zmedico | for this patch from bug #276813. | | 14326 | Fix case for 0 args in args unicode conversion. | | zmedico | | svn path=/main/branches/prefix/; revision=14350 --- bin/portageq | 2 +- pym/_emerge/EbuildMetadataPhase.py | 3 ++- pym/_emerge/depgraph.py | 6 +++--- pym/_emerge/main.py | 3 ++- pym/portage/__init__.py | 24 +++++++++++++++--------- pym/portage/dbapi/porttree.py | 4 ++++ pym/portage/dbapi/vartree.py | 10 ++++++++++ pym/portage/dep.py | 20 +++++++++++--------- 8 files changed, 48 insertions(+), 24 deletions(-) diff --git a/bin/portageq b/bin/portageq index b8da074e5..feaba1587 100755 --- a/bin/portageq +++ b/bin/portageq @@ -614,7 +614,7 @@ def main(): os.environ["ROOT"] = sys.argv[2] args = sys.argv[2:] - if args and not isinstance(args[0], unicode): + if args and sys.hexversion < 0x3000000 and not isinstance(args[0], unicode): for i in range(len(args)): args[i] = portage._unicode_decode(args[i]) diff --git a/pym/_emerge/EbuildMetadataPhase.py b/pym/_emerge/EbuildMetadataPhase.py index 07d993b7d..1231b1b11 100644 --- a/pym/_emerge/EbuildMetadataPhase.py +++ b/pym/_emerge/EbuildMetadataPhase.py @@ -9,6 +9,7 @@ from portage.cache.mappings import slot_dict_class import portage from portage import os from portage import _encodings +from portage import _unicode_decode from portage import _unicode_encode import fcntl import codecs @@ -122,7 +123,7 @@ class EbuildMetadataPhase(SubProcess): def _set_returncode(self, wait_retval): SubProcess._set_returncode(self, wait_retval) if self.returncode == os.EX_OK: - metadata_lines = ''.join(unicode(chunk, + metadata_lines = ''.join(_unicode_decode(chunk, encoding=_encodings['repo.content'], errors='replace') for chunk in self._raw_metadata).splitlines() if len(portage.auxdbkeys) != len(metadata_lines): diff --git a/pym/_emerge/depgraph.py b/pym/_emerge/depgraph.py index 0e113d2cb..6bee45813 100644 --- a/pym/_emerge/depgraph.py +++ b/pym/_emerge/depgraph.py @@ -3980,14 +3980,14 @@ class depgraph(object): counters.blocks += 1 if x.satisfied: counters.blocks_satisfied += 1 - resolved = portage.key_expand( + resolved = portage.dep_expand( str(x.atom).lstrip("!"), mydb=vardb, settings=pkgsettings) if "--columns" in self._frozen_config.myopts and "--quiet" in self._frozen_config.myopts: - addl += " " + colorize(blocker_style, resolved) + addl += " " + colorize(blocker_style, str(resolved)) else: addl = "[%s %s] %s%s" % \ (colorize(blocker_style, "blocks"), - addl, indent, colorize(blocker_style, resolved)) + addl, indent, colorize(blocker_style, str(resolved))) block_parents = self._dynamic_config._blocker_parents.parent_nodes(x) block_parents = set([pnode[2] for pnode in block_parents]) block_parents = ", ".join(block_parents) diff --git a/pym/_emerge/main.py b/pym/_emerge/main.py index 2048c63ad..327c82f93 100644 --- a/pym/_emerge/main.py +++ b/pym/_emerge/main.py @@ -770,7 +770,8 @@ def parse_opts(tmpcmdline, silent=False): if myaction is None and myoptions.deselect is True: myaction = 'deselect' - if myargs and not isinstance(myargs[0], unicode): + if myargs and sys.hexversion < 0x3000000 and \ + not isinstance(myargs[0], unicode): for i in range(len(myargs)): myargs[i] = portage._unicode_decode(myargs[i]) diff --git a/pym/portage/__init__.py b/pym/portage/__init__.py index e16b0537f..86504c2a9 100644 --- a/pym/portage/__init__.py +++ b/pym/portage/__init__.py @@ -143,18 +143,19 @@ if _encodings['merge'] is None: def _unicode_encode(s, encoding=_encodings['content'], errors='backslashreplace'): - if isinstance(s, unicode): + if sys.hexversion >= 0x3000000: + if isinstance(s, str): + s = s.encode(encoding, errors) + elif isinstance(s, unicode): s = s.encode(encoding, errors) return s def _unicode_decode(s, encoding=_encodings['content'], errors='replace'): - if not isinstance(s, unicode): - if sys.hexversion < 0x3000000: - if isinstance(s, basestring): - s = unicode(s, encoding=encoding, errors=errors) + if isinstance(s, bytes): + if sys.hexversion >= 0x3000000: + s = str(s, encoding=encoding, errors=errors) else: - if isinstance(s, bytes): - s = unicode(s, encoding=encoding, errors=errors) + s = unicode(s, encoding=encoding, errors=errors) return s class _unicode_func_wrapper(object): @@ -8084,6 +8085,9 @@ def cpv_getkey(mycpv): getCPFromCPV = cpv_getkey def key_expand(mykey, mydb=None, use_cache=1, settings=None): + """This is deprecated because it just returns the first match instead of + raising AmbiguousPackageName like cpv_expand does.""" + warnings.warn("portage.key_expand() is deprecated", DeprecationWarning) mysplit=mykey.split("/") if settings is None: settings = globals()["settings"] @@ -8093,15 +8097,17 @@ def key_expand(mykey, mydb=None, use_cache=1, settings=None): if hasattr(mydb, "cp_list"): for x in mydb.categories: if mydb.cp_list(x+"/"+mykey,use_cache=use_cache): - return x+"/"+mykey + return dep.Atom(x + "/" + mykey) if mykey in virts_p: return(virts_p[mykey][0]) - return "null/"+mykey + return dep.Atom("null/" + mykey) elif mydb: if hasattr(mydb, "cp_list"): if not mydb.cp_list(mykey, use_cache=use_cache) and \ virts and mykey in virts: return virts[mykey][0] + if not isinstance(mykey, dep.Atom): + mykey = dep.Atom(mykey) return mykey def cpv_expand(mycpv, mydb=None, use_cache=1, settings=None): diff --git a/pym/portage/dbapi/porttree.py b/pym/portage/dbapi/porttree.py index ea22abd11..98af60d7f 100644 --- a/pym/portage/dbapi/porttree.py +++ b/pym/portage/dbapi/porttree.py @@ -35,6 +35,7 @@ from portage import _unicode_encode import codecs import logging import stat +import warnings def _src_uri_validate(cpv, eapi, src_uri): """ @@ -1196,6 +1197,9 @@ class portagetree(object): return "/".join([self.portroot, mysplit[0], psplit[0], mysplit[1]])+".ebuild" def resolve_specific(self, myspec): + warnings.warn( + "portage.dbapi.porttree.portagetree.resolve_specific() is deprecated", + DeprecationWarning) cps = catpkgsplit(myspec) if not cps: return None diff --git a/pym/portage/dbapi/vartree.py b/pym/portage/dbapi/vartree.py index 9eeef325a..3619f0db5 100644 --- a/pym/portage/dbapi/vartree.py +++ b/pym/portage/dbapi/vartree.py @@ -52,6 +52,7 @@ import codecs import re, shutil, stat, errno, copy, subprocess import logging import sys +import warnings try: import cPickle as pickle @@ -2450,6 +2451,9 @@ class vartree(object): return self.dbapi.cp_all() def exists_specific_cat(self, cpv, use_cache=1): + warnings.warn( + "portage.dbapi.vartree.vartree.exists_specific_cat() is deprecated", + DeprecationWarning) cpv = key_expand(cpv, mydb=self.dbapi, use_cache=use_cache, settings=self.settings) a = catpkgsplit(cpv) @@ -2470,6 +2474,9 @@ class vartree(object): return self.getpath(fullpackage, filename=package+".ebuild") def getnode(self, mykey, use_cache=1): + warnings.warn( + "portage.dbapi.vartree.vartree.getnode() is deprecated", + DeprecationWarning) mykey = key_expand(mykey, mydb=self.dbapi, use_cache=use_cache, settings=self.settings) if not mykey: @@ -2496,6 +2503,9 @@ class vartree(object): def hasnode(self, mykey, use_cache): """Does the particular node (cat/pkg key) exist?""" + warnings.warn( + "portage.dbapi.vartree.vartree.hadnode() is deprecated", + DeprecationWarning) mykey = key_expand(mykey, mydb=self.dbapi, use_cache=use_cache, settings=self.settings) mysplit = catsplit(mykey) diff --git a/pym/portage/dep.py b/pym/portage/dep.py index 4a2514474..9d055912d 100644 --- a/pym/portage/dep.py +++ b/pym/portage/dep.py @@ -18,7 +18,7 @@ # import re, sys -import weakref +import warnings from itertools import chain import portage.exception from portage.exception import InvalidData, InvalidAtom @@ -641,6 +641,9 @@ def get_operator(mydep): pass # Fall back to legacy code for backward compatibility. + warnings.warn(_("%s is deprecated, use %s instead") % \ + ('portage.dep.get_operator()', 'portage.dep.Atom.operator'), + DeprecationWarning) operator = None if mydep: mydep = remove_slot(mydep) @@ -684,6 +687,9 @@ def dep_getcpv(mydep): pass # Fall back to legacy code for backward compatibility. + warnings.warn(_("%s is deprecated, use %s instead") % \ + ('portage.dep.dep_getcpv()', 'portage.dep.Atom.cpv'), + DeprecationWarning) mydep_orig = mydep if mydep: mydep = remove_slot(mydep) @@ -927,6 +933,9 @@ def dep_getkey(mydep): pass # Fall back to legacy code for backward compatibility. + warnings.warn(_("%s is deprecated, use %s instead") % \ + ('portage.dep.dep_getkey()', 'portage.dep.Atom.cp'), + DeprecationWarning) mydep = dep_getcpv(mydep) if mydep and isspecific(mydep): mysplit = catpkgsplit(mydep) @@ -947,14 +956,7 @@ def match_to_list(mypkg, mylist): @rtype: List @return: A unique list of package atoms that match the given package atom """ - matches = [] - for x in mylist: - if not isinstance(x, Atom): - x = Atom(x) - if match_from_list(x, [mypkg]): - if x not in matches: - matches.append(x) - return matches + return [ x for x in set(mylist) if match_from_list(x, [mypkg]) ] def best_match_to_list(mypkg, mylist): """ -- 2.26.2