pocketutils.misc.klgists

Complexity

Total Complexity

219

Size/Duplication

Total Lines	828
Duplicated Lines	1.45 %

Importance

Changes

0

62 Functions

Rating	Name	Duplication	Size	Complexity
A	nice_time()	0	6	2
A	sanitize_str()	0	3	1
A	year_range()	0	4	1
B	init_logger()	0	33	6
A	flatmap()	0	2	1
A	pretty_dict()	0	3	1
A	pjoin_sanitized_rel()	0	6	1
A	read_properties_file()	0	17	4
A	pjoin_sanitized_abs()	0	3	1
A	_reader()	0	7	3
A	format_time()	0	3	1
A	escape_for_tsv()	0	2	1
A	approxeq()	0	5	1
A	scan_for_files()	0	11	3
A	_sanitize_bit()	0	3	2
A	flatten()	0	2	1
A	now()	0	2	1
A	file_from_env_var()	0	14	4
A	fix_path()	0	10	4
A	blob_to_short_array()	0	2	1
A	make_dirs()	0	8	3
B	zip_strict()	0	20	7
A	_log()	0	3	1
A	only()	0	15	3
A	this_year()	0	2	1
A	_disp()	0	8	3
A	pp_dict()	0	3	1
A	escape_for_properties()	0	2	1
A	remake_dirs()	0	9	4
A	is_proper_file()	0	3	1
A	read_lines_file()	0	13	4
A	blob_to_double_array()	0	2	1
A	blob_to_int_array()	0	2	1
A	json_serial()	0	12	4
A	git_commit_hash()	0	7	2
A	walk_until_level()	0	16	4
A	fix_path_platform_dependent()	0	12	2
B	smart_log_callback()	12	14	6
A	blob_to_long_array()	0	2	1
A	scantree()	0	9	4
B	lines()	0	12	7
A	_blob_to_dt()	0	2	1
A	blob_to_byte_array()	0	2	1
A	grandpardir()	0	2	1
A	pkl()	0	3	2
A	walk_until()	0	10	3
A	unpkl()	0	3	2
A	today()	0	2	1
A	mkdate()	0	2	1
A	mkdatetime()	0	2	1
A	look()	0	5	4
A	pardir()	0	4	2
A	parse_local_iso_datetime()	0	2	1
A	blob_to_float_array()	0	2	1
A	timestamp_path()	0	3	1
A	decorator()	0	2	1
A	wrap_cmd_call()	0	26	4
B	stream_cmd_call()	0	25	6
A	timestamp()	0	3	1
A	try_index_of()	0	6	2
A	pp_size()	0	3	1
A	exists()	0	6	3

import typing

Missing module docstring

import os, io, shutil, gzip, platform, re

Multiple imports on one line (os, io, shutil, gzip, platform, re)

from enum import Enum

from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError

The name core does not seem to exist in module pocketutils.

import json, sys

Multiple imports on one line (json, sys)

standard import "import json, sys" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

import unicodedata

standard import "import unicodedata" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

from itertools import chain

standard import "from itertools import chain" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

import signal

standard import "import signal" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

import operator

standard import "import operator" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

from datetime import date, datetime

standard import "from datetime import date, datetime" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

from typing import Callable, TypeVar, Iterator, Iterable, Optional, List, Any, Sequence, Mapping, Dict, ItemsView, KeysView, ValuesView, Tuple, Union

This line is too long as per the coding-style (149/100).

standard import "from typing import Callable, TypeVar, Iterator, Iterable, Optional, List, Any, Sequence, Mapping, Dict, ItemsView, KeysView, ValuesView, Tuple, Union" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

from hurry.filesize import size as hsize

Unable to import 'hurry.filesize'

from pocketutils.core.exceptions import LookupFailedError, MultipleMatchesError, ParsingError, ResourceError, MissingConfigKeyError, \

This line is too long as per the coding-style (134/100).

The name core does not seem to exist in module pocketutils.

Unused MissingConfigKeyError imported from pocketutils.core.exceptions

Imports from package pocketutils are not grouped

NaturalExpectedError, HashValidationError, FileDoesNotExistError

import logging

standard import "import logging" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

import subprocess

standard import "import subprocess" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

from subprocess import Popen, PIPE

standard import "from subprocess import Popen, PIPE" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

from queue import Queue

standard import "from queue import Queue" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

from threading import Thread

standard import "from threading import Thread" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

from deprecated import deprecated

Unable to import 'deprecated'

import datetime

The import datetime was already done on line 12. You should be able to
remove this line.

standard import "import datetime" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

#from datetime import datetime
from subprocess import Popen, PIPE

The import Popen was already done on line 21. You should be able to
remove this line.

The import PIPE was already done on line 21. You should be able to
remove this line.

standard import "from subprocess import Popen, PIPE" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

Imports from package subprocess are not grouped

from infix import shift_infix, mod_infix, sub_infix

Unable to import 'infix'

Unused mod_infix imported from infix

Unused sub_infix imported from infix

from colorama import Fore

Unable to import 'colorama'

import shutil

The import shutil was already done on line 2. You should be able to
remove this line.

standard import "import shutil" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

Imports from package shutil are not grouped

import argparse

standard import "import argparse" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

import hashlib

standard import "import hashlib" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

import codecs

standard import "import codecs" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

import gzip

The import gzip was already done on line 2. You should be able to
remove this line.

standard import "import gzip" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

Imports from package gzip are not grouped

import struct

standard import "import struct" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

from array import array

Unused array imported from array

standard import "from array import array" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

import numpy as np

Unable to import 'numpy'

def blob_to_byte_array(bytes_obj: bytes):

Missing function or method docstring

	return _blob_to_dt(bytes_obj, 'b', 1, np.ubyte) + 128

Found indentation with tabs instead of spaces

def blob_to_float_array(bytes_obj: bytes):

Missing function or method docstring

	return _blob_to_dt(bytes_obj, 'f', 4, np.float32)

Found indentation with tabs instead of spaces

def blob_to_double_array(bytes_obj: bytes):

Missing function or method docstring

	return _blob_to_dt(bytes_obj, 'd', 8, np.float64)

Found indentation with tabs instead of spaces

def blob_to_short_array(bytes_obj: bytes):

Missing function or method docstring

	return _blob_to_dt(bytes_obj, 'H', 2, np.int16)

Found indentation with tabs instead of spaces

def blob_to_int_array(bytes_obj: bytes):

Missing function or method docstring

	return _blob_to_dt(bytes_obj, 'I', 4, np.int32)

Found indentation with tabs instead of spaces

def blob_to_long_array(bytes_obj: bytes):

Missing function or method docstring

	return _blob_to_dt(bytes_obj, 'Q', 8, np.int64)

Found indentation with tabs instead of spaces

def _blob_to_dt(bytes_obj: bytes, data_type_str: str, data_type_len: int, dtype):
	return np.array(next(iter(struct.iter_unpack('>' + data_type_str * int(len(bytes_obj)/data_type_len), bytes_obj))), dtype=dtype)

This line is too long as per the coding-style (129/100).

Found indentation with tabs instead of spaces

class FileHasher:

Missing class docstring

	def __init__(self, algorithm: Callable[[], Any]=hashlib.sha1, extension: str='.sha1', buffer_size: int = 16*1024):

This line is too long as per the coding-style (115/100).

Found indentation with tabs instead of spaces

Exactly one space required around keyword argument assignment

		self.algorithm = algorithm

Found indentation with tabs instead of spaces

		self.extension = extension

Found indentation with tabs instead of spaces

		self.buffer_size = buffer_size

