mercurial/policy.py
34–38	As I said on the pull request for black, I don't like that these lines get split up.

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	15009		May 4 2019, 11:19 PM	★	★
Diff 2	15039		May 8 2019, 3:31 PM	★	★
Diff 3	15040		May 8 2019, 3:34 PM	★	★
Diff 4	16812		Oct 5 2019, 9:44 AM	★	★
Diff 5	16829		Oct 5 2019, 11:01 AM	★	★
Diff 6	16867		Oct 6 2019, 9:50 AM	★	★
Diff 7	16881		Oct 6 2019, 10:56 AM	★	★
Diff 8	16902	rHG57875cf423c9c1b2128da728b2e6eecbc847e694	Oct 5 2019, 10:29 AM	★	★

Commit	Parents	Author	Summary	Date
63ac8b0c153d	c348d829d23a	Augie Fackler		Oct 5 2019, 9:42 AM

Status	Author	Revision
Closed	durin42	D6997 contrib: fix check-code to be able to detect missing _() with bytestrings
Closed	durin42	D6996 cleanup: mark some ui.(status\|note\|warn\|write) calls as not needing i18n
Closed	indygreg	D6994 ui: define (write\|status\|warn\|note)noi18n aliases
Closed	durin42	D6973 mangler: stop rewriting string constants to be bytes literals
Closed	durin42	D6972 formatting: byteify all mercurial/ and hgext/ string literals
Closed	durin42	D6971 formatting: blacken the codebase
Closed	durin42	D6970 transaction: re-wrap line to avoid a black bug
Closed	durin42	D6969 discovery: re-wrap expression to avoid a black bug
Closed	durin42	D6342 style: run a patched black on a subset of mercurial
Closed	durin42	D6974 examples: include a sample of how to use black with fix
Closed	durin42	D6993 black: add a pyproject.toml that contains our black settings
Closed	durin42	D6979 contrib: stop whining about whitespace around =
Closed	durin42	D6978 contrib: black manages whitespace after Python keywords now
Closed	durin42	D6977 contrib: allow trailing commas in lists
Closed	durin42	D6976 contrib: remove check-code line length limit
Closed	durin42	D6985 statprof: drop python #! and exec bit we don't use
Closed	durin42	D6984 cvsps: switch a file open to a with statement

Diff 16812

