Datasets:

chuxuan
/

REPRO-Bench

	# -- coding: utf-8 --
	from __future__ import absolute_import, division, print_function, unicode_literals
	from future.utils import raise_from, string_types
	from builtins import (bytes, str, open, super, range,
	zip, round, input, int, pow, object)

	import os
	import re
	import io
	import sys
	import glob
	import yaml
	import codecs
	import filecmp
	import traceback

	import gslab_make.private.messages as messages
	from gslab_make.private.exceptionclasses import CritError


	def decode(string):
	"""Decode string."""

	if (sys.version_info < (3, 0)) and isinstance(string, string_types):
	string = codecs.decode(string, 'latin1')

	return(string)


	def encode(string):
	"""Clean string for encoding."""

	if (sys.version_info < (3, 0)) and isinstance(string, unicode):
	string = codecs.encode(string, 'utf-8')

	return(string)


	def convert_to_list(obj, warning_type):
	"""Convert object to list."""

	obj = [obj] if isinstance(obj, string_types) else obj

	if type(obj) is not list:
	if (warning_type == 'dir'):
	raise_from(TypeError(messages.type_error_dir_list % obj), None)
	elif (warning_type == 'file'):
	raise_from(TypeError(messages.type_error_file_list % obj), None)

	return(obj)


	def norm_path(path):
	"""Normalize path to be OS-compatible."""

	if path:
	path = re.split('[/\\\\]+', path)
	path = os.path.sep.join(path)
	path = os.path.expanduser(path)
	path = os.path.abspath(path)

	return(path)


	def get_path(paths_dict, key, throw_error = True):
	"""Get path for key.

	Parameters
	----------
	path_dict : dict
	Dictionary of paths.
	key : str
	Path to get from dictionary.
	throw_error : bool
	Return error instead of ``None``. Defaults to ``True``.

	Returns
	-------
	path : str
	Path requested.
	"""

	try:
	path = paths_dict[key]
	if isinstance(path, string_types):
	path = norm_path(path)
	elif isinstance(path, list):
	path = [norm_path(p) for p in path]
	except KeyError:
	if throw_error:
	raise_from(CritError(messages.crit_error_no_key % (key, key)), None)
	else:
	path = None

	return(path)


	def glob_recursive(path, depth, max_depth = 20, quiet = True):
	"""Walks through path.

	Notes
	-----
	Takes glob-style wildcards.

	Parameters
	----------
	path : str
	Path to walk through.
	depth : int
	Level of depth when walking through path.
	max_depth : int
	Maximum level of depth allowed. Defaults to 20.
	quiet : bool, optional
	Suppress warning if no files globbed. Defaults to ``True``.

	Returns
	-------
	path_files : list
	List of files contained in path.
	"""

	depth = max_depth if depth > max_depth else depth
	path_walk = norm_path(path)
	path_files = glob.glob(path_walk)

	i = 0
	while i <= depth:
	path_walk = os.path.join(path_walk, "*")
	glob_files = glob.glob(path_walk)
	if glob_files:
	path_files.extend(glob_files)
	i += 1
	else:
	break

	path_files = [p for p in path_files if os.path.isfile(p)]
	if not path_files and not quiet:
	print(messages.warning_glob % (path, depth))

	return(path_files)


	def file_to_array(file_name):
	"""Read file and extract lines to list.

	Parameters
	----------
	file_name : str
	Path of file to read.

	Returns
	-------
	array : list
	List of lines contained in file.
	"""

	with io.open(file_name, encoding = 'utf-8') as f:
	array = [line.strip() for line in f]
	array = [line for line in array if line]
	array = [line for line in array if not re.match('\#',line)]

	return(array)


	def format_traceback(trace = ''):
	"""Format traceback message.

	Parameters
	----------
	trace : str
	Traceback to format. Defaults to ``traceback.format_exc``.

	Notes
	-----
	Format trackback for readability to pass into user messages.

	Returns
	-------
	formatted : str
	Formatted traceback.
	"""

	if not trace:
	trace = traceback.format_exc()

	trace = trace.strip()
	trace = '\n' + decode(trace)
	formatted = re.sub('\n', '\n > ', trace)

	return(formatted)


	def format_message(message):
	"""Format message."""

	message = message.strip()
	star_line = '' (len(message) + 4)
	formatted = star_line + '\n* %s *\n' + star_line
	formatted = formatted % message

	return(formatted)


	def format_list(list):
	"""Format list.

	Parameters
	----------
	list : list
	List to format.

	Notes
	-----
	Format list for readability to pass into user messages.

	Returns
	-------
	formatted : str
	Formatted list.
	"""

	formatted = ['`' + str(item) + '`' for item in list]
	formatted = ", ".join(formatted)

	return(formatted)


	def open_yaml(path):
	"""Safely loads YAML file."""

	path = norm_path(path)

	with io.open(path, 'r') as f:
	stream = yaml.safe_load(f)

	return(stream)


	# ~~~~~~~~~~ #
	# DEPRECATED #
	# ~~~~~~~~~~ #

	def check_duplicate(original, copy):
	"""Check duplicate.

	Parameters
	----------
	original : str
	Original path.
	copy : str
	Path to check if duplicate.

	Returns
	-------
	duplicate : bool
	Destination is duplicate.
	"""

	duplicate = os.path.exists(copy)

	if duplicate:
	if os.path.isfile(original):
	duplicate = filecmp.cmp(original, copy)
	elif os.path.isdir(copy):
	dircmp = filecmp.dircmp(original, copy, ignore = ['.DS_Store'])
	duplicate = parse_dircmp(dircmp)
	else:
	duplicate = False

	return(duplicate)


	def parse_dircmp(dircmp):
	"""Parse dircmp to see if directories duplicate.

	Parameters
	----------
	dircmp : ``filecmp.dircmp``
	dircmp to parse if directories duplicate.

	Returns
	-------
	duplicate : bool
	Directories are duplicates.
	"""

	# Check directory
	if dircmp.left_only:
	return False
	if dircmp.right_only:
	return False
	if dircmp.diff_files:
	return False
	if dircmp.funny_files:
	return False
	if dircmp.common_funny:
	return False

	# Check subdirectories
	duplicate = True

	for subdir in dircmp.subdirs.itervalues():
	if duplicate:
	duplicate = check_duplicate(subdir)
	else:
	break

	return(duplicate)