lib: use packaging.version.Version instead of dropped distutils.version.StrictVersion

distutils is dropped in Python 3.12 . Migrate to packaging as described on
https://github.com/pypa/packaging/issues/520 .

kallithea/lib/utils2.py

@@ -1,545 +1,545 b''
 # -*- coding: utf-8 -*-
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
 kallithea.lib.utils2
 ~~~~~~~~~~~~~~~~~~~~
 
 Some simple helper functions.
 Note: all these functions should be independent of Kallithea classes, i.e.
 models, controllers, etc.  to prevent import cycles.
 
 This file was forked by the Kallithea project in July 2014.
 Original author and date, and relevant copyright and licensing information is below:
 :created_on: Jan 5, 2011
 :author: marcink
 :copyright: (c) 2013 RhodeCode GmbH, and others.
 :license: GPLv3, see LICENSE.md for more details.
 """
 
 import binascii
 import datetime
 import hashlib
 import json
 import logging
 import os
 import re
 import string
 import sys
 import time
 import urllib.parse
-from distutils.version import StrictVersion
 
 import bcrypt
 import urlobject
+from packaging.version import Version
 from sqlalchemy.engine import url as sa_url
 from sqlalchemy.exc import ArgumentError
 from tg import tmpl_context
 from tg.support.converters import asbool, aslist
 from webhelpers2.text import collapse, remove_formatting, strip_tags
 
 import kallithea
 from kallithea.lib import webutils
 from kallithea.lib.vcs.backends.base import BaseRepository, EmptyChangeset
 from kallithea.lib.vcs.backends.git.repository import GitRepository
 from kallithea.lib.vcs.conf import settings
 from kallithea.lib.vcs.exceptions import RepositoryError
 from kallithea.lib.vcs.utils import ascii_bytes, ascii_str, safe_bytes, safe_str  # re-export
 from kallithea.lib.vcs.utils.lazy import LazyProperty
 
 
 try:
     import pwd
 except ImportError:
     pass
 
 
 log = logging.getLogger(__name__)
 
 
 # mute pyflakes "imported but unused"
 assert asbool
 assert aslist
 assert ascii_bytes
 assert ascii_str
 assert safe_bytes
 assert safe_str
 assert LazyProperty
 
 
 # get current umask value without changing it
 umask = os.umask(0)
 os.umask(umask)
 
 
 def convert_line_endings(line, mode):
     """
     Converts a given line  "line end" according to given mode
 
     Available modes are::
         0 - Unix
         1 - Mac
         2 - DOS
 
     :param line: given line to convert
     :param mode: mode to convert to
     :rtype: str
     :return: converted line according to mode
     """
     if mode == 0:
         line = line.replace('\r\n', '\n')
         line = line.replace('\r', '\n')
     elif mode == 1:
         line = line.replace('\r\n', '\r')
         line = line.replace('\n', '\r')
     elif mode == 2:
         line = re.sub("\r(?!\n)|(?<!\r)\n", "\r\n", line)
     return line
 
 
 def detect_mode(line, default):
     """
     Detects line break for given line, if line break couldn't be found
     given default value is returned
 
     :param line: str line
     :param default: default
     :rtype: int
     :return: value of line end on of 0 - Unix, 1 - Mac, 2 - DOS
     """
     if line.endswith('\r\n'):
         return 2
     elif line.endswith('\n'):
         return 0
     elif line.endswith('\r'):
         return 1
     else:
         return default
 
 
 def generate_api_key():
     """
     Generates a random (presumably unique) API key.
 
     This value is used in URLs and "Bearer" HTTP Authorization headers,
     which in practice means it should only contain URL-safe characters
     (RFC 3986):
 
         unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
     """
     # Hexadecimal certainly qualifies as URL-safe.
     return ascii_str(binascii.hexlify(os.urandom(20)))
 
 
 def safe_int(val, default=None):
     """
     Returns int() of val if val is not convertable to int use default
     instead
 
     :param val:
     :param default:
     """
     try:
         val = int(val)
     except (ValueError, TypeError):
         val = default
     return val
 
 
 def remove_suffix(s, suffix):
     if s.endswith(suffix):
         s = s[:-1 * len(suffix)]
     return s
 
 
 def remove_prefix(s, prefix):
     if s.startswith(prefix):
         s = s[len(prefix):]
     return s
 
 
 def uri_filter(uri):
     """
     Removes user:password from given url string
 
     :param uri:
     :rtype: str
     :returns: filtered list of strings
     """
     if not uri:
         return []
 
     proto = ''
 
     for pat in ('https://', 'http://', 'git://'):
         if uri.startswith(pat):
             uri = uri[len(pat):]
             proto = pat
             break
 
     # remove passwords and username
     uri = uri[uri.find('@') + 1:]
 
     # get the port
     cred_pos = uri.find(':')
     if cred_pos == -1:
         host, port = uri, None
     else:
         host, port = uri[:cred_pos], uri[cred_pos + 1:]
 
     return [_f for _f in [proto, host, port] if _f]
 
 
 def credentials_filter(uri):
     """
     Returns a url with removed credentials
 
     :param uri:
     """
 
     uri = uri_filter(uri)
     # check if we have port
     if len(uri) > 2 and uri[2]:
         uri[2] = ':' + uri[2]
 
     return ''.join(uri)
 
 
 def get_clone_url(clone_uri_tmpl, prefix_url, repo_name, repo_id, username=None):
     parsed_url = urlobject.URLObject(prefix_url)
     prefix = urllib.parse.unquote(parsed_url.path.rstrip('/'))
     try:
         system_user = pwd.getpwuid(os.getuid()).pw_name
     except NameError: # TODO: support all systems - especially Windows
         system_user = 'kallithea' # hardcoded default value ...
     args = {
         'scheme': parsed_url.scheme,
         'user': urllib.parse.quote(username or ''),
         'netloc': parsed_url.netloc + prefix,  # like "hostname:port/prefix" (with optional ":port" and "/prefix")
         'prefix': prefix, # undocumented, empty or starting with /
         'repo': repo_name,
         'repoid': str(repo_id),
         'system_user': system_user,
         'hostname': parsed_url.hostname,
     }
     url = re.sub('{([^{}]+)}', lambda m: args.get(m.group(1), m.group(0)), clone_uri_tmpl)
 
     # remove leading @ sign if it's present. Case of empty user
     url_obj = urlobject.URLObject(url)
     if not url_obj.username:
         url_obj = url_obj.with_username(None)
 
     return str(url_obj)
 
 
 def short_ref_name(ref_type, ref_name):
     """Return short description of PR ref - revs will be truncated"""
     if ref_type == 'rev':
         return ref_name[:12]
     return ref_name
 
 
 def link_to_ref(repo_name, ref_type, ref_name, rev=None):
     """
     Return full markup for a PR ref to changeset_home for a changeset.
     If ref_type is 'branch', it will link to changelog.
     ref_name is shortened if ref_type is 'rev'.
     if rev is specified, show it too, explicitly linking to that revision.
     """
     txt = short_ref_name(ref_type, ref_name)
     if ref_type == 'branch':
         u = webutils.url('changelog_home', repo_name=repo_name, branch=ref_name)
     else:
         u = webutils.url('changeset_home', repo_name=repo_name, revision=ref_name)
     l = webutils.link_to(repo_name + '#' + txt, u)
     if rev and ref_type != 'rev':
         l = webutils.literal('%s (%s)' % (l, webutils.link_to(rev[:12], webutils.url('changeset_home', repo_name=repo_name, revision=rev))))
     return l
 
 
 def get_changeset_safe(repo, rev):
     """
     Safe version of get_changeset if this changeset doesn't exists for a
     repo it returns a Dummy one instead
 
     :param repo:
     :param rev:
     """
     if not isinstance(repo, BaseRepository):
         raise Exception('You must pass an Repository '
                         'object as first argument got %s' % type(repo))
 
     try:
         cs = repo.get_changeset(rev)
     except (RepositoryError, LookupError):
         cs = EmptyChangeset(requested_revision=rev)
     return cs
 
 
 def datetime_to_time(dt):
     if dt:
         return time.mktime(dt.timetuple())
 
 
 def time_to_datetime(tm):
     if tm:
         if isinstance(tm, str):
             try:
                 tm = float(tm)
             except ValueError:
                 return
         return datetime.datetime.fromtimestamp(tm)
 
 
 class AttributeDict(dict):
     def __getattr__(self, attr):
         return self.get(attr, None)
     __setattr__ = dict.__setitem__
     __delattr__ = dict.__delitem__
 
 
 def obfuscate_url_pw(engine):
     try:
         _url = sa_url.make_url(engine or '')
     except ArgumentError:
         return engine
     if _url.password:
         _url.password = 'XXXXX'
     return str(_url)
 
 
 class HookEnvironmentError(Exception): pass
 
 
 def get_hook_environment():
     """
     Get hook context by deserializing the global KALLITHEA_EXTRAS environment
     variable.
 
     Called early in Git out-of-process hooks to get .ini config path so the
     basic environment can be configured properly. Also used in all hooks to get
     information about the action that triggered it.
     """
 
     try:
         kallithea_extras = os.environ['KALLITHEA_EXTRAS']
     except KeyError:
         raise HookEnvironmentError("Environment variable KALLITHEA_EXTRAS not found")
 
     extras = json.loads(kallithea_extras)
     for k in ['username', 'repository', 'scm', 'action', 'ip', 'config']:
         try:
             extras[k]
         except KeyError:
             raise HookEnvironmentError('Missing key %s in KALLITHEA_EXTRAS %s' % (k, extras))
 
     return AttributeDict(extras)
 
 
 def set_hook_environment(username, ip_addr, repo_name, repo_alias, action=None):
     """Prepare global context for running hooks by serializing data in the
     global KALLITHEA_EXTRAS environment variable.
 
     Most importantly, this allow Git hooks to do proper logging and updating of
     caches after pushes.
 
     Must always be called before anything with hooks are invoked.
     """
     extras = {
         'ip': ip_addr, # used in action_logger
         'username': username,
         'action': action or 'push_local', # used in process_pushed_raw_ids action_logger
         'repository': repo_name,
         'scm': repo_alias,
         'config': kallithea.CONFIG['__file__'], # used by git hook to read config
     }
     os.environ['KALLITHEA_EXTRAS'] = json.dumps(extras)
 
 
 def get_current_authuser():
     """
     Gets kallithea user from threadlocal tmpl_context variable if it's
     defined, else returns None.
     """
     try:
         return getattr(tmpl_context, 'authuser', None)
     except TypeError:  # No object (name: context) has been registered for this thread
         return None
 
 
 def urlreadable(s, _cleanstringsub=re.compile('[^-a-zA-Z0-9./]+').sub):
     return _cleanstringsub('_', s).rstrip('_')
 
 
 def recursive_replace(str_, replace=' '):
     """
     Recursive replace of given sign to just one instance
 
     :param str_: given string
     :param replace: char to find and replace multiple instances
 
     Examples::
     >>> recursive_replace("Mighty---Mighty-Bo--sstones",'-')
     'Mighty-Mighty-Bo-sstones'
     """
 
     if str_.find(replace * 2) == -1:
         return str_
     else:
         str_ = str_.replace(replace * 2, replace)
         return recursive_replace(str_, replace)
 
 
 def repo_name_slug(value):
     """
     Return slug of name of repository
     This function is called on each creation/modification
     of repository to prevent bad names in repo
     """
 
     slug = remove_formatting(value)
     slug = strip_tags(slug)
 
     for c in r"""`?=[]\;'"<>,/~!@#$%^&*()+{}|: """:
         slug = slug.replace(c, '-')
     slug = recursive_replace(slug, '-')
     slug = collapse(slug, '-')
     return slug
 
 
 def ask_ok(prompt, retries=4, complaint='Yes or no please!'):
     while True:
         ok = input(prompt)
         if ok in ('y', 'ye', 'yes'):
             return True
         if ok in ('n', 'no', 'nop', 'nope'):
             return False
         retries = retries - 1
         if retries < 0:
             raise IOError
         print(complaint)
 
 
 class PasswordGenerator(object):
     """
     This is a simple class for generating password from different sets of
     characters
     usage::
 
         passwd_gen = PasswordGenerator()
         #print 8-letter password containing only big and small letters
             of alphabet
         passwd_gen.gen_password(8, passwd_gen.ALPHABETS_BIG_SMALL)
     """
     ALPHABETS_NUM = r'''1234567890'''
     ALPHABETS_SMALL = r'''qwertyuiopasdfghjklzxcvbnm'''
     ALPHABETS_BIG = r'''QWERTYUIOPASDFGHJKLZXCVBNM'''
     ALPHABETS_SPECIAL = r'''`-=[]\;',./~!@#$%^&*()_+{}|:"<>?'''
     ALPHABETS_FULL = ALPHABETS_BIG + ALPHABETS_SMALL \
         + ALPHABETS_NUM + ALPHABETS_SPECIAL
     ALPHABETS_ALPHANUM = ALPHABETS_BIG + ALPHABETS_SMALL + ALPHABETS_NUM
     ALPHABETS_BIG_SMALL = ALPHABETS_BIG + ALPHABETS_SMALL
     ALPHABETS_ALPHANUM_BIG = ALPHABETS_BIG + ALPHABETS_NUM
     ALPHABETS_ALPHANUM_SMALL = ALPHABETS_SMALL + ALPHABETS_NUM
 
     def gen_password(self, length, alphabet=ALPHABETS_FULL):
         assert len(alphabet) <= 256, alphabet
         l = []
         while len(l) < length:
             i = ord(os.urandom(1))
             if i < len(alphabet):
                 l.append(alphabet[i])
         return ''.join(l)
 
 
 def get_crypt_password(password):
     """
     Cryptographic function used for bcrypt password hashing.
 
     :param password: password to hash
     """
     return ascii_str(bcrypt.hashpw(safe_bytes(password), bcrypt.gensalt(10)))
 
 
 def check_password(password, hashed):
     """
     Checks password match the hashed value using bcrypt.
     Remains backwards compatible and accept plain sha256 hashes which used to
     be used on Windows.
 
     :param password: password
     :param hashed: password in hashed form
     """
     # sha256 hashes will always be 64 hex chars
     # bcrypt hashes will always contain $ (and be shorter)
     if len(hashed) == 64 and all(x in string.hexdigits for x in hashed):
         return hashlib.sha256(password).hexdigest() == hashed
     try:
         return bcrypt.checkpw(safe_bytes(password), ascii_bytes(hashed))
     except ValueError as e:
         # bcrypt will throw ValueError 'Invalid hashed_password salt' on all password errors
         log.error('error from bcrypt checking password: %s', e)
         return False
     log.error('check_password failed - no method found for hash length %s', len(hashed))
     return False
 
 