contrib/import-checker.py

	#!/usr/bin/env python			#!/usr/bin/env python

	from __future__ import absolute_import, print_function			from __future__ import absolute_import, print_function

	import ast			import ast
	import collections			import collections
	import os			import os
	import sys			import sys

	# Import a minimal set of stdlib modules needed for list_stdlib_modules()			# Import a minimal set of stdlib modules needed for list_stdlib_modules()
	# to work when run from a virtualenv. The modules were chosen empirically			# to work when run from a virtualenv. The modules were chosen empirically
	# so that the return value matches the return value without virtualenv.			# so that the return value matches the return value without virtualenv.
	if True: # disable lexical sorting checks			if True: # disable lexical sorting checks
	try:			try:
	import BaseHTTPServer as basehttpserver			import BaseHTTPServer as basehttpserver
	except ImportError:			except ImportError:
	basehttpserver = None			basehttpserver = None
	import zlib			import zlib

	import testparseutil			import testparseutil

	# third-party imports should be directly imported			# third-party imports should be directly imported
	'mercurial.thirdparty',			'mercurial.thirdparty',
	'mercurial.thirdparty.attr',			'mercurial.thirdparty.attr',
	'mercurial.thirdparty.zope',			'mercurial.thirdparty.zope',
	'mercurial.thirdparty.zope.interface',			'mercurial.thirdparty.zope.interface',
	)			)

	# Whitelist of symbols that can be directly imported.			# Whitelist of symbols that can be directly imported.
	directsymbols = (			directsymbols = ('demandimport',)
	'demandimport',
	)

	# Modules that must be aliased because they are commonly confused with			# Modules that must be aliased because they are commonly confused with
	# common variables and can create aliasing and readability issues.			# common variables and can create aliasing and readability issues.
	requirealias = {			requirealias = {
	'ui': 'uimod',			'ui': 'uimod',
	}			}


	def usingabsolute(root):			def usingabsolute(root):
	"""Whether absolute imports are being used."""			"""Whether absolute imports are being used."""
	if sys.version_info[0] >= 3:			if sys.version_info[0] >= 3:
	return True			return True

	for node in ast.walk(root):			for node in ast.walk(root):
	if isinstance(node, ast.ImportFrom):			if isinstance(node, ast.ImportFrom):
	if node.module == '__future__':			if node.module == '__future__':
	for n in node.names:			for n in node.names:
	if n.name == 'absolute_import':			if n.name == 'absolute_import':
	return True			return True

	return False			return False


	def walklocal(root):			def walklocal(root):
	"""Recursively yield all descendant nodes but not in a different scope"""			"""Recursively yield all descendant nodes but not in a different scope"""
	todo = collections.deque(ast.iter_child_nodes(root))			todo = collections.deque(ast.iter_child_nodes(root))
	yield root, False			yield root, False
	while todo:			while todo:
	node = todo.popleft()			node = todo.popleft()
	newscope = isinstance(node, ast.FunctionDef)			newscope = isinstance(node, ast.FunctionDef)
	if not newscope:			if not newscope:
	todo.extend(ast.iter_child_nodes(node))			todo.extend(ast.iter_child_nodes(node))
	yield node, newscope			yield node, newscope


	def dotted_name_of_path(path):			def dotted_name_of_path(path):
	"""Given a relative path to a source file, return its dotted module name.			"""Given a relative path to a source file, return its dotted module name.

	>>> dotted_name_of_path('mercurial/error.py')			>>> dotted_name_of_path('mercurial/error.py')
	'mercurial.error'			'mercurial.error'
	>>> dotted_name_of_path('zlibmodule.so')			>>> dotted_name_of_path('zlibmodule.so')
	'zlib'			'zlib'
	"""			"""
	parts = path.replace(os.sep, '/').split('/')			parts = path.replace(os.sep, '/').split('/')
	parts[-1] = parts[-1].split('.', 1)[0] # remove .py and .so and .ARCH.so			parts[-1] = parts[-1].split('.', 1)[0] # remove .py and .so and .ARCH.so
	if parts[-1].endswith('module'):			if parts[-1].endswith('module'):
	parts[-1] = parts[-1][:-6]			parts[-1] = parts[-1][:-6]
	return '.'.join(parts)			return '.'.join(parts)


	def fromlocalfunc(modulename, localmods):			def fromlocalfunc(modulename, localmods):
	"""Get a function to examine which locally defined module the			"""Get a function to examine which locally defined module the
	target source imports via a specified name.			target source imports via a specified name.

	`modulename` is an `dotted_name_of_path()`-ed source file path,			`modulename` is an `dotted_name_of_path()`-ed source file path,
	which may have `.__init__` at the end of it, of the target source.			which may have `.__init__` at the end of it, of the target source.

	`localmods` is a set of absolute `dotted_name_of_path()`-ed source file			`localmods` is a set of absolute `dotted_name_of_path()`-ed source file
	>>> fromlocal2('bar', 2)			>>> fromlocal2('bar', 2)
	('foo.bar', 'foo.bar.__init__', True)			('foo.bar', 'foo.bar.__init__', True)
	"""			"""
	if not isinstance(modulename, str):			if not isinstance(modulename, str):
	modulename = modulename.decode('ascii')			modulename = modulename.decode('ascii')
	prefix = '.'.join(modulename.split('.')[:-1])			prefix = '.'.join(modulename.split('.')[:-1])
	if prefix:			if prefix:
	prefix += '.'			prefix += '.'

	def fromlocal(name, level=0):			def fromlocal(name, level=0):
	# name is false value when relative imports are used.			# name is false value when relative imports are used.
	if not name:			if not name:
	# If relative imports are used, level must not be absolute.			# If relative imports are used, level must not be absolute.
	assert level > 0			assert level > 0
	candidates = ['.'.join(modulename.split('.')[:-level])]			candidates = ['.'.join(modulename.split('.')[:-level])]
	else:			else:
	if not level:			if not level:
	# Check relative name first.			# Check relative name first.
	candidates = [prefix + name, name]			candidates = [prefix + name, name]
	else:			else:
	candidates = ['.'.join(modulename.split('.')[:-level]) +			candidates = [
	'.' + name]			'.'.join(modulename.split('.')[:-level]) + '.' + name
				]

	for n in candidates:			for n in candidates:
	if n in localmods:			if n in localmods:
	return (n, n, False)			return (n, n, False)
	dottedpath = n + '.__init__'			dottedpath = n + '.__init__'
	if dottedpath in localmods:			if dottedpath in localmods:
	return (n, dottedpath, True)			return (n, dottedpath, True)
	return False			return False

	return fromlocal			return fromlocal


	def populateextmods(localmods):			def populateextmods(localmods):
	"""Populate C extension modules based on pure modules"""			"""Populate C extension modules based on pure modules"""
	newlocalmods = set(localmods)			newlocalmods = set(localmods)
	for n in localmods:			for n in localmods:
	if n.startswith('mercurial.pure.'):			if n.startswith('mercurial.pure.'):
	m = n[len('mercurial.pure.'):]			m = n[len('mercurial.pure.') :]
	newlocalmods.add('mercurial.cext.' + m)			newlocalmods.add('mercurial.cext.' + m)
	newlocalmods.add('mercurial.cffi._' + m)			newlocalmods.add('mercurial.cffi._' + m)
	return newlocalmods			return newlocalmods


	def list_stdlib_modules():			def list_stdlib_modules():
	"""List the modules present in the stdlib.			"""List the modules present in the stdlib.

	>>> py3 = sys.version_info[0] >= 3			>>> py3 = sys.version_info[0] >= 3
	>>> mods = set(list_stdlib_modules())			>>> mods = set(list_stdlib_modules())
	>>> 'BaseHTTPServer' in mods or py3			>>> 'BaseHTTPServer' in mods or py3
	True			True

	"""			"""
	for m in sys.builtin_module_names:			for m in sys.builtin_module_names:
	yield m			yield m
	# These modules only exist on windows, but we should always			# These modules only exist on windows, but we should always
	# consider them stdlib.			# consider them stdlib.
	for m in ['msvcrt', '_winreg']:			for m in ['msvcrt', '_winreg']:
	yield m			yield m
	yield '__builtin__'			yield '__builtin__'
	yield 'builtins' # python3 only			yield 'builtins' # python3 only
	yield 'importlib.abc' # python3 only			yield 'importlib.abc' # python3 only
	yield 'importlib.machinery' # python3 only			yield 'importlib.machinery' # python3 only
	yield 'importlib.util' # python3 only			yield 'importlib.util' # python3 only
	for m in 'fcntl', 'grp', 'pwd', 'termios': # Unix only			for m in 'fcntl', 'grp', 'pwd', 'termios': # Unix only
	yield m			yield m
	for m in 'cPickle', 'datetime': # in Python (not C) on PyPy			for m in 'cPickle', 'datetime': # in Python (not C) on PyPy
	yield m			yield m
	for m in ['cffi']:			for m in ['cffi']:
	yield m			yield m
	stdlib_prefixes = {sys.prefix, sys.exec_prefix}			stdlib_prefixes = {sys.prefix, sys.exec_prefix}
	# We need to supplement the list of prefixes for the search to work			# We need to supplement the list of prefixes for the search to work
	# when run from within a virtualenv.			# when run from within a virtualenv.
	for mod in (basehttpserver, zlib):			for mod in (basehttpserver, zlib):
	if mod is None:			if mod is None:
	# Then this directory is redundant.			# Then this directory is redundant.
	break			break
	else:			else:
	stdlib_prefixes.add(dirname)			stdlib_prefixes.add(dirname)
	sourceroot = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))			sourceroot = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
	for libpath in sys.path:			for libpath in sys.path:
	# We want to walk everything in sys.path that starts with something in			# We want to walk everything in sys.path that starts with something in
	# stdlib_prefixes, but not directories from the hg sources.			# stdlib_prefixes, but not directories from the hg sources.
	if (os.path.abspath(libpath).startswith(sourceroot)			if os.path.abspath(libpath).startswith(sourceroot) or not any(
	or not any(libpath.startswith(p) for p in stdlib_prefixes)):			libpath.startswith(p) for p in stdlib_prefixes
				):
	continue			continue
	for top, dirs, files in os.walk(libpath):			for top, dirs, files in os.walk(libpath):
	for i, d in reversed(list(enumerate(dirs))):			for i, d in reversed(list(enumerate(dirs))):
	if (not os.path.exists(os.path.join(top, d, '__init__.py'))			if (
	or top == libpath and d in ('hgdemandimport', 'hgext',			not os.path.exists(os.path.join(top, d, '__init__.py'))
	'mercurial')):			or top == libpath
				and d in ('hgdemandimport', 'hgext', 'mercurial')
				):
	del dirs[i]			del dirs[i]
	for name in files:			for name in files:
	if not name.endswith(('.py', '.so', '.pyc', '.pyo', '.pyd')):			if not name.endswith(('.py', '.so', '.pyc', '.pyo', '.pyd')):
	continue			continue
	if name.startswith('__init__.py'):			if name.startswith('__init__.py'):
	full_path = top			full_path = top
	else:			else:
	full_path = os.path.join(top, name)			full_path = os.path.join(top, name)
	rel_path = full_path[len(libpath) + 1:]			rel_path = full_path[len(libpath) + 1 :]
	mod = dotted_name_of_path(rel_path)			mod = dotted_name_of_path(rel_path)
	yield mod			yield mod


	stdlib_modules = set(list_stdlib_modules())			stdlib_modules = set(list_stdlib_modules())


	def imported_modules(source, modulename, f, localmods, ignore_nested=False):			def imported_modules(source, modulename, f, localmods, ignore_nested=False):
	"""Given the source of a file as a string, yield the names			"""Given the source of a file as a string, yield the names
	imported by that file.			imported by that file.

	Args:			Args:
	source: The python source to examine as a string.			source: The python source to examine as a string.
	modulename: of specified python source (may have `__init__`)			modulename: of specified python source (may have `__init__`)
	localmods: set of locally defined module names (may have `__init__`)			localmods: set of locally defined module names (may have `__init__`)
	modnotfound = True			modnotfound = True
	continue			continue
	yield found[1]			yield found[1]
	if modnotfound:			if modnotfound:
	# "dottedpath" is a package, but imported because of non-module			# "dottedpath" is a package, but imported because of non-module
	# lookup			# lookup
	yield dottedpath			yield dottedpath


	def verify_import_convention(module, source, localmods):			def verify_import_convention(module, source, localmods):
	"""Verify imports match our established coding convention.			"""Verify imports match our established coding convention.

	We have 2 conventions: legacy and modern. The modern convention is in			We have 2 conventions: legacy and modern. The modern convention is in
	effect when using absolute imports.			effect when using absolute imports.

	The legacy convention only looks for mixed imports. The modern convention			The legacy convention only looks for mixed imports. The modern convention
	is much more thorough.			is much more thorough.
	"""			"""
	root = ast.parse(source)			root = ast.parse(source)
	absolute = usingabsolute(root)			absolute = usingabsolute(root)

	if absolute:			if absolute:
	return verify_modern_convention(module, root, localmods)			return verify_modern_convention(module, root, localmods)
	else:			else:
	return verify_stdlib_on_own_line(root)			return verify_stdlib_on_own_line(root)


	def verify_modern_convention(module, root, localmods, root_col_offset=0):			def verify_modern_convention(module, root, localmods, root_col_offset=0):
	"""Verify a file conforms to the modern import convention rules.			"""Verify a file conforms to the modern import convention rules.

	The rules of the modern convention are:			The rules of the modern convention are:

	* Ordering is stdlib followed by local imports. Each group is lexically			* Ordering is stdlib followed by local imports. Each group is lexically
	sorted.			sorted.
	* Importing multiple modules via "import X, Y" is not allowed: use			* Importing multiple modules via "import X, Y" is not allowed: use
	seennonsymbollocal = False			seennonsymbollocal = False
	# The last name to be imported (for sorting).			# The last name to be imported (for sorting).
	lastname = None			lastname = None
	laststdlib = None			laststdlib = None
	# Relative import levels encountered so far.			# Relative import levels encountered so far.
	seenlevels = set()			seenlevels = set()

	for node, newscope in walklocal(root):			for node, newscope in walklocal(root):

	def msg(fmt, *args):			def msg(fmt, *args):
	return (fmt % args, node.lineno)			return (fmt % args, node.lineno)

	if newscope:			if newscope:
	# Check for local imports in function			# Check for local imports in function
	for r in verify_modern_convention(module, node, localmods,			for r in verify_modern_convention(
	node.col_offset + 4):			module, node, localmods, node.col_offset + 4
				):
	yield r			yield r
	elif isinstance(node, ast.Import):			elif isinstance(node, ast.Import):
	# Disallow "import foo, bar" and require separate imports			# Disallow "import foo, bar" and require separate imports
	# for each module.			# for each module.
	if len(node.names) > 1:			if len(node.names) > 1:
	yield msg('multiple imported names: %s',			yield msg(
	', '.join(n.name for n in node.names))			'multiple imported names: %s',
				', '.join(n.name for n in node.names),
				)

	name = node.names[0].name			name = node.names[0].name
	asname = node.names[0].asname			asname = node.names[0].asname

	stdlib = name in stdlib_modules			stdlib = name in stdlib_modules

	# Ignore sorting rules on imports inside blocks.			# Ignore sorting rules on imports inside blocks.
	if node.col_offset == root_col_offset:			if node.col_offset == root_col_offset:
	if lastname and name < lastname and laststdlib == stdlib:			if lastname and name < lastname and laststdlib == stdlib:
	yield msg('imports not lexically sorted: %s < %s',			yield msg(
	name, lastname)			'imports not lexically sorted: %s < %s', name, lastname
				)

	lastname = name			lastname = name
	laststdlib = stdlib			laststdlib = stdlib

	# stdlib imports should be before local imports.			# stdlib imports should be before local imports.
	if stdlib and seenlocal and node.col_offset == root_col_offset:			if stdlib and seenlocal and node.col_offset == root_col_offset:
	yield msg('stdlib import "%s" follows local import: %s',			yield msg(
	name, seenlocal)			'stdlib import "%s" follows local import: %s',
				name,
				seenlocal,
				)

	if not stdlib:			if not stdlib:
	seenlocal = name			seenlocal = name

	# Import of sibling modules should use relative imports.			# Import of sibling modules should use relative imports.
	topname = name.split('.')[0]			topname = name.split('.')[0]
	if topname == topmodule:			if topname == topmodule:
	yield msg('import should be relative: %s', name)			yield msg('import should be relative: %s', name)

	if name in requirealias and asname != requirealias[name]:			if name in requirealias and asname != requirealias[name]:
	yield msg('%s module must be "as" aliased to %s',			yield msg(
	name, requirealias[name])			'%s module must be "as" aliased to %s',
				name,
				requirealias[name],
				)

	elif isinstance(node, ast.ImportFrom):			elif isinstance(node, ast.ImportFrom):
	# Resolve the full imported module name.			# Resolve the full imported module name.
	if node.level > 0:			if node.level > 0:
	fullname = '.'.join(module.split('.')[:-node.level])			fullname = '.'.join(module.split('.')[: -node.level])
	if node.module:			if node.module:
	fullname += '.%s' % node.module			fullname += '.%s' % node.module
	else:			else:
	assert node.module			assert node.module
	fullname = node.module			fullname = node.module

	topname = fullname.split('.')[0]			topname = fullname.split('.')[0]
	if topname == topmodule:			if topname == topmodule:
	yield msg('import should be relative: %s', fullname)			yield msg('import should be relative: %s', fullname)

	# __future__ is special since it needs to come first and use			# __future__ is special since it needs to come first and use
	# symbol import.			# symbol import.
	if fullname != '__future__':			if fullname != '__future__':
	if not fullname or (			if not fullname or (
	fullname in stdlib_modules			fullname in stdlib_modules
	and fullname not in localmods			and fullname not in localmods
	and fullname + '.__init__' not in localmods):			and fullname + '.__init__' not in localmods
				):
	yield msg('relative import of stdlib module')			yield msg('relative import of stdlib module')
	else:			else:
	seenlocal = fullname			seenlocal = fullname

	# Direct symbol import is only allowed from certain modules and			# Direct symbol import is only allowed from certain modules and
	# must occur before non-symbol imports.			# must occur before non-symbol imports.
	found = fromlocal(node.module, node.level)			found = fromlocal(node.module, node.level)
	if found and found[2]: # node.module is a package			if found and found[2]: # node.module is a package
	prefix = found[0] + '.'			prefix = found[0] + '.'
	symbols = (n.name for n in node.names			symbols = (
	if not fromlocal(prefix + n.name))			n.name for n in node.names if not fromlocal(prefix + n.name)
				)
	else:			else:
	symbols = (n.name for n in node.names)			symbols = (n.name for n in node.names)
	symbols = [sym for sym in symbols if sym not in directsymbols]			symbols = [sym for sym in symbols if sym not in directsymbols]
	if node.module and node.col_offset == root_col_offset:			if node.module and node.col_offset == root_col_offset:
	if symbols and fullname not in allowsymbolimports:			if symbols and fullname not in allowsymbolimports:
	yield msg('direct symbol import %s from %s',			yield msg(
	', '.join(symbols), fullname)			'direct symbol import %s from %s',
				', '.join(symbols),
				fullname,
				)

	if symbols and seennonsymbollocal:			if symbols and seennonsymbollocal:
	yield msg('symbol import follows non-symbol import: %s',			yield msg(
	fullname)			'symbol import follows non-symbol import: %s', fullname
				)
	if not symbols and fullname not in stdlib_modules:			if not symbols and fullname not in stdlib_modules:
	seennonsymbollocal = True			seennonsymbollocal = True

	if not node.module:			if not node.module:
	assert node.level			assert node.level

	# Only allow 1 group per level.			# Only allow 1 group per level.
	if (node.level in seenlevels			if (
	and node.col_offset == root_col_offset):			node.level in seenlevels
	yield msg('multiple "from %s import" statements',			and node.col_offset == root_col_offset
	'.' * node.level)			):
				yield msg(
				'multiple "from %s import" statements', '.' * node.level
				)

	# Higher-level groups come before lower-level groups.			# Higher-level groups come before lower-level groups.
	if any(node.level > l for l in seenlevels):			if any(node.level > l for l in seenlevels):
	yield msg('higher-level import should come first: %s',			yield msg(
	fullname)			'higher-level import should come first: %s', fullname
				)

	seenlevels.add(node.level)			seenlevels.add(node.level)

	# Entries in "from .X import ( ... )" lists must be lexically			# Entries in "from .X import ( ... )" lists must be lexically
	# sorted.			# sorted.
	lastentryname = None			lastentryname = None

	for n in node.names:			for n in node.names:
	if lastentryname and n.name < lastentryname:			if lastentryname and n.name < lastentryname:
	yield msg('imports from %s not lexically sorted: %s < %s',			yield msg(
	fullname, n.name, lastentryname)			'imports from %s not lexically sorted: %s < %s',
				fullname,
				n.name,
				lastentryname,
				)

	lastentryname = n.name			lastentryname = n.name

	if n.name in requirealias and n.asname != requirealias[n.name]:			if n.name in requirealias and n.asname != requirealias[n.name]:
	yield msg('%s from %s must be "as" aliased to %s',			yield msg(
	n.name, fullname, requirealias[n.name])			'%s from %s must be "as" aliased to %s',
				n.name,
				fullname,
				requirealias[n.name],
				)


	def verify_stdlib_on_own_line(root):			def verify_stdlib_on_own_line(root):
	"""Given some python source, verify that stdlib imports are done			"""Given some python source, verify that stdlib imports are done
	in separate statements from relative local module imports.			in separate statements from relative local module imports.

	>>> list(verify_stdlib_on_own_line(ast.parse('import sys, foo')))			>>> list(verify_stdlib_on_own_line(ast.parse('import sys, foo')))
	[('mixed imports\\n stdlib: sys\\n relative: foo', 1)]			[('mixed imports\\n stdlib: sys\\n relative: foo', 1)]
	>>> list(verify_stdlib_on_own_line(ast.parse('import sys, os')))			>>> list(verify_stdlib_on_own_line(ast.parse('import sys, os')))
	[]			[]
	>>> list(verify_stdlib_on_own_line(ast.parse('import foo, bar')))			>>> list(verify_stdlib_on_own_line(ast.parse('import foo, bar')))
	[]			[]
	"""			"""
	for node in ast.walk(root):			for node in ast.walk(root):
	if isinstance(node, ast.Import):			if isinstance(node, ast.Import):
	from_stdlib = {False: [], True: []}			from_stdlib = {False: [], True: []}
	for n in node.names:			for n in node.names:
	from_stdlib[n.name in stdlib_modules].append(n.name)			from_stdlib[n.name in stdlib_modules].append(n.name)
	if from_stdlib[True] and from_stdlib[False]:			if from_stdlib[True] and from_stdlib[False]:
	yield ('mixed imports\n stdlib: %s\n relative: %s' %			yield (
	(', '.join(sorted(from_stdlib[True])),			'mixed imports\n stdlib: %s\n relative: %s'
	', '.join(sorted(from_stdlib[False]))), node.lineno)			% (
				', '.join(sorted(from_stdlib[True])),
				', '.join(sorted(from_stdlib[False])),
				),
				node.lineno,
				)


	class CircularImport(Exception):			class CircularImport(Exception):
	pass			pass


	def checkmod(mod, imports):			def checkmod(mod, imports):
	shortest = {}			shortest = {}
	visit = [[mod]]			visit = [[mod]]
	while visit:			while visit:
	path = visit.pop(0)			path = visit.pop(0)
	for i in sorted(imports.get(path[-1], [])):			for i in sorted(imports.get(path[-1], [])):
	if len(path) < shortest.get(i, 1000):			if len(path) < shortest.get(i, 1000):
	shortest[i] = len(path)			shortest[i] = len(path)
	if i in path:			if i in path:
	if i == path[0]:			if i == path[0]:
	raise CircularImport(path)			raise CircularImport(path)
	continue			continue
	visit.append(path + [i])			visit.append(path + [i])


	def rotatecycle(cycle):			def rotatecycle(cycle):
	"""arrange a cycle so that the lexicographically first module listed first			"""arrange a cycle so that the lexicographically first module listed first

	>>> rotatecycle(['foo', 'bar'])			>>> rotatecycle(['foo', 'bar'])
	['bar', 'foo', 'bar']			['bar', 'foo', 'bar']
	"""			"""
	lowest = min(cycle)			lowest = min(cycle)
	idx = cycle.index(lowest)			idx = cycle.index(lowest)
	return cycle[idx:] + cycle[:idx] + [lowest]			return cycle[idx:] + cycle[:idx] + [lowest]


	def find_cycles(imports):			def find_cycles(imports):
	"""Find cycles in an already-loaded import graph.			"""Find cycles in an already-loaded import graph.

	All module names recorded in `imports` should be absolute one.			All module names recorded in `imports` should be absolute one.

	>>> from __future__ import print_function			>>> from __future__ import print_function
	>>> imports = {'top.foo': ['top.bar', 'os.path', 'top.qux'],			>>> imports = {'top.foo': ['top.bar', 'os.path', 'top.qux'],
	... 'top.bar': ['top.baz', 'sys'],			... 'top.bar': ['top.baz', 'sys'],
	... 'top.baz': ['top.foo'],			... 'top.baz': ['top.foo'],
	... 'top.qux': ['top.foo']}			... 'top.qux': ['top.foo']}
	>>> print('\\n'.join(sorted(find_cycles(imports))))			>>> print('\\n'.join(sorted(find_cycles(imports))))
	top.bar -> top.baz -> top.foo -> top.bar			top.bar -> top.baz -> top.foo -> top.bar
	top.foo -> top.qux -> top.foo			top.foo -> top.qux -> top.foo
	"""			"""
	cycles = set()			cycles = set()
	for mod in sorted(imports.keys()):			for mod in sorted(imports.keys()):
	try:			try:
	checkmod(mod, imports)			checkmod(mod, imports)
	except CircularImport as e:			except CircularImport as e:
	cycle = e.args[0]			cycle = e.args[0]
	cycles.add(" -> ".join(rotatecycle(cycle)))			cycles.add(" -> ".join(rotatecycle(cycle)))
	return cycles			return cycles


	def _cycle_sortkey(c):			def _cycle_sortkey(c):
	return len(c), c			return len(c), c


	def embedded(f, modname, src):			def embedded(f, modname, src):
	"""Extract embedded python code			"""Extract embedded python code

	>>> def _forcestr(thing):			>>> def _forcestr(thing):
	... if not isinstance(thing, str):			... if not isinstance(thing, str):
	... return thing.decode('ascii')			... return thing.decode('ascii')
	... return thing			... return thing
	>>> def test(fn, lines):			>>> def test(fn, lines):
	name = 'doctest.py'			name = 'doctest.py'
	# "starts" is "line number" (1-origin), but embedded() is			# "starts" is "line number" (1-origin), but embedded() is
	# expected to return "line offset" (0-origin). Therefore, this			# expected to return "line offset" (0-origin). Therefore, this
	# yields "starts - 1".			# yields "starts - 1".
	if not isinstance(modname, str):			if not isinstance(modname, str):
	modname = modname.decode('utf8')			modname = modname.decode('utf8')
	yield code, "%s[%d]" % (modname, starts), name, starts - 1			yield code, "%s[%d]" % (modname, starts), name, starts - 1


	def sources(f, modname):			def sources(f, modname):
	"""Yields possibly multiple sources from a filepath			"""Yields possibly multiple sources from a filepath

	input: filepath, modulename			input: filepath, modulename
	yields: script(string), modulename, filepath, linenumber			yields: script(string), modulename, filepath, linenumber

	For embedded scripts, the modulename and filepath will be different			For embedded scripts, the modulename and filepath will be different
	from the function arguments. linenumber is an offset relative to			from the function arguments. linenumber is an offset relative to
	the input file.			the input file.
	"""			"""
	py = False			py = False
	if not f.endswith('.t'):			if not f.endswith('.t'):
	with open(f, 'rb') as src:			with open(f, 'rb') as src:
	yield src.read(), modname, f, 0			yield src.read(), modname, f, 0
	py = True			py = True
	if py or f.endswith('.t'):			if py or f.endswith('.t'):
	with open(f, 'r') as src:			with open(f, 'r') as src:
	for script, modname, t, line in embedded(f, modname, src):			for script, modname, t, line in embedded(f, modname, src):
	yield script, modname.encode('utf8'), t, line			yield script, modname.encode('utf8'), t, line


	def main(argv):			def main(argv):
	if len(argv) < 2 or (argv[1] == '-' and len(argv) > 2):			if len(argv) < 2 or (argv[1] == '-' and len(argv) > 2):
	print('Usage: %s {-\|file [file] [file] ...}')			print('Usage: %s {-\|file [file] [file] ...}')
	return 1			return 1
	if argv[1] == '-':			if argv[1] == '-':
	argv = argv[:1]			argv = argv[:1]
	argv.extend(l.rstrip() for l in sys.stdin.readlines())			argv.extend(l.rstrip() for l in sys.stdin.readlines())
	localmodpaths = {}			localmodpaths = {}
	used_imports = {}			used_imports = {}
	any_errors = False			any_errors = False
	for source_path in argv[1:]:			for source_path in argv[1:]:
	modname = dotted_name_of_path(source_path)			modname = dotted_name_of_path(source_path)
	localmodpaths[modname] = source_path			localmodpaths[modname] = source_path
	localmods = populateextmods(localmodpaths)			localmods = populateextmods(localmodpaths)
	for localmodname, source_path in sorted(localmodpaths.items()):			for localmodname, source_path in sorted(localmodpaths.items()):
	if not isinstance(localmodname, bytes):			if not isinstance(localmodname, bytes):
	# This is only safe because all hg's files are ascii			# This is only safe because all hg's files are ascii
	localmodname = localmodname.encode('ascii')			localmodname = localmodname.encode('ascii')
	for src, modname, name, line in sources(source_path, localmodname):			for src, modname, name, line in sources(source_path, localmodname):
	try:			try:
	used_imports[modname] = sorted(			used_imports[modname] = sorted(
	imported_modules(src, modname, name, localmods,			imported_modules(
	ignore_nested=True))			src, modname, name, localmods, ignore_nested=True
	for error, lineno in verify_import_convention(modname, src,			)
	localmods):			)
				for error, lineno in verify_import_convention(
				modname, src, localmods
				):
	any_errors = True			any_errors = True
	print('%s:%d: %s' % (source_path, lineno + line, error))			print('%s:%d: %s' % (source_path, lineno + line, error))
	except SyntaxError as e:			except SyntaxError as e:
	print('%s:%d: SyntaxError: %s' %			print(
	(source_path, e.lineno + line, e))			'%s:%d: SyntaxError: %s' % (source_path, e.lineno + line, e)
				)
	cycles = find_cycles(used_imports)			cycles = find_cycles(used_imports)
	if cycles:			if cycles:
	firstmods = set()			firstmods = set()
	for c in sorted(cycles, key=_cycle_sortkey):			for c in sorted(cycles, key=_cycle_sortkey):
	first = c.split()[0]			first = c.split()[0]
	# As a rough cut, ignore any cycle that starts with the			# As a rough cut, ignore any cycle that starts with the
	# same module as some other cycle. Otherwise we see lots			# same module as some other cycle. Otherwise we see lots
	# of cycles that are effectively duplicates.			# of cycles that are effectively duplicates.
	if first in firstmods:			if first in firstmods:
	continue			continue
	print('Import cycle:', c)			print('Import cycle:', c)
	firstmods.add(first)			firstmods.add(first)
	any_errors = True			any_errors = True
	return any_errors != 0			return any_errors != 0


	if __name__ == '__main__':			if __name__ == '__main__':
	sys.exit(int(main(sys.argv)))			sys.exit(int(main(sys.argv)))