Found indentation with tabs instead of spaces

	def hashsum(self, file_name: str) -> str:

Found indentation with tabs instead of spaces

Missing function or method docstring

		alg = self.algorithm()

Found indentation with tabs instead of spaces

		with open(file_name, 'rb') as f:

Found indentation with tabs instead of spaces

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			for chunk in iter(lambda: f.read(self.buffer_size), b''):

Found indentation with tabs instead of spaces

				alg.update(chunk)

Found indentation with tabs instead of spaces

		return alg.hexdigest()

Found indentation with tabs instead of spaces

	def add_hash(self, file_name: str) -> None:

Found indentation with tabs instead of spaces

Missing function or method docstring

		with open(file_name + self.extension, 'w', encoding="utf8") as f:

Found indentation with tabs instead of spaces

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			s = self.hashsum(file_name)

Found indentation with tabs instead of spaces

Variable name "s" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			f.write(s)

Found indentation with tabs instead of spaces

	def check_hash(self, file_name: str) -> bool:

Found indentation with tabs instead of spaces

Missing function or method docstring

		if not os.path.isfile(file_name + self.extension): return False 

Trailing whitespace

Found indentation with tabs instead of spaces

More than one statement on a single line

		with open(file_name + self.extension, 'r', encoding="utf8") as f:

Found indentation with tabs instead of spaces

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			hash_str = f.read().split()[0] # check only the first thing on the line before any spaces

Found indentation with tabs instead of spaces

			return hash_str == self.hashsum(file_name)

Found indentation with tabs instead of spaces

	def check_and_open(self, file_name: str, *args):

Found indentation with tabs instead of spaces

Missing function or method docstring

		return self._o(file_name, opener=lambda f: codecs.open(f, encoding='utf-8'), *args)

Found indentation with tabs instead of spaces

	def check_and_open_gzip(self, file_name: str, *args):

Found indentation with tabs instead of spaces

Missing function or method docstring

		return self._o(file_name, opener=gzip.open, *args)

Found indentation with tabs instead of spaces

	def _o(self, file_name: str, opener, *args):

Found indentation with tabs instead of spaces

		if not os.path.isfile(file_name + self.extension):

Found indentation with tabs instead of spaces

			raise FileDoesNotExistError("Hash for file {} does not exist".format(file_name))

Found indentation with tabs instead of spaces

		with open(file_name + self.extension, 'r', encoding="utf8") as f:

Found indentation with tabs instead of spaces

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			if f.read() != self.hashsum(file_name):

Found indentation with tabs instead of spaces

				raise HashValidationError("Hash for file {} does not match".format(file_name))

Found indentation with tabs instead of spaces

		return opener(file_name, *args)

Found indentation with tabs instead of spaces

def mkdatetime(s: str) -> datetime:

Argument name "s" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Missing function or method docstring

	return datetime.strptime(s.replace(' ', 'T'), "%Y-%m-%dT%H:%M:%S")

Found indentation with tabs instead of spaces

The Module datetime does not seem to have a member named strptime.

def now() -> datetime:

Missing function or method docstring

	return datetime.datetime.now()

Found indentation with tabs instead of spaces

def today() -> datetime:

Missing function or method docstring

	return datetime.datetime.today()

Found indentation with tabs instead of spaces

def mkdate(s: str) -> datetime:

Argument name "s" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Missing function or method docstring

	return datetime.strptime(s, "%Y-%m-%d")

Found indentation with tabs instead of spaces

The Module datetime does not seem to have a member named strptime.

def this_year(s: str) -> datetime:

Argument name "s" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Missing function or method docstring

	return datetime.strptime(s, "%Y")

Found indentation with tabs instead of spaces

The Module datetime does not seem to have a member named strptime.

def year_range(year: int) -> Tuple[datetime.datetime, datetime.datetime]:

Missing function or method docstring

	return (

Found indentation with tabs instead of spaces

		datetime(year, 1, 1, 0, 0, 0, 0),

Wrong hanging indentation (remove 4 spaces).

datetime does not seem to be callable.

		datetime(year, 12, 31, 23, 59, 59, 999)

Wrong hanging indentation (remove 4 spaces).

datetime does not seem to be callable.

	)

@shift_infix
def approxeq(a, b):

Argument name "a" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Argument name "b" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

	"""This takes 1e-09 * max(abs(a), abs(b)), which may not be appropriate."""

Found indentation with tabs instead of spaces

	"""Example: 5 <<approxeq>> 5.000000000000001"""

Found indentation with tabs instead of spaces

This string statement has no effect and could be removed.

	return abs(a - b) < 1e-09 * max(abs(a), abs(b))

Found indentation with tabs instead of spaces

class TomlData:
	"""A better TOML data structure than a plain dict.

Found indentation with tabs instead of spaces

	Usage examples:
		data = TomlData({'x': {'y': {'z': 155}}})
		print(data['x.y.z'])   # prints 155
		data.sub('x.y')        # returns a new TomlData for {'z': 155}
		data.nested_keys()     # returns all keys and sub-keys
	"""
	def __init__(self, top_level_item: Dict[str, object]):

Found indentation with tabs instead of spaces

		assert top_level_item is not None

Found indentation with tabs instead of spaces

		self.top = top_level_item

Found indentation with tabs instead of spaces

	def __str__(self) -> str:

Found indentation with tabs instead of spaces

		return repr(self)

Found indentation with tabs instead of spaces

	def __repr__(self) -> str:

Found indentation with tabs instead of spaces

		return "TomlData({})".format(str(self.top))

Found indentation with tabs instead of spaces

	def __getitem__(self, key: str) -> Dict[str, object]:

Found indentation with tabs instead of spaces

		return self.sub(key).top

Found indentation with tabs instead of spaces

		def __contains__(self, key: str) -> bool:

Found indentation with tabs instead of spaces

This code does not seem to be reachable.

The variable __contains__ seems to be unused.

			try:

Found indentation with tabs instead of spaces

					self.sub(key)

Found indentation with tabs instead of spaces

					return True

Found indentation with tabs instead of spaces

			except AttributeError: return False

Found indentation with tabs instead of spaces

More than one statement on a single line

	def get_str(self, key: str) -> str:

Found indentation with tabs instead of spaces

Missing function or method docstring

		return str(self.__as(key, str))

Found indentation with tabs instead of spaces

	def get_int(self, key: str) -> int:

Found indentation with tabs instead of spaces

Missing function or method docstring

		# noinspection PyTypeChecker
		return int(self.__as(key, int))

Found indentation with tabs instead of spaces

	def get_bool(self, key: str) -> int:

Found indentation with tabs instead of spaces

Missing function or method docstring

		# noinspection PyTypeChecker
		return bool(self.__as(key, bool))

Found indentation with tabs instead of spaces

	def get_str_list(self, key: str) -> List[str]:

Found indentation with tabs instead of spaces

Missing function or method docstring

		return self.__as_list(key, str)

Found indentation with tabs instead of spaces

	def get_int_list(self, key: str) -> List[int]:

Found indentation with tabs instead of spaces

Missing function or method docstring

		return self.__as_list(key, int)

Found indentation with tabs instead of spaces

	def get_float_list(self, key: str) -> List[int]:

Found indentation with tabs instead of spaces

Missing function or method docstring

		return self.__as_list(key, int)

Found indentation with tabs instead of spaces

	def get_bool_list(self, key: str) -> List[int]:

Found indentation with tabs instead of spaces

Missing function or method docstring

		return self.__as_list(key, bool)

Found indentation with tabs instead of spaces

	def get_float(self, key: str) -> int:

Found indentation with tabs instead of spaces