-git_req_ver = StrictVersion('1.7.4')
+git_req_ver = Version('1.7.4')
 
 def check_git_version():
     """
     Checks what version of git is installed on the system, and raise a system exit
     if it's too old for Kallithea to work properly.
     """
     if 'git' not in kallithea.BACKENDS:
         return None
 
     if not settings.GIT_EXECUTABLE_PATH:
         log.warning('No git executable configured - check "git_path" in the ini file.')
         return None
 
     try:
         stdout, stderr = GitRepository._run_git_command(['--version'])
     except RepositoryError as e:
         # message will already have been logged as error
         log.warning('No working git executable found - check "git_path" in the ini file.')
         return None
 
     if stderr:
         log.warning('Error/stderr from "%s --version":\n%s', settings.GIT_EXECUTABLE_PATH, safe_str(stderr))
 
     if not stdout:
         log.warning('No working git executable found - check "git_path" in the ini file.')
         return None
 
     output = safe_str(stdout).strip()
     m = re.search(r"\d+.\d+.\d+", output)
     if m:
-        ver = StrictVersion(m.group(0))
+        ver = Version(m.group(0))
         log.debug('Git executable: "%s", version %s (parsed from: "%s")',
                   settings.GIT_EXECUTABLE_PATH, ver, output)
         if ver < git_req_ver:
             log.error('Kallithea detected %s version %s, which is too old '
                       'for the system to function properly. '
                       'Please upgrade to version %s or later. '
                       'If you strictly need Mercurial repositories, you can '
                       'clear the "git_path" setting in the ini file.',
                       settings.GIT_EXECUTABLE_PATH, ver, git_req_ver)
             log.error("Terminating ...")
             sys.exit(1)
     else:
-        ver = StrictVersion('0.0.0')
+        ver = Version('0.0.0')
         log.warning('Error finding version number in "%s --version" stdout:\n%s',
                     settings.GIT_EXECUTABLE_PATH, output)
 
     return ver

scripts/deps.py

@@ -1,293 +1,294 b''
 #!/usr/bin/env python3
 
 
 import re
 import sys
 
 
 ignored_modules = set('''
 argparse
 base64
 bcrypt
 binascii
 bleach
 calendar
 celery
 celery
 chardet
 click
 collections
 configparser
 copy
 csv
 ctypes
 datetime
 dateutil
 decimal
 decorator
 difflib
 distutils
 docutils
 email
 errno
 fileinput
 functools
 getpass
 grp
 hashlib
 hmac
 html
 http
 imp
 importlib
 inspect
 io
 ipaddr
 IPython
 isapi_wsgi
 itertools
 json
 kajiki
 ldap
 logging
 mako
 markdown
 mimetypes
 mock
 msvcrt
 multiprocessing
 operator
 os
 paginate
 paginate_sqlalchemy
 pam
 paste
 pkg_resources
 platform
 posixpath
 pprint
 pwd
 pyflakes
 pytest
 pytest_localserver
 random
 re
 routes
 setuptools
 shlex
 shutil
 smtplib
 socket
 ssl
 stat
 string
 struct
 subprocess
 sys
 tarfile
 tempfile
 textwrap
 tgext
 threading
 time
 traceback
 traitlets
 types
 typing
 urllib
 urlobject
 uuid
 warnings
 webhelpers2
 webob
 webtest
 whoosh
 win32traceutil
 zipfile
 '''.split())
 
 top_modules = set('''
 kallithea.alembic
 kallithea.bin
 kallithea.config
 kallithea.controllers
 kallithea.templates.py
 scripts
 '''.split())
 
 bottom_external_modules = set('''
 tg
 mercurial
 sqlalchemy
 alembic
 formencode
 pygments
 dulwich
 beaker
 psycopg2
 docs
 setup
 conftest
+packaging
 '''.split())
 
 normal_modules = set('''
 kallithea
 kallithea.controllers.base
 kallithea.lib
 kallithea.lib.auth
 kallithea.lib.auth_modules
 kallithea.lib.celerylib
 kallithea.lib.db_manage
 kallithea.lib.helpers
 kallithea.lib.hooks
 kallithea.lib.indexers
 kallithea.lib.utils
 kallithea.lib.utils2
 kallithea.lib.vcs
 kallithea.lib.webutils
 kallithea.model
 kallithea.model.async_tasks
 kallithea.model.scm
 kallithea.templates.py
 '''.split())
 
 shown_modules = normal_modules | top_modules
 
 # break the chains somehow - this is a cleanup TODO list
 known_violations = set([
 ('kallithea.lib.auth_modules', 'kallithea.lib.auth'),  # needs base&facade
 ('kallithea.lib.utils', 'kallithea.model'),  # clean up utils
 ('kallithea.lib.utils', 'kallithea.model.db'),
 ('kallithea.lib.utils', 'kallithea.model.scm'),
 ('kallithea.model', 'kallithea.lib.auth'),  # auth.HasXXX
 ('kallithea.model', 'kallithea.lib.auth_modules'),  # validators
 ('kallithea.model', 'kallithea.lib.hooks'),  # clean up hooks
 ('kallithea.model', 'kallithea.model.scm'),
 ('kallithea.model.scm', 'kallithea.lib.hooks'),
 ])
 
 extra_edges = [
 ('kallithea.config', 'kallithea.controllers'),  # through TG
 ('kallithea.lib.auth', 'kallithea.lib.auth_modules'),  # custom loader
 ]
 
 
 def normalize(s):
     """Given a string with dot path, return the string it should be shown as."""
     parts = s.replace('.__init__', '').split('.')
     short_2 = '.'.join(parts[:2])
     short_3 = '.'.join(parts[:3])
     short_4 = '.'.join(parts[:4])
     if parts[0] in ['scripts', 'contributor_data', 'i18n_utils']:
         return 'scripts'
     if short_3 == 'kallithea.model.meta':
         return 'kallithea.model.db'
     if parts[:4] == ['kallithea', 'lib', 'vcs', 'ssh']:
         return 'kallithea.lib.vcs.ssh'
     if short_4 in shown_modules:
         return short_4
     if short_3 in shown_modules:
         return short_3
     if short_2 in shown_modules:
         return short_2
     if short_2 == 'kallithea.tests':
         return None
     if parts[0] in ignored_modules:
         return None
     assert parts[0] in bottom_external_modules, parts
     return parts[0]
 
 
 def main(filenames):
     if not filenames or filenames[0].startswith('-'):
         print('''\
 Usage:
     hg files 'set:!binary()&grep("^#!.*python")' 'set:**.py' | xargs scripts/deps.py
     dot -Tsvg deps.dot > deps.svg
         ''')
         raise SystemExit(1)
 
     files_imports = dict()  # map filenames to its imports
     import_deps = set()  # set of tuples with module name and its imports
     for fn in filenames:
         with open(fn) as f:
             s = f.read()
 
         dot_name = (fn[:-3] if fn.endswith('.py') else fn).replace('/', '.')
         file_imports = set()
         for m in re.finditer(r'^ *(?:from ([^ ]*) import (?:([a-zA-Z].*)|\(([^)]*)\))|import (.*))$', s, re.MULTILINE):
             m_from, m_from_import, m_from_import2, m_import = m.groups()
             if m_from:
                 pre = m_from + '.'
                 if pre.startswith('.'):
                     pre = dot_name.rsplit('.', 1)[0] + pre
                 importlist = m_from_import or m_from_import2
             else:
                 pre = ''
                 importlist = m_import
             for imp in importlist.split('#', 1)[0].split(','):
                 full_imp = pre + imp.strip().split(' as ', 1)[0]
                 file_imports.add(full_imp)
                 import_deps.add((dot_name, full_imp))
         files_imports[fn] = file_imports
 
     # dump out all deps for debugging and analysis
     with open('deps.txt', 'w') as f:
         for fn, file_imports in sorted(files_imports.items()):
             for file_import in sorted(file_imports):
                 if file_import.split('.', 1)[0] in ignored_modules:
                     continue
                 f.write('%s: %s\n' % (fn, file_import))
 
     # find leafs that haven't been ignored - they are the important external dependencies and shown in the bottom row
     only_imported = set(
         set(normalize(b) for a, b in import_deps) -
         set(normalize(a) for a, b in import_deps) -
         set([None, 'kallithea'])
     )
 
     normalized_dep_edges = set()
     for dot_name, full_imp in import_deps:
         a = normalize(dot_name)
         b = normalize(full_imp)
         if a is None or b is None or a == b:
             continue
         normalized_dep_edges.add((a, b))
         #print((dot_name, full_imp, a, b))
     normalized_dep_edges.update(extra_edges)
 
     unseen_shown_modules = shown_modules.difference(a for a, b in normalized_dep_edges).difference(b for a, b in normalized_dep_edges)
     assert not unseen_shown_modules, unseen_shown_modules
 
     with open('deps.dot', 'w') as f:
         f.write('digraph {\n')
         f.write('subgraph { rank = same; %s}\n' % ''.join('"%s"; ' % s for s in sorted(top_modules)))
         f.write('subgraph { rank = same; %s}\n' % ''.join('"%s"; ' % s for s in sorted(only_imported)))
         for a, b in sorted(normalized_dep_edges):
             f.write('  "%s" -> "%s"%s\n' % (a, b, ' [color=red]' if (a, b) in known_violations else ' [color=green]' if (a, b) in extra_edges else ''))
         f.write('}\n')
 
     # verify dependencies by untangling dependency chain bottom-up:
     todo = set(normalized_dep_edges)
     unseen_violations = known_violations.difference(todo)
     assert not unseen_violations, unseen_violations
     for x in known_violations:
         todo.remove(x)
 
     while todo:
         depending = set(a for a, b in todo)
         depended = set(b for a, b in todo)
         drop = depended - depending
         if not drop:
             print('ERROR: cycles:', len(todo))
             for x in sorted(todo):
                 print('%s,' % (x,))
             raise SystemExit(1)
         #for do_b in sorted(drop):
         #    print('Picking', do_b, '- unblocks:', ' '.join(a for a, b in sorted((todo)) if b == do_b))
         todo = set((a, b) for a, b in todo if b in depending)
         #print()
 
 
 if __name__ == '__main__':
     main(sys.argv[1:])