mercurial/cacheutil.py

	# scmutil.py - Mercurial core utility functions			# scmutil.py - Mercurial core utility functions
	#			#
	# Copyright Matt Mackall <mpm@selenic.com> and other			# Copyright Matt Mackall <mpm@selenic.com> and other
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.
	from __future__ import absolute_import			from __future__ import absolute_import

	from . import repoview			from . import repoview


	def cachetocopy(srcrepo):			def cachetocopy(srcrepo):
	"""return the list of cache file valuable to copy during a clone"""			"""return the list of cache file valuable to copy during a clone"""
	# In local clones we're copying all nodes, not just served			# In local clones we're copying all nodes, not just served
	# ones. Therefore copy all branch caches over.			# ones. Therefore copy all branch caches over.
	cachefiles = ['branch2']			cachefiles = ['branch2']
	cachefiles += ['branch2-%s' % f for f in repoview.filtertable]			cachefiles += ['branch2-%s' % f for f in repoview.filtertable]
	cachefiles += ['rbc-names-v1', 'rbc-revs-v1']			cachefiles += ['rbc-names-v1', 'rbc-revs-v1']
	cachefiles += ['tags2']			cachefiles += ['tags2']
	cachefiles += ['tags2-%s' % f for f in repoview.filtertable]			cachefiles += ['tags2-%s' % f for f in repoview.filtertable]
	cachefiles += ['hgtagsfnodes1']			cachefiles += ['hgtagsfnodes1']
	return cachefiles			return cachefiles