Missing function or method docstring

		# noinspection PyTypeChecker
		return int(self.__as(key, float))

Found indentation with tabs instead of spaces

	def __as_list(self, key: str, clazz):

Found indentation with tabs instead of spaces

		def to(v):

Found indentation with tabs instead of spaces

Function name "to" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Argument name "v" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			if not isinstance(v, clazz):

Found indentation with tabs instead of spaces

				raise TypeError("{}={} is a {}, not {}".format(key, v, type(v), clazz))

Found indentation with tabs instead of spaces

			return [to(v) for v in self[key]]

Found indentation with tabs instead of spaces

	def __as(self, key: str, clazz):

Found indentation with tabs instead of spaces

		v = self[key]

Found indentation with tabs instead of spaces

Variable name "v" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

		if isinstance(v, clazz):

Found indentation with tabs instead of spaces

Unnecessary "else" after "return"

			return v

Found indentation with tabs instead of spaces

		else:

Found indentation with tabs instead of spaces

			raise TypeError("{}={} is a {}, not {}".format(key, v, type(v), clazz))

Found indentation with tabs instead of spaces

	def sub(self, key: str):

Found indentation with tabs instead of spaces

		"""Returns a new TomlData with its top set to items[1][2]..."""

Found indentation with tabs instead of spaces

		items = key.split('.')

Found indentation with tabs instead of spaces

		item = self.top

Found indentation with tabs instead of spaces

		for i, s in enumerate(items):

Found indentation with tabs instead of spaces

Variable name "s" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			if s not in item: raise MissingConfigEntry(

The variable MissingConfigEntry does not seem to be defined.

Found indentation with tabs instead of spaces

More than one statement on a single line

Undefined variable 'MissingConfigEntry'

				"{} is not in the TOML; failed at {}"

Wrong hanging indentation before block.

				.format(key, '.'.join(items[:i+1]))

Wrong hanging indentation before block.

			)
			item = item[s]

Found indentation with tabs instead of spaces

		return TomlData(item)

Found indentation with tabs instead of spaces

	def items(self) -> ItemsView[str, object]:

Found indentation with tabs instead of spaces

Missing function or method docstring

		return self.top.items()

Found indentation with tabs instead of spaces

	def keys(self) -> KeysView[str]:

Found indentation with tabs instead of spaces

Missing function or method docstring

		return self.top.keys()

Found indentation with tabs instead of spaces

	def values(self) -> ValuesView[object]:

Found indentation with tabs instead of spaces

Missing function or method docstring

		return self.top.values()

Found indentation with tabs instead of spaces

	def nested_keys(self, separator='.') -> Iterator[str]:

Found indentation with tabs instead of spaces

Missing function or method docstring

		for lst in self.nested_key_lists(self.top):

Found indentation with tabs instead of spaces

			yield separator.join(lst)

Found indentation with tabs instead of spaces

	def nested_key_lists(self, dictionary: Dict[str, object], prefix=None) -> Iterator[List[str]]:

Found indentation with tabs instead of spaces

Missing function or method docstring

		prefix = prefix[:] if prefix else []

Found indentation with tabs instead of spaces

		if isinstance(dictionary, dict):

Found indentation with tabs instead of spaces

			for key, value in dictionary.items():

Found indentation with tabs instead of spaces

				if isinstance(value, dict):

Found indentation with tabs instead of spaces

					for result in self.nested_key_lists(value, [key] + prefix): yield result

Found indentation with tabs instead of spaces

More than one statement on a single line

				else: yield prefix + [key]

Found indentation with tabs instead of spaces

		else: yield dictionary

Found indentation with tabs instead of spaces

def git_commit_hash(git_repo_dir: str='.') -> str:

Exactly one space required around keyword argument assignment

	"""Gets the hex of the most recent Git commit hash in git_repo_dir."""

Found indentation with tabs instead of spaces

	p = Popen(['git', 'rev-parse', 'HEAD'], stdout=PIPE, cwd=git_repo_dir)

Found indentation with tabs instead of spaces

Variable name "p" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

	(out, err) = p.communicate()

Found indentation with tabs instead of spaces

The variable err seems to be unused.

	exit_code = p.wait()

Found indentation with tabs instead of spaces

	if exit_code != 0: raise ValueError("Got nonzero exit code {} from git rev-parse".format(exit_code))

This line is too long as per the coding-style (101/100).

Found indentation with tabs instead of spaces

More than one statement on a single line

	return out.decode('utf-8').rstrip()

Found indentation with tabs instead of spaces

@deprecated(reason="Use klgists.common.flexible_logger instead.")
def init_logger(

Too many arguments (6/5)

	log_path: Optional[str]=None,

Wrong hanging indentation before block.

Exactly one space required around keyword argument assignment

	format_str: str='%(asctime)s %(levelname)-8s: %(message)s',

Wrong hanging indentation before block.

Exactly one space required around keyword argument assignment

	to_std: bool=True,

Wrong hanging indentation before block.

Exactly one space required around keyword argument assignment

	child_logger_name: Optional[str]=None,

Wrong hanging indentation before block.

Exactly one space required around keyword argument assignment

	std_level = logging.INFO,

Wrong hanging indentation before block.

No space allowed around keyword argument assignment

	file_level = logging.DEBUG

Wrong hanging indentation before block.

No space allowed around keyword argument assignment

):
	"""Initializes a logger that can write to a log file and/or stdout."""

Found indentation with tabs instead of spaces

	if log_path is not None and not os.path.exists(os.path.dirname(log_path)):

Found indentation with tabs instead of spaces

		os.mkdir(os.path.dirname(log_path))

Found indentation with tabs instead of spaces

	if child_logger_name is None:

Found indentation with tabs instead of spaces

		logger = logging.getLogger()

Found indentation with tabs instead of spaces

logger is re-defining a name which is already available in the outer-scope (previously defined on line 297).

	else:

Found indentation with tabs instead of spaces

		logger = logging.getLogger(child_logger_name)

Found indentation with tabs instead of spaces

	logger.setLevel(logging.NOTSET)

Found indentation with tabs instead of spaces

	formatter = logging.Formatter(format_str)

Found indentation with tabs instead of spaces

	if log_path is not None:

Found indentation with tabs instead of spaces

		handler = logging.FileHandler(log_path, encoding='utf-8')

Found indentation with tabs instead of spaces

		handler.setLevel(file_level)

Found indentation with tabs instead of spaces

		handler.setFormatter(formatter)

Found indentation with tabs instead of spaces

		logger.addHandler(handler)

Found indentation with tabs instead of spaces

	if to_std:

Found indentation with tabs instead of spaces

		handler = logging.StreamHandler()

Found indentation with tabs instead of spaces

		handler.setLevel(std_level)

Found indentation with tabs instead of spaces

		handler.setFormatter(formatter)

Found indentation with tabs instead of spaces

		logger.addHandler(handler)

Found indentation with tabs instead of spaces

import datetime

The import datetime was already done on line 12. You should be able to
remove this line.

Import "import datetime" should be placed at the top of the module

standard import "import datetime" should be placed before "from pocketutils.core.exceptions import PathIsNotADirError, MissingResourceError"

Imports from package datetime are not grouped

def format_time(time: datetime) -> str:
	"""Standard timestamp format. Ex: 2016-05-02_22_35_56."""

Found indentation with tabs instead of spaces

	return time.strftime("%Y-%m-%d_%H-%M-%S")

Found indentation with tabs instead of spaces

def timestamp() -> str:
	"""Standard timestamp of time now. Ex: 2016-05-02_22_35_56."""