mercurial/diffhelper.py

	# diffhelper.py - helper routines for patch			# diffhelper.py - helper routines for patch
	#			#
	# Copyright 2009 Matt Mackall <mpm@selenic.com> and others			# Copyright 2009 Matt Mackall <mpm@selenic.com> and others
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	from .i18n import _			from .i18n import _

	from . import (			from . import (
	error,			error,
	pycompat,			pycompat,
	)			)


	def addlines(fp, hunk, lena, lenb, a, b):			def addlines(fp, hunk, lena, lenb, a, b):
	"""Read lines from fp into the hunk			"""Read lines from fp into the hunk

	The hunk is parsed into two arrays, a and b. a gets the old state of			The hunk is parsed into two arrays, a and b. a gets the old state of
	the text, b gets the new state. The control char from the hunk is saved			the text, b gets the new state. The control char from the hunk is saved
	when inserting into a, but not b (for performance while deleting files.)			when inserting into a, but not b (for performance while deleting files.)
	"""			"""
	while True:			while True:
	if s.startswith('+'):			if s.startswith('+'):
	b.append(s[1:])			b.append(s[1:])
	elif s.startswith('-'):			elif s.startswith('-'):
	a.append(s)			a.append(s)
	else:			else:
	b.append(s[1:])			b.append(s[1:])
	a.append(s)			a.append(s)


	def fixnewline(hunk, a, b):			def fixnewline(hunk, a, b):
	"""Fix up the last lines of a and b when the patch has no newline at EOF"""			"""Fix up the last lines of a and b when the patch has no newline at EOF"""
	l = hunk[-1]			l = hunk[-1]
	# tolerate CRLF in last line			# tolerate CRLF in last line
	if l.endswith('\r\n'):			if l.endswith('\r\n'):
	hline = l[:-2]			hline = l[:-2]
	else:			else:
	hline = l[:-1]			hline = l[:-1]

	if hline.startswith((' ', '+')):			if hline.startswith((' ', '+')):
	b[-1] = hline[1:]			b[-1] = hline[1:]
	if hline.startswith((' ', '-')):			if hline.startswith((' ', '-')):
	a[-1] = hline			a[-1] = hline
	hunk[-1] = hline			hunk[-1] = hline


	def testhunk(a, b, bstart):			def testhunk(a, b, bstart):
	"""Compare the lines in a with the lines in b			"""Compare the lines in a with the lines in b

	a is assumed to have a control char at the start of each line, this char			a is assumed to have a control char at the start of each line, this char
	is ignored in the compare.			is ignored in the compare.
	"""			"""
	alen = len(a)			alen = len(a)
	blen = len(b)			blen = len(b)
	if alen > blen - bstart or bstart < 0:			if alen > blen - bstart or bstart < 0:
	return False			return False
	for i in pycompat.xrange(alen):			for i in pycompat.xrange(alen):
	if a[i][1:] != b[i + bstart]:			if a[i][1:] != b[i + bstart]:
	return False			return False
	return True			return True

mercurial/dirstateguard.py

	from .i18n import _			from .i18n import _

	from . import (			from . import (
	error,			error,
	narrowspec,			narrowspec,
	util,			util,
	)			)


	class dirstateguard(util.transactional):			class dirstateguard(util.transactional):
	'''Restore dirstate at unexpected failure.			'''Restore dirstate at unexpected failure.

	At the construction, this class does:			At the construction, this class does:

	- write current ``repo.dirstate`` out, and			- write current ``repo.dirstate`` out, and
	- save ``.hg/dirstate`` into the backup file			- save ``.hg/dirstate`` into the backup file

	This restores ``.hg/dirstate`` from backup file, if ``release()``			This restores ``.hg/dirstate`` from backup file, if ``release()``
	is invoked before ``close()``.			is invoked before ``close()``.

	This just removes the backup file at ``close()`` before ``release()``.			This just removes the backup file at ``close()`` before ``release()``.
	'''			'''

	def __init__(self, repo, name):			def __init__(self, repo, name):
	self._repo = repo			self._repo = repo
	self._active = False			self._active = False
	self._closed = False			self._closed = False
	self._backupname = 'dirstate.backup.%s.%d' % (name, id(self))			self._backupname = 'dirstate.backup.%s.%d' % (name, id(self))
	self._narrowspecbackupname = ('narrowspec.backup.%s.%d' %			self._narrowspecbackupname = 'narrowspec.backup.%s.%d' % (
	(name, id(self)))			name,
				id(self),
				)
	repo.dirstate.savebackup(repo.currenttransaction(), self._backupname)			repo.dirstate.savebackup(repo.currenttransaction(), self._backupname)
	narrowspec.savewcbackup(repo, self._narrowspecbackupname)			narrowspec.savewcbackup(repo, self._narrowspecbackupname)
	self._active = True			self._active = True

	def __del__(self):			def __del__(self):
	if self._active: # still active			if self._active: # still active
	# this may occur, even if this class is used correctly:			# this may occur, even if this class is used correctly:
	# for example, releasing other resources like transaction			# for example, releasing other resources like transaction
	# may raise exception before ``dirstateguard.release`` in			# may raise exception before ``dirstateguard.release`` in
	# ``release(tr, ....)``.			# ``release(tr, ....)``.
	self._abort()			self._abort()

	def close(self):			def close(self):
	if not self._active: # already inactivated			if not self._active: # already inactivated
	msg = (_("can't close already inactivated backup: %s")			msg = (
	% self._backupname)			_("can't close already inactivated backup: %s")
				% self._backupname
				)
	raise error.Abort(msg)			raise error.Abort(msg)

	self._repo.dirstate.clearbackup(self._repo.currenttransaction(),			self._repo.dirstate.clearbackup(
	self._backupname)			self._repo.currenttransaction(), self._backupname
				)
	narrowspec.clearwcbackup(self._repo, self._narrowspecbackupname)			narrowspec.clearwcbackup(self._repo, self._narrowspecbackupname)
	self._active = False			self._active = False
	self._closed = True			self._closed = True

	def _abort(self):			def _abort(self):
	narrowspec.restorewcbackup(self._repo, self._narrowspecbackupname)			narrowspec.restorewcbackup(self._repo, self._narrowspecbackupname)
	self._repo.dirstate.restorebackup(self._repo.currenttransaction(),			self._repo.dirstate.restorebackup(
	self._backupname)			self._repo.currenttransaction(), self._backupname
				)
	self._active = False			self._active = False

	def release(self):			def release(self):
	if not self._closed:			if not self._closed:
	if not self._active: # already inactivated			if not self._active: # already inactivated
	msg = (_("can't release already inactivated backup: %s")			msg = (
	% self._backupname)			_("can't release already inactivated backup: %s")
				% self._backupname
				)
	raise error.Abort(msg)			raise error.Abort(msg)
	self._abort()			self._abort()

mercurial/httpconnection.py

	self.write = self._data.write			self.write = self._data.write
	self.length = os.fstat(self._data.fileno()).st_size			self.length = os.fstat(self._data.fileno()).st_size
	self._pos = 0			self._pos = 0
	# We pass double the max for total because we currently have			# We pass double the max for total because we currently have
	# to send the bundle twice in the case of a server that			# to send the bundle twice in the case of a server that
	# requires authentication. Since we can't know until we try			# requires authentication. Since we can't know until we try
	# once whether authentication will be required, just lie to			# once whether authentication will be required, just lie to
	# the user and maybe the push succeeds suddenly at 50%.			# the user and maybe the push succeeds suddenly at 50%.
	self._progress = ui.makeprogress(_('sending'), unit=_('kb'),			self._progress = ui.makeprogress(
	total=(self.length // 1024 * 2))			_('sending'), unit=_('kb'), total=(self.length // 1024 * 2)
				)

	def read(self, args, *kwargs):			def read(self, args, *kwargs):
	ret = self._data.read(args, *kwargs)			ret = self._data.read(args, *kwargs)
	if not ret:			if not ret:
	self._progress.complete()			self._progress.complete()
	return ret			return ret
	self._pos += len(ret)			self._pos += len(ret)
	self._progress.update(self._pos // 1024)			self._progress.update(self._pos // 1024)
	return ret			return ret

	def __enter__(self):			def __enter__(self):
	return self			return self

	def __exit__(self, exc_type, exc_val, exc_tb):			def __exit__(self, exc_type, exc_val, exc_tb):
	self.close()			self.close()


	# moved here from url.py to avoid a cycle			# moved here from url.py to avoid a cycle
	def readauthforuri(ui, uri, user):			def readauthforuri(ui, uri, user):
	uri = pycompat.bytesurl(uri)			uri = pycompat.bytesurl(uri)
	# Read configuration			# Read configuration
	groups = {}			groups = {}
	for key, val in ui.configitems('auth'):			for key, val in ui.configitems('auth'):
	if key in ('cookiefile',):			if key in ('cookiefile',):
	continue			continue
	prefixurl.user = None			prefixurl.user = None
	prefix = bytes(prefixurl)			prefix = bytes(prefixurl)

	p = prefix.split('://', 1)			p = prefix.split('://', 1)
	if len(p) > 1:			if len(p) > 1:
	schemes, prefix = [p[0]], p[1]			schemes, prefix = [p[0]], p[1]
	else:			else:
	schemes = (auth.get('schemes') or 'https').split()			schemes = (auth.get('schemes') or 'https').split()
	if ((prefix == '*' or hostpath.startswith(prefix)) and			if (
	(len(prefix) > bestlen or (len(prefix) == bestlen and			(prefix == '*' or hostpath.startswith(prefix))
	not bestuser and 'username' in auth))			and (
	and scheme in schemes):			len(prefix) > bestlen
				or (
				len(prefix) == bestlen
				and not bestuser
				and 'username' in auth
				)
				)
				and scheme in schemes
				):
	bestlen = len(prefix)			bestlen = len(prefix)
	bestauth = group, auth			bestauth = group, auth
	bestuser = auth.get('username')			bestuser = auth.get('username')
	if user and not bestuser:			if user and not bestuser:
	auth['username'] = user			auth['username'] = user
	return bestauth			return bestauth

mercurial/minifileset.py

	from .i18n import _			from .i18n import _
	from . import (			from . import (
	error,			error,
	fileset,			fileset,
	filesetlang,			filesetlang,
	pycompat,			pycompat,
	)			)


	def _sizep(x):			def _sizep(x):
	# i18n: "size" is a keyword			# i18n: "size" is a keyword
	expr = filesetlang.getstring(x, _("size requires an expression"))			expr = filesetlang.getstring(x, _("size requires an expression"))
	return fileset.sizematcher(expr)			return fileset.sizematcher(expr)


	def _compile(tree):			def _compile(tree):
	if not tree:			if not tree:
	raise error.ParseError(_("missing argument"))			raise error.ParseError(_("missing argument"))
	op = tree[0]			op = tree[0]
	if op == 'withstatus':			if op == 'withstatus':
	return _compile(tree[1])			return _compile(tree[1])
	elif op in {'symbol', 'string', 'kindpat'}:			elif op in {'symbol', 'string', 'kindpat'}:
	name = filesetlang.getpattern(tree, {'path'}, _('invalid file pattern'))			name = filesetlang.getpattern(tree, {'path'}, _('invalid file pattern'))
	if name.startswith(''): # file extension test, ex. ".tar.gz"			if name.startswith(''): # file extension test, ex. ".tar.gz"
	ext = name[2:]			ext = name[2:]
	for c in pycompat.bytestr(ext):			for c in pycompat.bytestr(ext):
	if c in '*{}[]?/\\':			if c in '*{}[]?/\\':
	raise error.ParseError(_('reserved character: %s') % c)			raise error.ParseError(_('reserved character: %s') % c)
	return lambda n, s: n.endswith(ext)			return lambda n, s: n.endswith(ext)
	elif name.startswith('path:'): # directory or full path test			elif name.startswith('path:'): # directory or full path test
	p = name[5:] # prefix			p = name[5:] # prefix
	pl = len(p)			pl = len(p)
	f = lambda n, s: n.startswith(p) and (len(n) == pl			f = lambda n, s: n.startswith(p) and (
	or n[pl:pl + 1] == '/')			len(n) == pl or n[pl : pl + 1] == '/'
				)
	return f			return f
	raise error.ParseError(_("unsupported file pattern: %s") % name,			raise error.ParseError(
	hint=_('paths must be prefixed with "path:"'))			_("unsupported file pattern: %s") % name,
				hint=_('paths must be prefixed with "path:"'),
				)
	elif op in {'or', 'patterns'}:			elif op in {'or', 'patterns'}:
	funcs = [_compile(x) for x in tree[1:]]			funcs = [_compile(x) for x in tree[1:]]
	return lambda n, s: any(f(n, s) for f in funcs)			return lambda n, s: any(f(n, s) for f in funcs)
	elif op == 'and':			elif op == 'and':
	func1 = _compile(tree[1])			func1 = _compile(tree[1])
	func2 = _compile(tree[2])			func2 = _compile(tree[2])
	return lambda n, s: func1(n, s) and func2(n, s)			return lambda n, s: func1(n, s) and func2(n, s)
	elif op == 'not':			elif op == 'not':
	return lambda n, s: not _compile(tree[1])(n, s)			return lambda n, s: not _compile(tree[1])(n, s)
	elif op == 'func':			elif op == 'func':
	symbols = {			symbols = {
	'all': lambda n, s: True,			'all': lambda n, s: True,
	'none': lambda n, s: False,			'none': lambda n, s: False,
	'size': lambda n, s: _sizep(tree[2])(s),			'size': lambda n, s: _sizep(tree[2])(s),
	}			}

	name = filesetlang.getsymbol(tree[1])			name = filesetlang.getsymbol(tree[1])
	if name in symbols:			if name in symbols:
	return symbols[name]			return symbols[name]

	raise error.UnknownIdentifier(name, symbols.keys())			raise error.UnknownIdentifier(name, symbols.keys())
	elif op == 'minus': # equivalent to 'x and not y'			elif op == 'minus': # equivalent to 'x and not y'
	func1 = _compile(tree[1])			func1 = _compile(tree[1])
	func2 = _compile(tree[2])			func2 = _compile(tree[2])
	return lambda n, s: func1(n, s) and not func2(n, s)			return lambda n, s: func1(n, s) and not func2(n, s)
	elif op == 'list':			elif op == 'list':
	raise error.ParseError(_("can't use a list in this context"),			raise error.ParseError(
	hint=_('see \'hg help "filesets.x or y"\''))			_("can't use a list in this context"),
				hint=_('see \'hg help "filesets.x or y"\''),
				)
	raise error.ProgrammingError('illegal tree: %r' % (tree,))			raise error.ProgrammingError('illegal tree: %r' % (tree,))


	def compile(text):			def compile(text):
	"""generate a function (path, size) -> bool from filter specification.			"""generate a function (path, size) -> bool from filter specification.

	"text" could contain the operators defined by the fileset language for			"text" could contain the operators defined by the fileset language for
	common logic operations, and parenthesis for grouping. The supported path			common logic operations, and parenthesis for grouping. The supported path
	tests are '**.extname' for file extension test, and '"path:dir/subdir"'			tests are '**.extname' for file extension test, and '"path:dir/subdir"'
	for prefix test. The ``size()`` predicate is borrowed from filesets to test			for prefix test. The ``size()`` predicate is borrowed from filesets to test
	file size. The predicates ``all()`` and ``none()`` are also supported.			file size. The predicates ``all()`` and ``none()`` are also supported.

mercurial/node.py

	# profiles, we can use this version only on Python 3, and forward			# profiles, we can use this version only on Python 3, and forward
	# binascii.unhexlify like we used to on Python 2.			# binascii.unhexlify like we used to on Python 2.
	def bin(s):			def bin(s):
	try:			try:
	return binascii.unhexlify(s)			return binascii.unhexlify(s)
	except binascii.Error as e:			except binascii.Error as e:
	raise TypeError(e)			raise TypeError(e)


	nullrev = -1			nullrev = -1
	# In hex, this is '0000000000000000000000000000000000000000'			# In hex, this is '0000000000000000000000000000000000000000'
	nullid = b"\0" * 20			nullid = b"\0" * 20
	nullhex = hex(nullid)			nullhex = hex(nullid)

	# Phony node value to stand-in for new files in some uses of			# Phony node value to stand-in for new files in some uses of
	# manifests.			# manifests.
	# In hex, this is '2121212121212121212121212121212121212121'			# In hex, this is '2121212121212121212121212121212121212121'
	newnodeid = '!!!!!!!!!!!!!!!!!!!!'			newnodeid = '!!!!!!!!!!!!!!!!!!!!'
	# In hex, this is '3030303030303030303030303030306164646564'			# In hex, this is '3030303030303030303030303030306164646564'
	addednodeid = '000000000000000added'			addednodeid = '000000000000000added'
	# In hex, this is '3030303030303030303030306d6f646966696564'			# In hex, this is '3030303030303030303030306d6f646966696564'
	modifiednodeid = '000000000000modified'			modifiednodeid = '000000000000modified'

	wdirfilenodeids = {newnodeid, addednodeid, modifiednodeid}			wdirfilenodeids = {newnodeid, addednodeid, modifiednodeid}

	# pseudo identifiers for working directory			# pseudo identifiers for working directory
	# (they are experimental, so don't add too many dependencies on them)			# (they are experimental, so don't add too many dependencies on them)
	wdirrev = 0x7fffffff			wdirrev = 0x7FFFFFFF
	# In hex, this is 'ffffffffffffffffffffffffffffffffffffffff'			# In hex, this is 'ffffffffffffffffffffffffffffffffffffffff'
	wdirid = b"\xff" * 20			wdirid = b"\xff" * 20
	wdirhex = hex(wdirid)			wdirhex = hex(wdirid)


	def short(node):			def short(node):
	return hex(node[:6])			return hex(node[:6])

mercurial/policy.py

	# __modulepolicy__ generated by setup.py.			# __modulepolicy__ generated by setup.py.
	policy = b'allow'			policy = b'allow'
	_packageprefs = {			_packageprefs = {
	# policy: (versioned package, pure package)			# policy: (versioned package, pure package)
	b'c': (r'cext', None),			b'c': (r'cext', None),
	b'allow': (r'cext', r'pure'),			b'allow': (r'cext', r'pure'),
	b'cffi': (r'cffi', None),			b'cffi': (r'cffi', None),
	b'cffi-allow': (r'cffi', r'pure'),			b'cffi-allow': (r'cffi', r'pure'),
	b'py': (None, r'pure'),			b'py': (None, r'pure'),
	# For now, rust policies impact importrust only			# For now, rust policies impact importrust only
	b'rust+c': (r'cext', None),			b'rust+c': (r'cext', None),
	b'rust+c-allow': (r'cext', r'pure'),			b'rust+c-allow': (r'cext', r'pure'),
	}			}
				martinvonzUnsubmitted Not Done As I said on the pull request for black, I don't like that these lines get split up. martinvonz: As I said on the pull request for black, I don't like that these lines get split up.

	try:			try:
	from . import __modulepolicy__			from . import __modulepolicy__

	policy = __modulepolicy__.modulepolicy			policy = __modulepolicy__.modulepolicy
	except ImportError:			except ImportError:
	pass			pass

	# PyPy doesn't load C extensions.			# PyPy doesn't load C extensions.
	#			#
	# The canonical way to do this is to test platform.python_implementation().			# The canonical way to do this is to test platform.python_implementation().
	# But we don't import platform and don't bloat for it here.			# But we don't import platform and don't bloat for it here.
	if r'__pypy__' in sys.builtin_module_names:			if r'__pypy__' in sys.builtin_module_names:
	policy = b'cffi'			policy = b'cffi'

	# Environment variable can always force settings.			# Environment variable can always force settings.
	if sys.version_info[0] >= 3:			if sys.version_info[0] >= 3:
	if r'HGMODULEPOLICY' in os.environ:			if r'HGMODULEPOLICY' in os.environ:
	policy = os.environ[r'HGMODULEPOLICY'].encode(r'utf-8')			policy = os.environ[r'HGMODULEPOLICY'].encode(r'utf-8')
	else:			else:
	policy = os.environ.get(r'HGMODULEPOLICY', policy)			policy = os.environ.get(r'HGMODULEPOLICY', policy)


	def _importfrom(pkgname, modname):			def _importfrom(pkgname, modname):
	# from .<pkgname> import <modname> (where . is looked through this module)			# from .<pkgname> import <modname> (where . is looked through this module)
	fakelocals = {}			fakelocals = {}
	pkg = __import__(pkgname, globals(), fakelocals, [modname], level=1)			pkg = __import__(pkgname, globals(), fakelocals, [modname], level=1)
	try:			try:
	fakelocals[modname] = mod = getattr(pkg, modname)			fakelocals[modname] = mod = getattr(pkg, modname)
	except AttributeError:			except AttributeError:
	raise ImportError(r'cannot import name %s' % modname)			raise ImportError(r'cannot import name %s' % modname)
	# force import; fakelocals[modname] may be replaced with the real module			# force import; fakelocals[modname] may be replaced with the real module
	getattr(mod, r'__doc__', None)			getattr(mod, r'__doc__', None)
	return fakelocals[modname]			return fakelocals[modname]


	# keep in sync with "version" in C modules			# keep in sync with "version" in C modules
	_cextversions = {			_cextversions = {
	(r'cext', r'base85'): 1,			(r'cext', r'base85'): 1,
	(r'cext', r'bdiff'): 3,			(r'cext', r'bdiff'): 3,
	(r'cext', r'mpatch'): 1,			(r'cext', r'mpatch'): 1,
	(r'cext', r'osutil'): 4,			(r'cext', r'osutil'): 4,
	(r'cext', r'parsers'): 13,			(r'cext', r'parsers'): 13,
	}			}

	# map import request to other package or module			# map import request to other package or module
	_modredirects = {			_modredirects = {
	(r'cext', r'charencode'): (r'cext', r'parsers'),			(r'cext', r'charencode'): (r'cext', r'parsers'),
	(r'cffi', r'base85'): (r'pure', r'base85'),			(r'cffi', r'base85'): (r'pure', r'base85'),
	(r'cffi', r'charencode'): (r'pure', r'charencode'),			(r'cffi', r'charencode'): (r'pure', r'charencode'),
	(r'cffi', r'parsers'): (r'pure', r'parsers'),			(r'cffi', r'parsers'): (r'pure', r'parsers'),
	}			}


	def _checkmod(pkgname, modname, mod):			def _checkmod(pkgname, modname, mod):
	expected = _cextversions.get((pkgname, modname))			expected = _cextversions.get((pkgname, modname))
	actual = getattr(mod, r'version', None)			actual = getattr(mod, r'version', None)
	if actual != expected:			if actual != expected:
	raise ImportError(r'cannot import module %s.%s '			raise ImportError(
				r'cannot import module %s.%s '
	r'(expected version: %d, actual: %r)'			r'(expected version: %d, actual: %r)'
	% (pkgname, modname, expected, actual))			% (pkgname, modname, expected, actual)
				)


	def importmod(modname):			def importmod(modname):
	"""Import module according to policy and check API version"""			"""Import module according to policy and check API version"""
	try:			try:
	verpkg, purepkg = _packageprefs[policy]			verpkg, purepkg = _packageprefs[policy]
	except KeyError:			except KeyError:
	raise ImportError(r'invalid HGMODULEPOLICY %r' % policy)			raise ImportError(r'invalid HGMODULEPOLICY %r' % policy)
	assert verpkg or purepkg			assert verpkg or purepkg
	if verpkg:			if verpkg:
	pn, mn = _modredirects.get((verpkg, modname), (verpkg, modname))			pn, mn = _modredirects.get((verpkg, modname), (verpkg, modname))
	try:			try:
	mod = _importfrom(pn, mn)			mod = _importfrom(pn, mn)
	if pn == verpkg:			if pn == verpkg:
	_checkmod(pn, mn, mod)			_checkmod(pn, mn, mod)
	return mod			return mod
	except ImportError:			except ImportError:
	if not purepkg:			if not purepkg:
	raise			raise
	pn, mn = _modredirects.get((purepkg, modname), (purepkg, modname))			pn, mn = _modredirects.get((purepkg, modname), (purepkg, modname))
	return _importfrom(pn, mn)			return _importfrom(pn, mn)


	def _isrustpermissive():			def _isrustpermissive():
	"""Assuming the policy is a Rust one, tell if it's permissive."""			"""Assuming the policy is a Rust one, tell if it's permissive."""
	return policy.endswith(b'-allow')			return policy.endswith(b'-allow')


	def importrust(modname, member=None, default=None):			def importrust(modname, member=None, default=None):
	"""Import Rust module according to policy and availability.			"""Import Rust module according to policy and availability.

	If policy isn't a Rust one, this returns `default`.			If policy isn't a Rust one, this returns `default`.

	If either the module or its member is not available, this returns `default`			If either the module or its member is not available, this returns `default`
	if policy is permissive and raises `ImportError` if not.			if policy is permissive and raises `ImportError` if not.
	"""			"""

mercurial/pushkey.py

	# pushkey.py - dispatching for pushing and pulling keys			# pushkey.py - dispatching for pushing and pulling keys
	#			#
	# Copyright 2010 Matt Mackall <mpm@selenic.com>			# Copyright 2010 Matt Mackall <mpm@selenic.com>
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import

	from . import (			from . import (
	bookmarks,			bookmarks,
	encoding,			encoding,
	obsolete,			obsolete,
	phases,			phases,
	)			)


	def _nslist(repo):			def _nslist(repo):
	n = {}			n = {}
	for k in _namespaces:			for k in _namespaces:
	n[k] = ""			n[k] = ""
	if not obsolete.isenabled(repo, obsolete.exchangeopt):			if not obsolete.isenabled(repo, obsolete.exchangeopt):
	n.pop('obsolete')			n.pop('obsolete')
	return n			return n

	_namespaces = {"namespaces": (lambda *x: False, _nslist),
				_namespaces = {
				"namespaces": (lambda *x: False, _nslist),
	"bookmarks": (bookmarks.pushbookmark, bookmarks.listbookmarks),			"bookmarks": (bookmarks.pushbookmark, bookmarks.listbookmarks),
	"phases": (phases.pushphase, phases.listphases),			"phases": (phases.pushphase, phases.listphases),
	"obsolete": (obsolete.pushmarker, obsolete.listmarkers),			"obsolete": (obsolete.pushmarker, obsolete.listmarkers),
	}			}


	def register(namespace, pushkey, listkeys):			def register(namespace, pushkey, listkeys):
	_namespaces[namespace] = (pushkey, listkeys)			_namespaces[namespace] = (pushkey, listkeys)


	def _get(namespace):			def _get(namespace):
	return _namespaces.get(namespace, (lambda x: False, lambda x: {}))			return _namespaces.get(namespace, (lambda x: False, lambda x: {}))


	def push(repo, namespace, key, old, new):			def push(repo, namespace, key, old, new):
	'''should succeed iff value was old'''			'''should succeed iff value was old'''
	pk = _get(namespace)[0]			pk = _get(namespace)[0]
	return pk(repo, key, old, new)			return pk(repo, key, old, new)


	def list(repo, namespace):			def list(repo, namespace):
	'''return a dict'''			'''return a dict'''
	lk = _get(namespace)[1]			lk = _get(namespace)[1]
	return lk(repo)			return lk(repo)


	encode = encoding.fromlocal			encode = encoding.fromlocal

	decode = encoding.tolocal			decode = encoding.tolocal


	def encodekeys(keys):			def encodekeys(keys):
	"""encode the content of a pushkey namespace for exchange over the wire"""			"""encode the content of a pushkey namespace for exchange over the wire"""
	return '\n'.join(['%s\t%s' % (encode(k), encode(v)) for k, v in keys])			return '\n'.join(['%s\t%s' % (encode(k), encode(v)) for k, v in keys])


	def decodekeys(data):			def decodekeys(data):
	"""decode the content of a pushkey namespace from exchange over the wire"""			"""decode the content of a pushkey namespace from exchange over the wire"""
	result = {}			result = {}
	for l in data.splitlines():			for l in data.splitlines():
	k, v = l.split('\t')			k, v = l.split('\t')
	result[decode(k)] = decode(v)			result[decode(k)] = decode(v)
	return result			return result

mercurial/rcutil.py

	from . import scmwindows as scmplatform			from . import scmwindows as scmplatform
	else:			else:
	from . import scmposix as scmplatform			from . import scmposix as scmplatform

	fallbackpager = scmplatform.fallbackpager			fallbackpager = scmplatform.fallbackpager
	systemrcpath = scmplatform.systemrcpath			systemrcpath = scmplatform.systemrcpath
	userrcpath = scmplatform.userrcpath			userrcpath = scmplatform.userrcpath


	def _expandrcpath(path):			def _expandrcpath(path):
	'''path could be a file or a directory. return a list of file paths'''			'''path could be a file or a directory. return a list of file paths'''
	p = util.expandpath(path)			p = util.expandpath(path)
	if os.path.isdir(p):			if os.path.isdir(p):
	join = os.path.join			join = os.path.join
	return sorted(join(p, f) for f, k in util.listdir(p)			return sorted(
	if f.endswith('.rc'))			join(p, f) for f, k in util.listdir(p) if f.endswith('.rc')
				)
	return [p]			return [p]


	def envrcitems(env=None):			def envrcitems(env=None):
	'''Return [(section, name, value, source)] config items.			'''Return [(section, name, value, source)] config items.

	The config items are extracted from environment variables specified by env,			The config items are extracted from environment variables specified by env,
	used to override systemrc, but not userrc.			used to override systemrc, but not userrc.

	If env is not provided, encoding.environ will be used.			If env is not provided, encoding.environ will be used.
	'''			'''
	if env is None:			if env is None:
	env = encoding.environ			env = encoding.environ
	checklist = [			checklist = [
	('EDITOR', 'ui', 'editor'),			('EDITOR', 'ui', 'editor'),
	('VISUAL', 'ui', 'editor'),			('VISUAL', 'ui', 'editor'),
	('PAGER', 'pager', 'pager'),			('PAGER', 'pager', 'pager'),
	]			]
	result = []			result = []
	for envname, section, configname in checklist:			for envname, section, configname in checklist:
	if envname not in env:			if envname not in env:
	continue			continue
	result.append((section, configname, env[envname], '$%s' % envname))			result.append((section, configname, env[envname], '$%s' % envname))
	return result			return result


	def defaultrcpath():			def defaultrcpath():
	'''return rc paths in default.d'''			'''return rc paths in default.d'''
	path = []			path = []
	defaultpath = os.path.join(util.datapath, 'default.d')			defaultpath = os.path.join(util.datapath, 'default.d')
	if os.path.isdir(defaultpath):			if os.path.isdir(defaultpath):
	path = _expandrcpath(defaultpath)			path = _expandrcpath(defaultpath)
	return path			return path


	def rccomponents():			def rccomponents():
	'''return an ordered [(type, obj)] about where to load configs.			'''return an ordered [(type, obj)] about where to load configs.

	respect $HGRCPATH. if $HGRCPATH is empty, only .hg/hgrc of current repo is			respect $HGRCPATH. if $HGRCPATH is empty, only .hg/hgrc of current repo is
	used. if $HGRCPATH is not set, the platform default will be used.			used. if $HGRCPATH is not set, the platform default will be used.

	if a directory is provided, *.rc files under it will be used.			if a directory is provided, *.rc files under it will be used.

	_rccomponents.extend(('path', p) for p in _expandrcpath(p))			_rccomponents.extend(('path', p) for p in _expandrcpath(p))
	else:			else:
	normpaths = lambda paths: [('path', os.path.normpath(p)) for p in paths]			normpaths = lambda paths: [('path', os.path.normpath(p)) for p in paths]
	_rccomponents = normpaths(defaultrcpath() + systemrcpath())			_rccomponents = normpaths(defaultrcpath() + systemrcpath())
	_rccomponents.append(envrc)			_rccomponents.append(envrc)
	_rccomponents.extend(normpaths(userrcpath()))			_rccomponents.extend(normpaths(userrcpath()))
	return _rccomponents			return _rccomponents


	def defaultpagerenv():			def defaultpagerenv():
	'''return a dict of default environment variables and their values,			'''return a dict of default environment variables and their values,
	intended to be set before starting a pager.			intended to be set before starting a pager.
	'''			'''
	return {'LESS': 'FRX', 'LV': '-c'}			return {'LESS': 'FRX', 'LV': '-c'}

mercurial/rewriteutil.py


	from . import (			from . import (
	error,			error,
	node,			node,
	obsolete,			obsolete,
	revset,			revset,
	)			)


	def precheck(repo, revs, action='rewrite'):			def precheck(repo, revs, action='rewrite'):
	"""check if revs can be rewritten			"""check if revs can be rewritten
	action is used to control the error message.			action is used to control the error message.

	Make sure this function is called after taking the lock.			Make sure this function is called after taking the lock.
	"""			"""
	if node.nullrev in revs:			if node.nullrev in revs:
	msg = _("cannot %s null changeset") % (action)			msg = _("cannot %s null changeset") % action
	hint = _("no changeset checked out")			hint = _("no changeset checked out")
	raise error.Abort(msg, hint=hint)			raise error.Abort(msg, hint=hint)

	if len(repo[None].parents()) > 1:			if len(repo[None].parents()) > 1:
	raise error.Abort(_("cannot %s while merging") % action)			raise error.Abort(_("cannot %s while merging") % action)

	publicrevs = repo.revs('%ld and public()', revs)			publicrevs = repo.revs('%ld and public()', revs)
	if publicrevs:			if publicrevs:
	msg = _("cannot %s public changesets") % (action)			msg = _("cannot %s public changesets") % action
	hint = _("see 'hg help phases' for details")			hint = _("see 'hg help phases' for details")
	raise error.Abort(msg, hint=hint)			raise error.Abort(msg, hint=hint)

	newunstable = disallowednewunstable(repo, revs)			newunstable = disallowednewunstable(repo, revs)
	if newunstable:			if newunstable:
	raise error.Abort(_("cannot %s changeset with children") % action)			raise error.Abort(_("cannot %s changeset with children") % action)


	def disallowednewunstable(repo, revs):			def disallowednewunstable(repo, revs):
	"""Checks whether editing the revs will create new unstable changesets and			"""Checks whether editing the revs will create new unstable changesets and
	are we allowed to create them.			are we allowed to create them.

	To allow new unstable changesets, set the config:			To allow new unstable changesets, set the config:
	`experimental.evolution.allowunstable=True`			`experimental.evolution.allowunstable=True`
	"""			"""
	allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)			allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
	if allowunstable:			if allowunstable:
	return revset.baseset()			return revset.baseset()
	return repo.revs("(%ld::) - %ld", revs, revs)			return repo.revs("(%ld::) - %ld", revs, revs)

mercurial/scmposix.py

	)			)

	# BSD 'more' escapes ANSI color sequences by default. This can be disabled by			# BSD 'more' escapes ANSI color sequences by default. This can be disabled by
	# $MORE variable, but there's no compatible option with Linux 'more'. Given			# $MORE variable, but there's no compatible option with Linux 'more'. Given
	# OS X is widely used and most modern Unix systems would have 'less', setting			# OS X is widely used and most modern Unix systems would have 'less', setting
	# 'less' as the default seems reasonable.			# 'less' as the default seems reasonable.
	fallbackpager = 'less'			fallbackpager = 'less'


	def _rcfiles(path):			def _rcfiles(path):
	rcs = [os.path.join(path, 'hgrc')]			rcs = [os.path.join(path, 'hgrc')]
	rcdir = os.path.join(path, 'hgrc.d')			rcdir = os.path.join(path, 'hgrc.d')
	try:			try:
	rcs.extend([os.path.join(rcdir, f)			rcs.extend(
				[
				os.path.join(rcdir, f)
	for f, kind in util.listdir(rcdir)			for f, kind in util.listdir(rcdir)
	if f.endswith(".rc")])			if f.endswith(".rc")
				]
				)
	except OSError:			except OSError:
	pass			pass
	return rcs			return rcs


	def systemrcpath():			def systemrcpath():
	path = []			path = []
	if pycompat.sysplatform == 'plan9':			if pycompat.sysplatform == 'plan9':
	root = 'lib/mercurial'			root = 'lib/mercurial'
	else:			else:
	root = 'etc/mercurial'			root = 'etc/mercurial'
	# old mod_python does not set sys.argv			# old mod_python does not set sys.argv
	if len(getattr(sys, 'argv', [])) > 0:			if len(getattr(sys, 'argv', [])) > 0:
	p = os.path.dirname(os.path.dirname(pycompat.sysargv[0]))			p = os.path.dirname(os.path.dirname(pycompat.sysargv[0]))
	if p != '/':			if p != '/':
	path.extend(_rcfiles(os.path.join(p, root)))			path.extend(_rcfiles(os.path.join(p, root)))
	path.extend(_rcfiles('/' + root))			path.extend(_rcfiles('/' + root))
	return path			return path


	def userrcpath():			def userrcpath():
	if pycompat.sysplatform == 'plan9':			if pycompat.sysplatform == 'plan9':
	return [encoding.environ['home'] + '/lib/hgrc']			return [encoding.environ['home'] + '/lib/hgrc']
	elif pycompat.isdarwin:			elif pycompat.isdarwin:
	return [os.path.expanduser('~/.hgrc')]			return [os.path.expanduser('~/.hgrc')]
	else:			else:
	confighome = encoding.environ.get('XDG_CONFIG_HOME')			confighome = encoding.environ.get('XDG_CONFIG_HOME')
	if confighome is None or not os.path.isabs(confighome):			if confighome is None or not os.path.isabs(confighome):
	confighome = os.path.expanduser('~/.config')			confighome = os.path.expanduser('~/.config')

	return [os.path.expanduser('~/.hgrc'),			return [
	os.path.join(confighome, 'hg', 'hgrc')]			os.path.expanduser('~/.hgrc'),
				os.path.join(confighome, 'hg', 'hgrc'),
				]


	def termsize(ui):			def termsize(ui):
	try:			try:
	import termios			import termios

	TIOCGWINSZ = termios.TIOCGWINSZ # unavailable on IRIX (issue3449)			TIOCGWINSZ = termios.TIOCGWINSZ # unavailable on IRIX (issue3449)
	except (AttributeError, ImportError):			except (AttributeError, ImportError):
	return 80, 24			return 80, 24

	for dev in (ui.ferr, ui.fout, ui.fin):			for dev in (ui.ferr, ui.fout, ui.fin):
	try:			try:
	try:			try:
	fd = dev.fileno()			fd = dev.fileno()