Found indentation with tabs instead of spaces

	return format_time(datetime.datetime.now())

Found indentation with tabs instead of spaces

def timestamp_path(path: str) -> str:
	"""Standard way to label a file path with a timestamp."""

Found indentation with tabs instead of spaces

	return "{}-{}".format(path, timestamp())

Found indentation with tabs instead of spaces

def nice_time(n_ms: int) -> str:

Missing function or method docstring

	length = datetime.datetime(1, 1, 1) + datetime.timedelta(milliseconds=n_ms)

Found indentation with tabs instead of spaces

	if n_ms < 1000 * 60 * 60 * 24:

Found indentation with tabs instead of spaces

Unnecessary "else" after "return"

		return "{}h, {}m, {}s".format(length.hour, length.minute, length.second)

Found indentation with tabs instead of spaces

	else:

Found indentation with tabs instead of spaces

		return "{}d, {}h, {}m, {}s".format(length.day, length.hour, length.minute, length.second)

Found indentation with tabs instead of spaces

def parse_local_iso_datetime(z: str) -> datetime:

Argument name "z" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Missing function or method docstring

	return datetime.datetime.strptime(z, '%Y-%m-%dT%H:%M:%S.%f')

Found indentation with tabs instead of spaces

logger = logging.getLogger(__name__)

class PipeType(Enum):

Missing class docstring

	STDOUT = 1

Found indentation with tabs instead of spaces

	STDERR = 2

Found indentation with tabs instead of spaces

def _disp(out, ell, name):
	out = out.strip()

Found indentation with tabs instead of spaces

	if '\n' in out:

Found indentation with tabs instead of spaces

		ell(name + ":\n<<=====\n" + out + '\n=====>>')

Found indentation with tabs instead of spaces

	elif len(out) > 0:

Found indentation with tabs instead of spaces

		ell(name + ": <<===== " + out + " =====>>")

Found indentation with tabs instead of spaces

	else:

Found indentation with tabs instead of spaces

		ell(name + ": <no output>")

Found indentation with tabs instead of spaces

Trailing whitespace

def _log(out, err, ell):
	_disp(out, ell, "stdout")

Found indentation with tabs instead of spaces

	_disp(err, ell, "stderr")

Found indentation with tabs instead of spaces

Trailing whitespace

def smart_log_callback(source, line, prefix: str = '') -> None:

Missing function or method docstring

The argument source seems to be unused.

	line = line.decode('utf-8')

Found indentation with tabs instead of spaces

	if line.startswith('FATAL:'):

This code seems to be duplicated in your project.

Found indentation with tabs instead of spaces

		logger.fatal(prefix + line)

Found indentation with tabs instead of spaces

	elif line.startswith('ERROR:'):

Found indentation with tabs instead of spaces

		logger.error(prefix + line)

Found indentation with tabs instead of spaces

	elif line.startswith('WARNING:'):

Found indentation with tabs instead of spaces

		logger.warning(prefix + line)

Found indentation with tabs instead of spaces

	elif line.startswith('INFO:'):

Found indentation with tabs instead of spaces

		logger.info(prefix + line)

Found indentation with tabs instead of spaces

	elif line.startswith('DEBUG:'):

Found indentation with tabs instead of spaces

		logger.debug(prefix + line)

Found indentation with tabs instead of spaces

	else:

Found indentation with tabs instead of spaces

		logger.debug(prefix + line)

Found indentation with tabs instead of spaces

def _reader(pipe_type, pipe, queue):
	try:

Found indentation with tabs instead of spaces

		with pipe:

Found indentation with tabs instead of spaces

			for line in iter(pipe.readline, b''):

Found indentation with tabs instead of spaces

				queue.put((pipe_type, line))

Found indentation with tabs instead of spaces

	finally:

Found indentation with tabs instead of spaces

		queue.put(None)

Found indentation with tabs instead of spaces

Trailing whitespace

def stream_cmd_call(cmd: List[str], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell_cmd: str=None, cwd: Optional[str] = None, timeout_secs: Optional[float] = None, log_callback: Callable[[PipeType, bytes], None] = None, bufsize: Optional[int] = None) -> None:

This line is too long as per the coding-style (265/100).

Exactly one space required around keyword argument assignment

Too many arguments (8/5)

The argument stdout seems to be unused.

The argument stderr seems to be unused.

	"""Calls an external command, waits, and throws a ResourceError for nonzero exit codes.

Found indentation with tabs instead of spaces

	Returns (stdout, stderr).
	The user can optionally provide a shell to run the command with, e.g. "powershell.exe" 

Trailing whitespace

	"""
	if log_callback is None:

Found indentation with tabs instead of spaces

		log_callback = smart_log_callback

Found indentation with tabs instead of spaces

	cmd = [str(p) for p in cmd]

Found indentation with tabs instead of spaces

	if shell_cmd:

Found indentation with tabs instead of spaces

		cmd = [shell_cmd] + cmd

Found indentation with tabs instead of spaces

	logger.debug("Streaming '{}'".format(' '.join(cmd)))

Found indentation with tabs instead of spaces

Use lazy % formatting in logging functions

Trailing whitespace

	p = subprocess.Popen(cmd, stdout=PIPE, stderr=PIPE, cwd=cwd, bufsize=bufsize)

Found indentation with tabs instead of spaces

Variable name "p" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

	try:

Found indentation with tabs instead of spaces

		q = Queue()

Found indentation with tabs instead of spaces

Variable name "q" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

		Thread(target=_reader, args=[PipeType.STDOUT, p.stdout, q]).start()

Found indentation with tabs instead of spaces

		Thread(target=_reader, args=[PipeType.STDERR, p.stderr, q]).start()

Found indentation with tabs instead of spaces

		for _ in range(2):

Found indentation with tabs instead of spaces

			for source, line in iter(q.get, None):

Found indentation with tabs instead of spaces

				log_callback(source, line)

Found indentation with tabs instead of spaces

		exit_code = p.wait(timeout=timeout_secs)

Found indentation with tabs instead of spaces

	finally:

Found indentation with tabs instead of spaces

		p.kill()

Found indentation with tabs instead of spaces

	if exit_code != 0:

Found indentation with tabs instead of spaces

		raise ResourceError("Got nonzero exit code {} from '{}'".format(exit_code, ' '.join(cmd)), cmd, exit_code, '<<unknown>>', '<<unknown>>')

This line is too long as per the coding-style (138/100).

Found indentation with tabs instead of spaces

Trailing whitespace

def wrap_cmd_call(cmd: List[str], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell_cmd: str=None, cwd: Optional[str] = None, timeout_secs: Optional[float] = None) -> (str, str):

This line is too long as per the coding-style (182/100).

Exactly one space required around keyword argument assignment

Too many arguments (6/5)

	"""Calls an external command, waits, and throws a ResourceError for nonzero exit codes.

Found indentation with tabs instead of spaces

	Returns (stdout, stderr).
	The user can optionally provide a shell to run the command with, e.g. "powershell.exe" 

Trailing whitespace

	"""
	cmd = [str(p) for p in cmd]

Found indentation with tabs instead of spaces

	if shell_cmd:

Found indentation with tabs instead of spaces

		cmd = [shell_cmd] + cmd

Found indentation with tabs instead of spaces

	logger.debug("Calling '{}'".format(' '.join(cmd)))

Found indentation with tabs instead of spaces

Use lazy % formatting in logging functions

	p = subprocess.Popen(cmd, stdout=stdout, stderr=stderr, cwd=cwd)

Found indentation with tabs instead of spaces

Variable name "p" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

	out, err, exit_code = None, None, None

Found indentation with tabs instead of spaces

	try:

Found indentation with tabs instead of spaces

		(out, err) = p.communicate(timeout=timeout_secs)

Found indentation with tabs instead of spaces

		out = out.decode('utf-8')

Found indentation with tabs instead of spaces

		err = err.decode('utf-8')

Found indentation with tabs instead of spaces

		exit_code = p.wait(timeout=timeout_secs)

Found indentation with tabs instead of spaces

	except Exception as e:

Found indentation with tabs instead of spaces

Variable name "e" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

		_log(out, err, logger.warning)

Found indentation with tabs instead of spaces

		raise e

Found indentation with tabs instead of spaces

	finally:

Found indentation with tabs instead of spaces

		p.kill()

Found indentation with tabs instead of spaces

	if exit_code != 0:

Found indentation with tabs instead of spaces

		_log(out, err, logger.warning)

Found indentation with tabs instead of spaces

		raise ResourceError("Got nonzero exit code {} from '{}'".format(exit_code, ' '.join(cmd)), cmd, exit_code, out, err)

This line is too long as per the coding-style (118/100).

Found indentation with tabs instead of spaces

	_log(out, err, logger.debug)

Found indentation with tabs instead of spaces

	return out, err

Found indentation with tabs instead of spaces

def look(obj: object, attrs: str) -> any:

Missing function or method docstring

	if not isinstance(attrs, str) and isinstance(attrs, Iterable): attrs = '.'.join(attrs)

Found indentation with tabs instead of spaces

Second argument of isinstance is not a type

More than one statement on a single line

	try:

Found indentation with tabs instead of spaces

		return operator.attrgetter(attrs)(obj)

Found indentation with tabs instead of spaces

	except AttributeError: return None

Found indentation with tabs instead of spaces

More than one statement on a single line

def flatmap(func, *iterable):

Missing function or method docstring

	return chain.from_iterable(map(func, *iterable))

Found indentation with tabs instead of spaces

def flatten(*iterable):

Missing function or method docstring

	return list(chain.from_iterable(iterable))

Found indentation with tabs instead of spaces

class DevNull:

Missing class docstring

	def write(self, msg): pass

Found indentation with tabs instead of spaces

Missing function or method docstring

More than one statement on a single line

pjoin = os.path.join
pexists = os.path.exists
pdir = os.path.isdir
pfile = os.path.isfile
pis_dir = os.path.isdir
fsize = os.path.getsize
def pardir(path: str, depth: int=1):

Exactly one space required around keyword argument assignment

Missing function or method docstring

	for _ in range(-1, depth):

Found indentation with tabs instead of spaces

		path = os.path.dirname(path)

Found indentation with tabs instead of spaces

	return path

Found indentation with tabs instead of spaces

def grandpardir(path: str):

Missing function or method docstring

	return pardir(path, 2)

Found indentation with tabs instead of spaces

T = TypeVar('T')

Class name "T" doesn't conform to PascalCase naming style ('[^\\W\\da-z][^\\W_]+$' pattern)

def try_index_of(element: List[T], list_element: T) -> Optional[T]:

Missing function or method docstring

	try:

Found indentation with tabs instead of spaces

		index_element = list_element.index(element)

Found indentation with tabs instead of spaces

		return index_element

Found indentation with tabs instead of spaces

	except ValueError:

Found indentation with tabs instead of spaces

		return None

Found indentation with tabs instead of spaces

def decorator(cls):

Missing function or method docstring

	return cls

Found indentation with tabs instead of spaces

def exists(keep_predicate: Callable[[T], bool], seq: Iterable[T]) -> bool:
	"""Efficient existential quantifier for a filter() predicate.

Found indentation with tabs instead of spaces

	Returns true iff keep_predicate is true for one or more elements."""
	for e in seq:

Found indentation with tabs instead of spaces

Variable name "e" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

		if keep_predicate(e): return True  # short-circuit

Found indentation with tabs instead of spaces

More than one statement on a single line

	return False

Found indentation with tabs instead of spaces

def zip_strict(*args):
	"""Same as zip(), but raises an IndexError if the lengths don't match."""

Found indentation with tabs instead of spaces

	iters = [iter(axis) for axis in args]

Found indentation with tabs instead of spaces

	n_elements = 0

Found indentation with tabs instead of spaces

	failures = []

Found indentation with tabs instead of spaces

	while len(failures) == 0:

Found indentation with tabs instead of spaces

		n_elements += 1

Found indentation with tabs instead of spaces

		values = []

Found indentation with tabs instead of spaces

		failures = []

Found indentation with tabs instead of spaces

		for axis, iterator in enumerate(iters):

Found indentation with tabs instead of spaces

			try:

Found indentation with tabs instead of spaces

				values.append(next(iterator))

Found indentation with tabs instead of spaces

			except StopIteration:

Found indentation with tabs instead of spaces

				failures.append(axis)

Found indentation with tabs instead of spaces

		if len(failures) == 0:

Found indentation with tabs instead of spaces

			yield tuple(values)

Found indentation with tabs instead of spaces

	if len(failures) == 1:

Found indentation with tabs instead of spaces

Unnecessary "elif" after "raise"

		raise IndexError("Too few elements ({}) along axis {}".format(n_elements, failures[0]))

Found indentation with tabs instead of spaces

	elif len(failures) < len(iters):

Found indentation with tabs instead of spaces

		raise IndexError("Too few elements ({}) along axes {}".format(n_elements, failures))

Found indentation with tabs instead of spaces

def only(sequence: Iterable[Any]) -> Any:
	"""

Found indentation with tabs instead of spaces

	Returns either the SINGLE (ONLY) UNIQUE ITEM in the sequence or raises an exception.
	Each item must have __hash__ defined on it.
	:param sequence: A list of any items (untyped)
	:return: The first item the sequence.
	:raises: ValarLookupError If the sequence is empty
	:raises: MultipleMatchesError If there is more than one unique item.
	"""
	st = set(sequence)

Found indentation with tabs instead of spaces

Variable name "st" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

	if len(st) > 1:

Found indentation with tabs instead of spaces

		raise MultipleMatchesError("More then 1 item in {}".format(sequence))

Found indentation with tabs instead of spaces

	if len(st) == 0:

Found indentation with tabs instead of spaces

		raise LookupFailedError("Empty sequence")

Found indentation with tabs instead of spaces

	return next(iter(st))

Found indentation with tabs instead of spaces

def read_lines_file(path: str, ignore_comments: bool = False) -> Sequence[str]:
	"""

Found indentation with tabs instead of spaces

	Returns a list of lines in a file, potentially ignoring comments.
	:param path: Read the file at this local path
	:param ignore_comments: Ignore lines beginning with #, excluding whitespace
	:return: The lines, with surrounding whitespace stripped
	"""
	lines = []

Found indentation with tabs instead of spaces

lines is re-defining a name which is already available in the outer-scope (previously defined on line 657).

	with open(path) as f:

Found indentation with tabs instead of spaces

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

		line = f.readline().strip()

Found indentation with tabs instead of spaces

		if not ignore_comments or not line.startswith('#'):

Found indentation with tabs instead of spaces

			lines.append(line)

Found indentation with tabs instead of spaces

	return lines

Found indentation with tabs instead of spaces

def read_properties_file(path: str) -> Mapping[str, str]:
	"""

Found indentation with tabs instead of spaces

	Reads a .properties file, which is a list of lines with key=value pairs (with an equals sign).
	Lines beginning with # are ignored.
	Each line must contain exactly 1 equals sign.
	:param path: Read the file at this local path
	:return: A dict mapping keys to values, both with surrounding whitespace stripped
	"""
	lines = read_lines_file(path, ignore_comments=False)