mercurial/scmwindows.py

	from __future__ import absolute_import			from __future__ import absolute_import

	import os			import os

	from . import (			from . import (
	encoding,			encoding,
	pycompat,			pycompat,
	util,			util,
	win32,			win32,
	)			)

	try:			try:
	import _winreg as winreg			import _winreg as winreg

	winreg.CloseKey			winreg.CloseKey
	except ImportError:			except ImportError:
	import winreg			import winreg

	# MS-DOS 'more' is the only pager available by default on Windows.			# MS-DOS 'more' is the only pager available by default on Windows.
	fallbackpager = 'more'			fallbackpager = 'more'


	def systemrcpath():			def systemrcpath():
	'''return default os-specific hgrc search path'''			'''return default os-specific hgrc search path'''
	rcpath = []			rcpath = []
	filename = win32.executablepath()			filename = win32.executablepath()
	# Use mercurial.ini found in directory with hg.exe			# Use mercurial.ini found in directory with hg.exe
	progrc = os.path.join(os.path.dirname(filename), 'mercurial.ini')			progrc = os.path.join(os.path.dirname(filename), 'mercurial.ini')
	rcpath.append(progrc)			rcpath.append(progrc)
	# Use hgrc.d found in directory with hg.exe			# Use hgrc.d found in directory with hg.exe
	progrcd = os.path.join(os.path.dirname(filename), 'hgrc.d')			progrcd = os.path.join(os.path.dirname(filename), 'hgrc.d')
	if os.path.isdir(progrcd):			if os.path.isdir(progrcd):
	for f, kind in util.listdir(progrcd):			for f, kind in util.listdir(progrcd):
	if f.endswith('.rc'):			if f.endswith('.rc'):
	rcpath.append(os.path.join(progrcd, f))			rcpath.append(os.path.join(progrcd, f))
	# else look for a system rcpath in the registry			# else look for a system rcpath in the registry
	value = util.lookupreg('SOFTWARE\\Mercurial', None,			value = util.lookupreg(
	winreg.HKEY_LOCAL_MACHINE)			'SOFTWARE\\Mercurial', None, winreg.HKEY_LOCAL_MACHINE
				)
	if not isinstance(value, str) or not value:			if not isinstance(value, str) or not value:
	return rcpath			return rcpath
	value = util.localpath(value)			value = util.localpath(value)
	for p in value.split(pycompat.ospathsep):			for p in value.split(pycompat.ospathsep):
	if p.lower().endswith('mercurial.ini'):			if p.lower().endswith('mercurial.ini'):
	rcpath.append(p)			rcpath.append(p)
	elif os.path.isdir(p):			elif os.path.isdir(p):
	for f, kind in util.listdir(p):			for f, kind in util.listdir(p):
	if f.endswith('.rc'):			if f.endswith('.rc'):
	rcpath.append(os.path.join(p, f))			rcpath.append(os.path.join(p, f))
	return rcpath			return rcpath


	def userrcpath():			def userrcpath():
	'''return os-specific hgrc search path to the user dir'''			'''return os-specific hgrc search path to the user dir'''
	home = os.path.expanduser('~')			home = os.path.expanduser('~')
	path = [os.path.join(home, 'mercurial.ini'),			path = [os.path.join(home, 'mercurial.ini'), os.path.join(home, '.hgrc')]
	os.path.join(home, '.hgrc')]
	userprofile = encoding.environ.get('USERPROFILE')			userprofile = encoding.environ.get('USERPROFILE')
	if userprofile and userprofile != home:			if userprofile and userprofile != home:
	path.append(os.path.join(userprofile, 'mercurial.ini'))			path.append(os.path.join(userprofile, 'mercurial.ini'))
	path.append(os.path.join(userprofile, '.hgrc'))			path.append(os.path.join(userprofile, '.hgrc'))
	return path			return path


	def termsize(ui):			def termsize(ui):
	return win32.termsize()			return win32.termsize()