Found indentation with tabs instead of spaces

lines is re-defining a name which is already available in the outer-scope (previously defined on line 657).

	dct = {}

Found indentation with tabs instead of spaces

	for i, line in enumerate(lines):

Found indentation with tabs instead of spaces

		if line.startswith('#'): continue

Found indentation with tabs instead of spaces

More than one statement on a single line

		if line.count('=') != 1:

Found indentation with tabs instead of spaces

			raise ParsingError("Bad line {} in {}".format(i+1, path))

Found indentation with tabs instead of spaces

		parts = line.split('=')

Found indentation with tabs instead of spaces

		dct[parts[0].strip()] = parts[1].strip()

Found indentation with tabs instead of spaces

	return dct

Found indentation with tabs instead of spaces

class Comparable:
	"""A class that's comparable. Just implement __lt__. Credit ot Alex Martelli on https://stackoverflow.com/questions/1061283/lt-instead-of-cmp"""

This line is too long as per the coding-style (145/100).

Found indentation with tabs instead of spaces

	def __eq__(self, other):

Found indentation with tabs instead of spaces

		return not self < other and not other < self

Found indentation with tabs instead of spaces

	def __ne__(self, other):

Found indentation with tabs instead of spaces

		return self < other or other < self

Found indentation with tabs instead of spaces

	def __gt__(self, other):

Found indentation with tabs instead of spaces

		return other < self

Found indentation with tabs instead of spaces

	def __ge__(self, other):

Found indentation with tabs instead of spaces

		return not self < other

Found indentation with tabs instead of spaces

	def __le__(self, other):

Found indentation with tabs instead of spaces

		return not other < self

Found indentation with tabs instead of spaces

def json_serial(obj):
	"""JSON serializer for objects not serializable by default json code.

Found indentation with tabs instead of spaces

	From jgbarah at https://stackoverflow.com/questions/11875770/how-to-overcome-datetime-datetime-not-json-serializable

This line is too long as per the coding-style (117/100).

	"""
	if isinstance(obj, (datetime, date)):

Found indentation with tabs instead of spaces

Second argument of isinstance is not a type

		return obj.isoformat()

Found indentation with tabs instead of spaces

	try:

Found indentation with tabs instead of spaces

		import peewee

Found indentation with tabs instead of spaces

Import outside toplevel (peewee)

		if isinstance(obj, peewee.Field):

Found indentation with tabs instead of spaces

			return type(obj).__name__

Found indentation with tabs instead of spaces

	except ImportError: pass

Found indentation with tabs instead of spaces

More than one statement on a single line

	raise TypeError("Type %s not serializable" % type(obj))

Found indentation with tabs instead of spaces

def pretty_dict(dct: dict) -> str:
	"""Returns a pretty-printed dict, complete with indentation. Will fail on non-JSON-serializable datatypes."""

This line is too long as per the coding-style (110/100).

Found indentation with tabs instead of spaces

	return json.dumps(dct, default=json_serial, sort_keys=True, indent=4)

Found indentation with tabs instead of spaces

def pp_dict(dct: dict) -> None:
	"""Pretty-prints a dict to stdout."""

Found indentation with tabs instead of spaces

	print(pretty_dict(dct))

Found indentation with tabs instead of spaces

def pp_size(obj: object) -> None:
	"""Prints to stdout a human-readable string of the memory usage of arbitrary Python objects. Ex: 8M for 8 megabytes."""

This line is too long as per the coding-style (120/100).

Found indentation with tabs instead of spaces

	print(hsize(sys.getsizeof(obj)))

Found indentation with tabs instead of spaces

def sanitize_str(value: str) -> str:
	"""Removes Unicode control (Cc) characters EXCEPT for tabs (\t), newlines (\n only), line separators (U+2028) and paragraph separators (U+2029)."""

This line is too long as per the coding-style (148/100).

Found indentation with tabs instead of spaces

	return "".join(ch for ch in value if unicodedata.category(ch) != 'Cc' and ch not in {'\t', '\n', '\u2028', '\u2029'})

This line is too long as per the coding-style (118/100).

Found indentation with tabs instead of spaces

def escape_for_properties(value: Any) -> str:

Missing function or method docstring

	return sanitize_str(str(value).replace('\n', '\u2028'))

Found indentation with tabs instead of spaces

def escape_for_tsv(value: Any) -> str:

Missing function or method docstring

	return sanitize_str(str(value).replace('\n', '\u2028').replace('\t', ' '))

Found indentation with tabs instead of spaces

Trailing whitespace

class Timeout:

Missing class docstring

	def __init__(self, seconds: int = 10, error_message='Timeout'):

Found indentation with tabs instead of spaces

		self.seconds = seconds

Found indentation with tabs instead of spaces

		self.error_message = error_message

Found indentation with tabs instead of spaces

	def handle_timeout(self, signum, frame):

Found indentation with tabs instead of spaces

Missing function or method docstring

		raise TimeoutError(self.error_message)

Found indentation with tabs instead of spaces

	def __enter__(self):

Found indentation with tabs instead of spaces

		signal.signal(signal.SIGALRM, self.handle_timeout)

Found indentation with tabs instead of spaces

		signal.alarm(self.seconds)

Found indentation with tabs instead of spaces

	def __exit__(self, type, value, traceback):

Found indentation with tabs instead of spaces

This seems to re-define the built-in type.

		signal.alarm(0)

Found indentation with tabs instead of spaces

class OverwriteChoice(Enum):

Missing class docstring

	FAIL = 1

Found indentation with tabs instead of spaces

	WARN = 2

Found indentation with tabs instead of spaces

	IGNORE = 3

Found indentation with tabs instead of spaces

	OVERWRITE = 4

Found indentation with tabs instead of spaces

def fix_path(path: str) -> str:

Missing function or method docstring

	# ffmpeg won't recognize './' and will simply not write images!
	# and Python doesn't recognize ~
	if '%' in path: raise ValueError(

Found indentation with tabs instead of spaces

More than one statement on a single line

		'For technical limitations (regarding ffmpeg), local paths cannot contain a percent sign (%), but "{}" does'.format(path)

Wrong hanging indentation before block.

This line is too long as per the coding-style (123/100).

	)
	if path == '~': return os.environ['HOME']  # prevent out of bounds

Found indentation with tabs instead of spaces

More than one statement on a single line

	if path.startswith('~'):

Found indentation with tabs instead of spaces

		path = pjoin(os.environ['HOME'], path[2:])

Found indentation with tabs instead of spaces

	return path.replace('./', '')

Found indentation with tabs instead of spaces

def fix_path_platform_dependent(path: str) -> str:
	"""Modifies path strings to work with Python and external tools.

A suspicious escape sequence \ was found. Did you maybe forget to add an r prefix?

Found indentation with tabs instead of spaces

	Replaces a beginning '~' with the HOME environment variable.
	Also accepts either / or \ (but not both) as a path separator in windows. 

Trailing whitespace

	"""
	path = fix_path(path)

Found indentation with tabs instead of spaces

	# if windows, allow either / or \, but not both
	if platform.system() == 'Windows':

Found indentation with tabs instead of spaces

Unnecessary "else" after "return"

		bits = re.split('[/\\\\]', path)

Found indentation with tabs instead of spaces

		return pjoin(*bits).replace(":", ":\\")

Found indentation with tabs instead of spaces

	else:

Found indentation with tabs instead of spaces

		return path

Found indentation with tabs instead of spaces

# NTFS doesn't allow these, so let's be safe
# Also exclude control characters
# 127 is the DEL char
_bad_chars = {'/', ':', '<', '>', '"', "'", '\\', '|', '?', '*', chr(127), *{chr(i) for i in range(0, 32)}}

This line is too long as per the coding-style (107/100).

assert ' ' not in _bad_chars
def _sanitize_bit(p: str) -> str:

Argument name "p" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

	for b in _bad_chars: p = p.replace(b, '-')

Found indentation with tabs instead of spaces

Variable name "b" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

More than one statement on a single line

	return p

Found indentation with tabs instead of spaces

def pjoin_sanitized_rel(*pieces: Iterable[any]) -> str:
	"""Builds a path from a hierarchy, sanitizing the path by replacing /, :, <, >, ", ', \, |, ?, *, <DEL>, and control characters 0–32 with a hyphen-minus (-).

A suspicious escape sequence \, was found. Did you maybe forget to add an r prefix?

This line is too long as per the coding-style (158/100).

Found indentation with tabs instead of spaces

	Each input to pjoin_sanitized must refer only to a single directory or file (cannot contain a path separator).

This line is too long as per the coding-style (111/100).

	This means that you cannot have an absolute path (it would begin with os.path (probably /); use pjoin_sanitized_abs for this.

This line is too long as per the coding-style (126/100).

	"""
	return pjoin(*[_sanitize_bit(str(bit)) for bit in pieces])

Found indentation with tabs instead of spaces

def pjoin_sanitized_abs(*pieces: Iterable[any]) -> str:
	"""Same as pjoin_sanitized_rel but starts with os.sep (the root directory)."""

Found indentation with tabs instead of spaces

	return pjoin(os.sep, pjoin_sanitized_rel(*pieces))

Found indentation with tabs instead of spaces

def make_dirs(output_dir: str):
	"""Makes a directory if it doesn't exist.

Found indentation with tabs instead of spaces

	May raise a PathIsNotADirError.
	"""
	if not os.path.exists(output_dir):

Found indentation with tabs instead of spaces

		os.makedirs(output_dir)

Found indentation with tabs instead of spaces

	elif not os.path.isdir(output_dir):

Found indentation with tabs instead of spaces

		raise PathIsNotADirError("{} already exists and is not a directory".format(output_dir))

Found indentation with tabs instead of spaces

def remake_dirs(output_dir: str):
	"""Makes a directory, remaking it if it already exists.

Found indentation with tabs instead of spaces

	May raise a PathIsNotADirError.
	"""
	if os.path.exists(output_dir) and os.path.isdir(output_dir):

Found indentation with tabs instead of spaces

		shutil.rmtree(output_dir)

Found indentation with tabs instead of spaces

	elif os.path.exists(output_dir):

Found indentation with tabs instead of spaces

		raise PathIsNotADirError("{} already exists and is not a directory".format(output_dir))

Found indentation with tabs instead of spaces

	make_dirs(output_dir)

Found indentation with tabs instead of spaces

def lines(file_name: str, known_encoding='utf-8') -> Iterator[str]:
	"""Lazily read a text file or gzipped text file, decode, and strip any newline character (\n or \r).

This line is too long as per the coding-style (101/100).

Found indentation with tabs instead of spaces

	If the file name ends with '.gz' or '.gzip', assumes the file is Gzipped.
	Arguments:
		known_encoding: Applied only when decoding gzip
	"""
	if file_name.endswith('.gz') or file_name.endswith('.gzip'):

Found indentation with tabs instead of spaces

		with io.TextIOWrapper(gzip.open(file_name, 'r'), encoding=known_encoding) as f:

Found indentation with tabs instead of spaces

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			for line in f: yield line.rstrip('\n\r')

Found indentation with tabs instead of spaces

More than one statement on a single line

	else:

Found indentation with tabs instead of spaces

		with open(file_name, 'r') as f:

Found indentation with tabs instead of spaces

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			for line in f: yield line.rstrip('\n\r')

Found indentation with tabs instead of spaces

More than one statement on a single line

import dill

Unable to import 'dill'

Import "import dill" should be placed at the top of the module

def pkl(data, path: str):

Missing function or method docstring

	with open(path, 'wb') as f:

Found indentation with tabs instead of spaces

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

		dill.dump(data, f)

Found indentation with tabs instead of spaces

def unpkl(path: str):

Missing function or method docstring

	with open(path, 'rb') as f:

Found indentation with tabs instead of spaces

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

		return dill.load(f)

Found indentation with tabs instead of spaces

def file_from_env_var(var: str) -> str:
	"""

Found indentation with tabs instead of spaces

	Just returns the path of a file specified in an environment variable, checking that it's a file.
	Will raise a MissingResourceError error if not set or not a file.
	:param var: The environment variable name, not including the $
	"""
	if var not in os.environ:

Found indentation with tabs instead of spaces

		raise MissingResourceError('Environment variable ${} is not set'.format(var))

Found indentation with tabs instead of spaces

	config_file_path = fix_path(os.environ[var])

Found indentation with tabs instead of spaces

	if not pexists(config_file_path):

Found indentation with tabs instead of spaces

		raise MissingResourceError("{} file {} does not exist".format(var, config_file_path))

Found indentation with tabs instead of spaces

	if not pfile(config_file_path):

Found indentation with tabs instead of spaces

		raise MissingResourceError("{} file {} is not a file".format(var, config_file_path))

Found indentation with tabs instead of spaces

	return config_file_path

Found indentation with tabs instead of spaces

def is_proper_file(path: str) -> bool:

Missing function or method docstring

	name = os.path.split(path)[1]

Found indentation with tabs instead of spaces

	return len(name) > 0 and name[0] not in {'.', '~', '_'}

Found indentation with tabs instead of spaces

def scantree(path: str, follow_symlinks: bool=False) -> Iterator[str]:

Exactly one space required around keyword argument assignment

	"""List the full path of every file not beginning with '.', '~', or '_' in a directory, recursively.

This line is too long as per the coding-style (101/100).

Found indentation with tabs instead of spaces

	.. deprecated Use scan_for_proper_files, which has a better name
	"""
	for entry in os.scandir(path):

Found indentation with tabs instead of spaces

		if entry.is_dir(follow_symlinks=follow_symlinks):

Found indentation with tabs instead of spaces

			yield from scantree(entry.path)

Found indentation with tabs instead of spaces

		elif is_proper_file(entry.path):

Found indentation with tabs instead of spaces

			yield entry.path

Found indentation with tabs instead of spaces

scan_for_proper_files = scantree


def scan_for_files(path: str, follow_symlinks: bool=False) -> Iterator[str]:

Exactly one space required around keyword argument assignment

	"""

Found indentation with tabs instead of spaces

	Using a generator, list all files in a directory or one of its subdirectories.
	Useful for iterating over files in a directory recursively if there are thousands of file.
	Warning: If there are looping symlinks, follow_symlinks will return an infinite generator.
	"""
	for d in os.scandir(path):

Found indentation with tabs instead of spaces

Variable name "d" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

		if d.is_dir(follow_symlinks=follow_symlinks):

Found indentation with tabs instead of spaces

			yield from scan_for_files(d.path)

Found indentation with tabs instead of spaces

		else:

Found indentation with tabs instead of spaces

			yield d.path

Found indentation with tabs instead of spaces

def walk_until(some_dir, until: Callable[[str], bool]) -> Iterator[typing.Tuple[str, str, str]]:
	"""Walk but stop recursing after 'until' occurs.

Found indentation with tabs instead of spaces

	Returns files and directories in the same manner as os.walk
	"""
	some_dir = some_dir.rstrip(os.path.sep)