mercurial/stack.py

	# stack.py - Mercurial functions for stack definition			# stack.py - Mercurial functions for stack definition
	#			#
	# Copyright Matt Mackall <mpm@selenic.com> and other			# Copyright Matt Mackall <mpm@selenic.com> and other
	#			#
	# This software may be used and distributed according to the terms of the			# This software may be used and distributed according to the terms of the
	# GNU General Public License version 2 or any later version.			# GNU General Public License version 2 or any later version.

	from __future__ import absolute_import			from __future__ import absolute_import


	def getstack(repo, rev=None):			def getstack(repo, rev=None):
	"""return a sorted smartrev of the stack containing either rev if it is			"""return a sorted smartrev of the stack containing either rev if it is
	not None or the current working directory parent.			not None or the current working directory parent.

	The stack will always contain all drafts changesets which are ancestors to			The stack will always contain all drafts changesets which are ancestors to
	the revision and are not merges.			the revision and are not merges.
	"""			"""
	if rev is None:			if rev is None:
	rev = '.'			rev = '.'

	revspec = 'only(%s) and not public() and not ::merge()'			revspec = 'only(%s) and not public() and not ::merge()'
	revisions = repo.revs(revspec, rev)			revisions = repo.revs(revspec, rev)
	revisions.sort()			revisions.sort()
	return revisions			return revisions