Found indentation with tabs instead of spaces

	assert os.path.isdir(some_dir)

Found indentation with tabs instead of spaces

	for root, dirs, files in os.walk(some_dir):

Found indentation with tabs instead of spaces

			yield root, dirs, files

Found indentation with tabs instead of spaces

			if until(root):

Found indentation with tabs instead of spaces

					del dirs[:]

Found indentation with tabs instead of spaces

def walk_until_level(some_dir, level: Optional[int]=None) -> Iterator[typing.Tuple[str, str, str]]:

Exactly one space required around keyword argument assignment

	"""

Found indentation with tabs instead of spaces

	Walk up to a maximum recursion depth.
	Returns files and directories in the same manner as os.walk
	Taken partly from https://stackoverflow.com/questions/7159607/list-directories-with-a-specified-depth-in-python

This line is too long as per the coding-style (112/100).

	:param some_dir:
	:param level: Maximum recursion depth, starting at 0
	"""
	some_dir = some_dir.rstrip(os.path.sep)

Found indentation with tabs instead of spaces

	assert os.path.isdir(some_dir)

Found indentation with tabs instead of spaces

	num_sep = some_dir.count(os.path.sep)

Found indentation with tabs instead of spaces

	for root, dirs, files in os.walk(some_dir):

Found indentation with tabs instead of spaces

			yield root, dirs, files

Found indentation with tabs instead of spaces

			num_sep_this = root.count(os.path.sep)

Found indentation with tabs instead of spaces

			if level is None or num_sep + level <= num_sep_this:

Found indentation with tabs instead of spaces

					del dirs[:]

Found indentation with tabs instead of spaces

class SubcommandHandler:
	"""A convenient wrapper for a program that uses command-line subcommands.

Found indentation with tabs instead of spaces

	Calls any method that belongs to the target
	:param parser: Should contain a description and help text, but should NOT contain any arguments.
	:param target: An object (or type) that contains a method for each subcommand; a dash (-) in the argument is converted to an underscore.

This line is too long as per the coding-style (137/100).

	:param temp_dir: A temporary directory
	:param error_handler: Called logging any exception except for KeyboardInterrupt or SystemExit (exceptions in here are ignored)

This line is too long as per the coding-style (127/100).

	:param cancel_handler: Called after logging a KeyboardInterrupt or SystemExit (exceptions in here are ignored)

This line is too long as per the coding-style (111/100).

	"""
	def __init__(self,

Found indentation with tabs instead of spaces

Too many arguments (6/5)

			parser: argparse.ArgumentParser, target: Any,

Wrong continued indentation (remove 3 spaces).

			temp_dir: Optional[str] = None,

Wrong continued indentation (remove 3 spaces).

			error_handler: Callable[[BaseException], None] = lambda e: None,

Wrong continued indentation (remove 3 spaces).

			cancel_handler: Callable[[Union[KeyboardInterrupt, SystemExit]], None] = lambda e: None

Wrong continued indentation (remove 3 spaces).

	) -> None:

Wrong continued indentation.

		parser.add_argument('subcommand', help='Subcommand to run')

Found indentation with tabs instead of spaces

		self.parser = parser

Found indentation with tabs instead of spaces

		self.target = target

Found indentation with tabs instead of spaces

		self.temp_dir = temp_dir

Found indentation with tabs instead of spaces

		self.error_handler = error_handler

Found indentation with tabs instead of spaces

		self.cancel_handler = cancel_handler

Found indentation with tabs instead of spaces

	def run(self, args: List[str]) -> None:

Found indentation with tabs instead of spaces

Missing function or method docstring

		full_args = self.parser.parse_args(args[1:2])

Found indentation with tabs instead of spaces

		subcommand = full_args.subcommand.replace('-', '_')

Found indentation with tabs instead of spaces

		if not hasattr(self.target, subcommand) and not subcommand.startswith('_'):

Found indentation with tabs instead of spaces

			print(Fore.RED + 'Unrecognized subcommand {}'.format(subcommand))

Found indentation with tabs instead of spaces

			self.parser.print_help()

Found indentation with tabs instead of spaces

			return

Found indentation with tabs instead of spaces

		# clever; from Chase Seibert: https://chase-seibert.github.io/blog/2014/03/21/python-multilevel-argparse.html

This line is too long as per the coding-style (111/100).

		# use dispatch pattern to invoke method with same name
		try:

Found indentation with tabs instead of spaces

			if self.temp_dir is not None:

Found indentation with tabs instead of spaces

				if pexists(self.temp_dir) and pdir(self.temp_dir): shutil.rmtree(self.temp_dir)

Found indentation with tabs instead of spaces

More than one statement on a single line

				elif pexists(self.temp_dir): raise PathIsNotADirError(self.temp_dir)

Found indentation with tabs instead of spaces

More than one statement on a single line

				remake_dirs(self.temp_dir)

Found indentation with tabs instead of spaces

				logger.debug("Created temp dir at {}".format(self.temp_dir))

Found indentation with tabs instead of spaces

Use lazy % formatting in logging functions

			getattr(self.target, subcommand)()

Found indentation with tabs instead of spaces

		except NaturalExpectedError as e:

Found indentation with tabs instead of spaces

Variable name "e" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			pass  # ignore totally

Found indentation with tabs instead of spaces

		except KeyboardInterrupt as e:

Found indentation with tabs instead of spaces

Variable name "e" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			try:

Found indentation with tabs instead of spaces

				logger.fatal("Received cancellation signal", exc_info=True)

Found indentation with tabs instead of spaces

				self.cancel_handler(e)

Found indentation with tabs instead of spaces

			except BaseException: pass

Found indentation with tabs instead of spaces

Catching very general exceptions such as BaseException is usually not recommended.

More than one statement on a single line

			raise e

Found indentation with tabs instead of spaces

		except SystemExit as e:

Found indentation with tabs instead of spaces

Variable name "e" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			try:

Found indentation with tabs instead of spaces

				logger.fatal("Received system exit signal", exc_info=True)

Found indentation with tabs instead of spaces

				self.cancel_handler(e)

Found indentation with tabs instead of spaces

			except BaseException: pass

Found indentation with tabs instead of spaces

Catching very general exceptions such as BaseException is usually not recommended.

More than one statement on a single line

			raise e

Found indentation with tabs instead of spaces

		except BaseException as e:

Found indentation with tabs instead of spaces

Variable name "e" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

			try:

Found indentation with tabs instead of spaces

				logger.fatal("{} failed!".format(self.parser.prog), exc_info=True)

Found indentation with tabs instead of spaces

Use lazy % formatting in logging functions

				self.error_handler(e)

Found indentation with tabs instead of spaces

			except BaseException: pass

Found indentation with tabs instead of spaces

Catching very general exceptions such as BaseException is usually not recommended.

More than one statement on a single line

			raise e

Found indentation with tabs instead of spaces

		finally:

Found indentation with tabs instead of spaces

			if self.temp_dir is not None:

Found indentation with tabs instead of spaces

				if pexists(self.temp_dir):

Found indentation with tabs instead of spaces

					logger.debug("Deleted temp dir at {}".format(self.temp_dir))

Found indentation with tabs instead of spaces

Use lazy % formatting in logging functions

					shutil.rmtree(self.temp_dir)

Found indentation with tabs instead of spaces

					try:

Found indentation with tabs instead of spaces

						os.remove(self.temp_dir)

Found indentation with tabs instead of spaces

					except IOError: pass

Found indentation with tabs instead of spaces

More than one statement on a single line

#__all__ = ['scan_for_files', 'walk_until', 'walk_until_level']