pyproject.toml

This file was added.

				[tool.black]
				line-length = 80
				exclude = 'build/\|wheelhouse/\|dist/\|packages/\|\.hg/\|\.mypy_cache/\|\.venv/\|mercurial/thirdparty/\|hgext/fsmonitor/pywatchman/\|contrib/python-zstandard/'

		Path
M		contrib/import-checker.py (175 lines)
M		mercurial/cacheutil.py (1 line)
M		mercurial/diffhelper.py (3 lines)
M		mercurial/dirstateguard.py (35 lines)
M		mercurial/httpconnection.py (22 lines)
M		mercurial/minifileset.py (28 lines)
M		mercurial/node.py (4 lines)
M		mercurial/policy.py (15 lines)
M		mercurial/pushkey.py (20 lines)
M		mercurial/rcutil.py (10 lines)
M		mercurial/rewriteutil.py (6 lines)
M		mercurial/scmposix.py (21 lines)
M		mercurial/scmwindows.py (12 lines)
M		mercurial/stack.py (1 line)
A	M	pyproject.toml (3 lines)

This is an archive of the discontinued Mercurial Phabricator instance.

style: run a patched black on a subset of mercurial
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents
Changeset List

Diff 16812

contrib/import-checker.py

mercurial/cacheutil.py

mercurial/diffhelper.py

mercurial/dirstateguard.py

mercurial/httpconnection.py

mercurial/minifileset.py

mercurial/node.py

mercurial/policy.py

mercurial/pushkey.py

mercurial/rcutil.py

mercurial/rewriteutil.py

mercurial/scmposix.py

mercurial/scmwindows.py

mercurial/stack.py

pyproject.toml

This is an archive of the discontinued Mercurial Phabricator instance.

style: run a patched black on a subset of mercurialClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 16812

contrib/import-checker.py

mercurial/cacheutil.py

mercurial/diffhelper.py

mercurial/dirstateguard.py

mercurial/httpconnection.py

mercurial/minifileset.py

mercurial/node.py

mercurial/policy.py

mercurial/pushkey.py

mercurial/rcutil.py

mercurial/rewriteutil.py

mercurial/scmposix.py

mercurial/scmwindows.py

mercurial/stack.py

pyproject.toml

style: run a patched black on a subset of mercurial
ClosedPublic

Revision Contents
Changeset List