"
+ self.text = text
+ if not self.text:
+ from coverage.python import get_python_source
+ try:
+ self.text = get_python_source(self.filename)
+ except IOError as err:
+ raise NoSource(
+ "No source for code: '%s': %s" % (self.filename, err)
+ )
+
+ self.exclude = exclude
+
+ # The text lines of the parsed code.
+ self.lines = self.text.split('\n')
+
+ # The normalized line numbers of the statements in the code. Exclusions
+ # are taken into account, and statements are adjusted to their first
+ # lines.
+ self.statements = set()
+
+ # The normalized line numbers of the excluded lines in the code,
+ # adjusted to their first lines.
+ self.excluded = set()
+
+ # The raw_* attributes are only used in this class, and in
+ # lab/parser.py to show how this class is working.
+
+ # The line numbers that start statements, as reported by the line
+ # number table in the bytecode.
+ self.raw_statements = set()
+
+ # The raw line numbers of excluded lines of code, as marked by pragmas.
+ self.raw_excluded = set()
+
+ # The line numbers of class and function definitions.
+ self.raw_classdefs = set()
+
+ # The line numbers of docstring lines.
+ self.raw_docstrings = set()
+
+ # Internal detail, used by lab/parser.py.
+ self.show_tokens = False
+
+ # A dict mapping line numbers to lexical statement starts for
+ # multi-line statements.
+ self._multiline = {}
+
+ # Lazily-created ByteParser, arc data, and missing arc descriptions.
+ self._byte_parser = None
+ self._all_arcs = None
+ self._missing_arc_fragments = None
+
+ @property
+ def byte_parser(self):
+ """Create a ByteParser on demand."""
+ if not self._byte_parser:
+ self._byte_parser = ByteParser(self.text, filename=self.filename)
+ return self._byte_parser
+
+ def lines_matching(self, *regexes):
+ """Find the lines matching one of a list of regexes.
+
+ Returns a set of line numbers, the lines that contain a match for one
+ of the regexes in `regexes`. The entire line needn't match, just a
+ part of it.
+
+ """
+ combined = join_regex(regexes)
+ if env.PY2:
+ combined = combined.decode("utf8")
+ regex_c = re.compile(combined)
+ matches = set()
+ for i, ltext in enumerate(self.lines, start=1):
+ if regex_c.search(ltext):
+ matches.add(i)
+ return matches
+
+ def _raw_parse(self):
+ """Parse the source to find the interesting facts about its lines.
+
+ A handful of attributes are updated.
+
+ """
+ # Find lines which match an exclusion pattern.
+ if self.exclude:
+ self.raw_excluded = self.lines_matching(self.exclude)
+
+ # Tokenize, to find excluded suites, to find docstrings, and to find
+ # multi-line statements.
+ indent = 0
+ exclude_indent = 0
+ excluding = False
+ excluding_decorators = False
+ prev_toktype = token.INDENT
+ first_line = None
+ empty = True
+ first_on_line = True
+
+ tokgen = generate_tokens(self.text)
+ for toktype, ttext, (slineno, _), (elineno, _), ltext in tokgen:
+ if self.show_tokens: # pragma: debugging
+ print("%10s %5s %-20r %r" % (
+ tokenize.tok_name.get(toktype, toktype),
+ nice_pair((slineno, elineno)), ttext, ltext
+ ))
+ if toktype == token.INDENT:
+ indent += 1
+ elif toktype == token.DEDENT:
+ indent -= 1
+ elif toktype == token.NAME:
+ if ttext == 'class':
+ # Class definitions look like branches in the bytecode, so
+ # we need to exclude them. The simplest way is to note the
+ # lines with the 'class' keyword.
+ self.raw_classdefs.add(slineno)
+ elif toktype == token.OP:
+ if ttext == ':':
+ should_exclude = (elineno in self.raw_excluded) or excluding_decorators
+ if not excluding and should_exclude:
+ # Start excluding a suite. We trigger off of the colon
+ # token so that the #pragma comment will be recognized on
+ # the same line as the colon.
+ self.raw_excluded.add(elineno)
+ exclude_indent = indent
+ excluding = True
+ excluding_decorators = False
+ elif ttext == '@' and first_on_line:
+ # A decorator.
+ if elineno in self.raw_excluded:
+ excluding_decorators = True
+ if excluding_decorators:
+ self.raw_excluded.add(elineno)
+ elif toktype == token.STRING and prev_toktype == token.INDENT:
+ # Strings that are first on an indented line are docstrings.
+ # (a trick from trace.py in the stdlib.) This works for
+ # 99.9999% of cases. For the rest (!) see:
+ # http://stackoverflow.com/questions/1769332/x/1769794#1769794
+ self.raw_docstrings.update(range(slineno, elineno+1))
+ elif toktype == token.NEWLINE:
+ if first_line is not None and elineno != first_line:
+ # We're at the end of a line, and we've ended on a
+ # different line than the first line of the statement,
+ # so record a multi-line range.
+ for l in range(first_line, elineno+1):
+ self._multiline[l] = first_line
+ first_line = None
+ first_on_line = True
+
+ if ttext.strip() and toktype != tokenize.COMMENT:
+ # A non-whitespace token.
+ empty = False
+ if first_line is None:
+ # The token is not whitespace, and is the first in a
+ # statement.
+ first_line = slineno
+ # Check whether to end an excluded suite.
+ if excluding and indent <= exclude_indent:
+ excluding = False
+ if excluding:
+ self.raw_excluded.add(elineno)
+ first_on_line = False
+
+ prev_toktype = toktype
+
+ # Find the starts of the executable statements.
+ if not empty:
+ self.raw_statements.update(self.byte_parser._find_statements())
+
+ def first_line(self, line):
+ """Return the first line number of the statement including `line`."""
+ return self._multiline.get(line, line)
+
+ def first_lines(self, lines):
+ """Map the line numbers in `lines` to the correct first line of the
+ statement.
+
+ Returns a set of the first lines.
+
+ """
+ return set(self.first_line(l) for l in lines)
+
+ def translate_lines(self, lines):
+ """Implement `FileReporter.translate_lines`."""
+ return self.first_lines(lines)
+
+ def translate_arcs(self, arcs):
+ """Implement `FileReporter.translate_arcs`."""
+ return [(self.first_line(a), self.first_line(b)) for (a, b) in arcs]
+
+ def parse_source(self):
+ """Parse source text to find executable lines, excluded lines, etc.
+
+ Sets the .excluded and .statements attributes, normalized to the first
+ line of multi-line statements.
+
+ """
+ try:
+ self._raw_parse()
+ except (tokenize.TokenError, IndentationError) as err:
+ if hasattr(err, "lineno"):
+ lineno = err.lineno # IndentationError
+ else:
+ lineno = err.args[1][0] # TokenError
+ raise NotPython(
+ u"Couldn't parse '%s' as Python source: '%s' at line %d" % (
+ self.filename, err.args[0], lineno
+ )
+ )
+
+ self.excluded = self.first_lines(self.raw_excluded)
+
+ ignore = self.excluded | self.raw_docstrings
+ starts = self.raw_statements - ignore
+ self.statements = self.first_lines(starts) - ignore
+
+ def arcs(self):
+ """Get information about the arcs available in the code.
+
+ Returns a set of line number pairs. Line numbers have been normalized
+ to the first line of multi-line statements.
+
+ """
+ if self._all_arcs is None:
+ self._analyze_ast()
+ return self._all_arcs
+
+ def _analyze_ast(self):
+ """Run the AstArcAnalyzer and save its results.
+
+ `_all_arcs` is the set of arcs in the code.
+
+ """
+ aaa = AstArcAnalyzer(self.text, self.raw_statements, self._multiline)
+ aaa.analyze()
+
+ self._all_arcs = set()
+ for l1, l2 in aaa.arcs:
+ fl1 = self.first_line(l1)
+ fl2 = self.first_line(l2)
+ if fl1 != fl2:
+ self._all_arcs.add((fl1, fl2))
+
+ self._missing_arc_fragments = aaa.missing_arc_fragments
+
+ def exit_counts(self):
+ """Get a count of exits from that each line.
+
+ Excluded lines are excluded.
+
+ """
+ exit_counts = collections.defaultdict(int)
+ for l1, l2 in self.arcs():
+ if l1 < 0:
+ # Don't ever report -1 as a line number
+ continue
+ if l1 in self.excluded:
+ # Don't report excluded lines as line numbers.
+ continue
+ if l2 in self.excluded:
+ # Arcs to excluded lines shouldn't count.
+ continue
+ exit_counts[l1] += 1
+
+ # Class definitions have one extra exit, so remove one for each:
+ for l in self.raw_classdefs:
+ # Ensure key is there: class definitions can include excluded lines.
+ if l in exit_counts:
+ exit_counts[l] -= 1
+
+ return exit_counts
+
+ def missing_arc_description(self, start, end, executed_arcs=None):
+ """Provide an English sentence describing a missing arc."""
+ if self._missing_arc_fragments is None:
+ self._analyze_ast()
+
+ actual_start = start
+
+ if (
+ executed_arcs and
+ end < 0 and end == -start and
+ (end, start) not in executed_arcs and
+ (end, start) in self._missing_arc_fragments
+ ):
+ # It's a one-line callable, and we never even started it,
+ # and we have a message about not starting it.
+ start, end = end, start
+
+ fragment_pairs = self._missing_arc_fragments.get((start, end), [(None, None)])
+
+ msgs = []
+ for fragment_pair in fragment_pairs:
+ smsg, emsg = fragment_pair
+
+ if emsg is None:
+ if end < 0:
+ # Hmm, maybe we have a one-line callable, let's check.
+ if (-end, end) in self._missing_arc_fragments:
+ return self.missing_arc_description(-end, end)
+ emsg = "didn't jump to the function exit"
+ else:
+ emsg = "didn't jump to line {lineno}"
+ emsg = emsg.format(lineno=end)
+
+ msg = "line {start} {emsg}".format(start=actual_start, emsg=emsg)
+ if smsg is not None:
+ msg += ", because {smsg}".format(smsg=smsg.format(lineno=actual_start))
+
+ msgs.append(msg)
+
+ return " or ".join(msgs)
+
+
+class ByteParser(object):
+ """Parse bytecode to understand the structure of code."""
+
+ @contract(text='unicode')
+ def __init__(self, text, code=None, filename=None):
+ self.text = text
+ if code:
+ self.code = code
+ else:
+ try:
+ self.code = compile_unicode(text, filename, "exec")
+ except SyntaxError as synerr:
+ raise NotPython(
+ u"Couldn't parse '%s' as Python source: '%s' at line %d" % (
+ filename, synerr.msg, synerr.lineno
+ )
+ )
+
+ # Alternative Python implementations don't always provide all the
+ # attributes on code objects that we need to do the analysis.
+ for attr in ['co_lnotab', 'co_firstlineno']:
+ if not hasattr(self.code, attr):
+ raise StopEverything( # pragma: only jython
+ "This implementation of Python doesn't support code analysis.\n"
+ "Run coverage.py under another Python for this command."
+ )
+
+ def child_parsers(self):
+ """Iterate over all the code objects nested within this one.
+
+ The iteration includes `self` as its first value.
+
+ """
+ children = CodeObjects(self.code)
+ return (ByteParser(self.text, code=c) for c in children)
+
+ def _bytes_lines(self):
+ """Map byte offsets to line numbers in `code`.
+
+ Uses co_lnotab described in Python/compile.c to map byte offsets to
+ line numbers. Produces a sequence: (b0, l0), (b1, l1), ...
+
+ Only byte offsets that correspond to line numbers are included in the
+ results.
+
+ """
+ # Adapted from dis.py in the standard library.
+ byte_increments = bytes_to_ints(self.code.co_lnotab[0::2])
+ line_increments = bytes_to_ints(self.code.co_lnotab[1::2])
+
+ last_line_num = None
+ line_num = self.code.co_firstlineno
+ byte_num = 0
+ for byte_incr, line_incr in zip(byte_increments, line_increments):
+ if byte_incr:
+ if line_num != last_line_num:
+ yield (byte_num, line_num)
+ last_line_num = line_num
+ byte_num += byte_incr
+ if env.PYVERSION >= (3, 6) and line_incr >= 0x80:
+ line_incr -= 0x100
+ line_num += line_incr
+ if line_num != last_line_num:
+ yield (byte_num, line_num)
+
+ def _find_statements(self):
+ """Find the statements in `self.code`.
+
+ Produce a sequence of line numbers that start statements. Recurses
+ into all code objects reachable from `self.code`.
+
+ """
+ for bp in self.child_parsers():
+ # Get all of the lineno information from this code.
+ for _, l in bp._bytes_lines():
+ yield l
+
+
+#
+# AST analysis
+#
+
+class LoopBlock(object):
+ """A block on the block stack representing a `for` or `while` loop."""
+ @contract(start=int)
+ def __init__(self, start):
+ # The line number where the loop starts.
+ self.start = start
+ # A set of ArcStarts, the arcs from break statements exiting this loop.
+ self.break_exits = set()
+
+
+class FunctionBlock(object):
+ """A block on the block stack representing a function definition."""
+ @contract(start=int, name=str)
+ def __init__(self, start, name):
+ # The line number where the function starts.
+ self.start = start
+ # The name of the function.
+ self.name = name
+
+
+class TryBlock(object):
+ """A block on the block stack representing a `try` block."""
+ @contract(handler_start='int|None', final_start='int|None')
+ def __init__(self, handler_start, final_start):
+ # The line number of the first "except" handler, if any.
+ self.handler_start = handler_start
+ # The line number of the "finally:" clause, if any.
+ self.final_start = final_start
+
+ # The ArcStarts for breaks/continues/returns/raises inside the "try:"
+ # that need to route through the "finally:" clause.
+ self.break_from = set()
+ self.continue_from = set()
+ self.return_from = set()
+ self.raise_from = set()
+
+
+class ArcStart(collections.namedtuple("Arc", "lineno, cause")):
+ """The information needed to start an arc.
+
+ `lineno` is the line number the arc starts from.
+
+ `cause` is an English text fragment used as the `startmsg` for
+ AstArcAnalyzer.missing_arc_fragments. It will be used to describe why an
+ arc wasn't executed, so should fit well into a sentence of the form,
+ "Line 17 didn't run because {cause}." The fragment can include "{lineno}"
+ to have `lineno` interpolated into it.
+
+ """
+ def __new__(cls, lineno, cause=None):
+ return super(ArcStart, cls).__new__(cls, lineno, cause)
+
+
+# Define contract words that PyContract doesn't have.
+# ArcStarts is for a list or set of ArcStart's.
+new_contract('ArcStarts', lambda seq: all(isinstance(x, ArcStart) for x in seq))
+
+
+# Turn on AST dumps with an environment variable.
+AST_DUMP = bool(int(os.environ.get("COVERAGE_AST_DUMP", 0)))
+
+class NodeList(object):
+ """A synthetic fictitious node, containing a sequence of nodes.
+
+ This is used when collapsing optimized if-statements, to represent the
+ unconditional execution of one of the clauses.
+
+ """
+ def __init__(self, body):
+ self.body = body
+ self.lineno = body[0].lineno
+
+
+# TODO: some add_arcs methods here don't add arcs, they return them. Rename them.
+# TODO: the cause messages have too many commas.
+# TODO: Shouldn't the cause messages join with "and" instead of "or"?
+
+class AstArcAnalyzer(object):
+ """Analyze source text with an AST to find executable code paths."""
+
+ @contract(text='unicode', statements=set)
+ def __init__(self, text, statements, multiline):
+ self.root_node = ast.parse(neuter_encoding_declaration(text))
+ # TODO: I think this is happening in too many places.
+ self.statements = set(multiline.get(l, l) for l in statements)
+ self.multiline = multiline
+
+ if AST_DUMP: # pragma: debugging
+ # Dump the AST so that failing tests have helpful output.
+ print("Statements: {0}".format(self.statements))
+ print("Multiline map: {0}".format(self.multiline))
+ ast_dump(self.root_node)
+
+ self.arcs = set()
+
+ # A map from arc pairs to a list of pairs of sentence fragments:
+ # { (start, end): [(startmsg, endmsg), ...], }
+ #
+ # For an arc from line 17, they should be usable like:
+ # "Line 17 {endmsg}, because {startmsg}"
+ self.missing_arc_fragments = collections.defaultdict(list)
+ self.block_stack = []
+
+ self.debug = bool(int(os.environ.get("COVERAGE_TRACK_ARCS", 0)))
+
+ def analyze(self):
+ """Examine the AST tree from `root_node` to determine possible arcs.
+
+ This sets the `arcs` attribute to be a set of (from, to) line number
+ pairs.
+
+ """
+ for node in ast.walk(self.root_node):
+ node_name = node.__class__.__name__
+ code_object_handler = getattr(self, "_code_object__" + node_name, None)
+ if code_object_handler is not None:
+ code_object_handler(node)
+
+ @contract(start=int, end=int)
+ def add_arc(self, start, end, smsg=None, emsg=None):
+ """Add an arc, including message fragments to use if it is missing."""
+ if self.debug: # pragma: debugging
+ print("\nAdding arc: ({}, {}): {!r}, {!r}".format(start, end, smsg, emsg))
+ print(short_stack(limit=6))
+ self.arcs.add((start, end))
+
+ if smsg is not None or emsg is not None:
+ self.missing_arc_fragments[(start, end)].append((smsg, emsg))
+
+ def nearest_blocks(self):
+ """Yield the blocks in nearest-to-farthest order."""
+ return reversed(self.block_stack)
+
+ @contract(returns=int)
+ def line_for_node(self, node):
+ """What is the right line number to use for this node?
+
+ This dispatches to _line__Node functions where needed.
+
+ """
+ node_name = node.__class__.__name__
+ handler = getattr(self, "_line__" + node_name, None)
+ if handler is not None:
+ return handler(node)
+ else:
+ return node.lineno
+
+ def _line_decorated(self, node):
+ """Compute first line number for things that can be decorated (classes and functions)."""
+ lineno = node.lineno
+ if env.PYBEHAVIOR.trace_decorated_def:
+ if node.decorator_list:
+ lineno = node.decorator_list[0].lineno
+ return lineno
+
+ def _line__Assign(self, node):
+ return self.line_for_node(node.value)
+
+ _line__ClassDef = _line_decorated
+
+ def _line__Dict(self, node):
+ # Python 3.5 changed how dict literals are made.
+ if env.PYVERSION >= (3, 5) and node.keys:
+ if node.keys[0] is not None:
+ return node.keys[0].lineno
+ else:
+ # Unpacked dict literals `{**{'a':1}}` have None as the key,
+ # use the value in that case.
+ return node.values[0].lineno
+ else:
+ return node.lineno
+
+ _line__FunctionDef = _line_decorated
+
+ def _line__List(self, node):
+ if node.elts:
+ return self.line_for_node(node.elts[0])
+ else:
+ return node.lineno
+
+ def _line__Module(self, node):
+ if node.body:
+ return self.line_for_node(node.body[0])
+ else:
+ # Empty modules have no line number, they always start at 1.
+ return 1
+
+ # The node types that just flow to the next node with no complications.
+ OK_TO_DEFAULT = set([
+ "Assign", "Assert", "AugAssign", "Delete", "Exec", "Expr", "Global",
+ "Import", "ImportFrom", "Nonlocal", "Pass", "Print",
+ ])
+
+ @contract(returns='ArcStarts')
+ def add_arcs(self, node):
+ """Add the arcs for `node`.
+
+ Return a set of ArcStarts, exits from this node to the next. Because a
+ node represents an entire sub-tree (including its children), the exits
+ from a node can be arbitrarily complex::
+
+ if something(1):
+ if other(2):
+ doit(3)
+ else:
+ doit(5)
+
+ There are two exits from line 1: they start at line 3 and line 5.
+
+ """
+ node_name = node.__class__.__name__
+ handler = getattr(self, "_handle__" + node_name, None)
+ if handler is not None:
+ return handler(node)
+ else:
+ # No handler: either it's something that's ok to default (a simple
+ # statement), or it's something we overlooked. Change this 0 to 1
+ # to see if it's overlooked.
+ if 0:
+ if node_name not in self.OK_TO_DEFAULT:
+ print("*** Unhandled: {0}".format(node))
+
+ # Default for simple statements: one exit from this node.
+ return set([ArcStart(self.line_for_node(node))])
+
+ @one_of("from_start, prev_starts")
+ @contract(returns='ArcStarts')
+ def add_body_arcs(self, body, from_start=None, prev_starts=None):
+ """Add arcs for the body of a compound statement.
+
+ `body` is the body node. `from_start` is a single `ArcStart` that can
+ be the previous line in flow before this body. `prev_starts` is a set
+ of ArcStarts that can be the previous line. Only one of them should be
+ given.
+
+ Returns a set of ArcStarts, the exits from this body.
+
+ """
+ if prev_starts is None:
+ prev_starts = set([from_start])
+ for body_node in body:
+ lineno = self.line_for_node(body_node)
+ first_line = self.multiline.get(lineno, lineno)
+ if first_line not in self.statements:
+ body_node = self.find_non_missing_node(body_node)
+ if body_node is None:
+ continue
+ lineno = self.line_for_node(body_node)
+ for prev_start in prev_starts:
+ self.add_arc(prev_start.lineno, lineno, prev_start.cause)
+ prev_starts = self.add_arcs(body_node)
+ return prev_starts
+
+ def find_non_missing_node(self, node):
+ """Search `node` looking for a child that has not been optimized away.
+
+ This might return the node you started with, or it will work recursively
+ to find a child node in self.statements.
+
+ Returns a node, or None if none of the node remains.
+
+ """
+ # This repeats work just done in add_body_arcs, but this duplication
+ # means we can avoid a function call in the 99.9999% case of not
+ # optimizing away statements.
+ lineno = self.line_for_node(node)
+ first_line = self.multiline.get(lineno, lineno)
+ if first_line in self.statements:
+ return node
+
+ missing_fn = getattr(self, "_missing__" + node.__class__.__name__, None)
+ if missing_fn:
+ node = missing_fn(node)
+ else:
+ node = None
+ return node
+
+ # Missing nodes: _missing__*
+ #
+ # Entire statements can be optimized away by Python. They will appear in
+ # the AST, but not the bytecode. These functions are called (by
+ # find_non_missing_node) to find a node to use instead of the missing
+ # node. They can return None if the node should truly be gone.
+
+ def _missing__If(self, node):
+ # If the if-node is missing, then one of its children might still be
+ # here, but not both. So return the first of the two that isn't missing.
+ # Use a NodeList to hold the clauses as a single node.
+ non_missing = self.find_non_missing_node(NodeList(node.body))
+ if non_missing:
+ return non_missing
+ if node.orelse:
+ return self.find_non_missing_node(NodeList(node.orelse))
+ return None
+
+ def _missing__NodeList(self, node):
+ # A NodeList might be a mixture of missing and present nodes. Find the
+ # ones that are present.
+ non_missing_children = []
+ for child in node.body:
+ child = self.find_non_missing_node(child)
+ if child is not None:
+ non_missing_children.append(child)
+
+ # Return the simplest representation of the present children.
+ if not non_missing_children:
+ return None
+ if len(non_missing_children) == 1:
+ return non_missing_children[0]
+ return NodeList(non_missing_children)
+
+ def _missing__While(self, node):
+ body_nodes = self.find_non_missing_node(NodeList(node.body))
+ if not body_nodes:
+ return None
+ # Make a synthetic While-true node.
+ new_while = ast.While()
+ new_while.lineno = body_nodes.lineno
+ new_while.test = ast.Name()
+ new_while.test.lineno = body_nodes.lineno
+ new_while.test.id = "True"
+ new_while.body = body_nodes.body
+ new_while.orelse = None
+ return new_while
+
+ def is_constant_expr(self, node):
+ """Is this a compile-time constant?"""
+ node_name = node.__class__.__name__
+ if node_name in ["Constant", "NameConstant", "Num"]:
+ return "Num"
+ elif node_name == "Name":
+ if node.id in ["True", "False", "None", "__debug__"]:
+ return "Name"
+ return None
+
+ # In the fullness of time, these might be good tests to write:
+ # while EXPR:
+ # while False:
+ # listcomps hidden deep in other expressions
+ # listcomps hidden in lists: x = [[i for i in range(10)]]
+ # nested function definitions
+
+
+ # Exit processing: process_*_exits
+ #
+ # These functions process the four kinds of jump exits: break, continue,
+ # raise, and return. To figure out where an exit goes, we have to look at
+ # the block stack context. For example, a break will jump to the nearest
+ # enclosing loop block, or the nearest enclosing finally block, whichever
+ # is nearer.
+
+ @contract(exits='ArcStarts')
+ def process_break_exits(self, exits):
+ """Add arcs due to jumps from `exits` being breaks."""
+ for block in self.nearest_blocks():
+ if isinstance(block, LoopBlock):
+ block.break_exits.update(exits)
+ break
+ elif isinstance(block, TryBlock) and block.final_start is not None:
+ block.break_from.update(exits)
+ break
+
+ @contract(exits='ArcStarts')
+ def process_continue_exits(self, exits):
+ """Add arcs due to jumps from `exits` being continues."""
+ for block in self.nearest_blocks():
+ if isinstance(block, LoopBlock):
+ for xit in exits:
+ self.add_arc(xit.lineno, block.start, xit.cause)
+ break
+ elif isinstance(block, TryBlock) and block.final_start is not None:
+ block.continue_from.update(exits)
+ break
+
+ @contract(exits='ArcStarts')
+ def process_raise_exits(self, exits):
+ """Add arcs due to jumps from `exits` being raises."""
+ for block in self.nearest_blocks():
+ if isinstance(block, TryBlock):
+ if block.handler_start is not None:
+ for xit in exits:
+ self.add_arc(xit.lineno, block.handler_start, xit.cause)
+ break
+ elif block.final_start is not None:
+ block.raise_from.update(exits)
+ break
+ elif isinstance(block, FunctionBlock):
+ for xit in exits:
+ self.add_arc(
+ xit.lineno, -block.start, xit.cause,
+ "didn't except from function '{0}'".format(block.name),
+ )
+ break
+
+ @contract(exits='ArcStarts')
+ def process_return_exits(self, exits):
+ """Add arcs due to jumps from `exits` being returns."""
+ for block in self.nearest_blocks():
+ if isinstance(block, TryBlock) and block.final_start is not None:
+ block.return_from.update(exits)
+ break
+ elif isinstance(block, FunctionBlock):
+ for xit in exits:
+ self.add_arc(
+ xit.lineno, -block.start, xit.cause,
+ "didn't return from function '{0}'".format(block.name),
+ )
+ break
+
+
+ # Handlers: _handle__*
+ #
+ # Each handler deals with a specific AST node type, dispatched from
+ # add_arcs. Handlers return the set of exits from that node, and can
+ # also call self.add_arc to record arcs they find. These functions mirror
+ # the Python semantics of each syntactic construct. See the docstring
+ # for add_arcs to understand the concept of exits from a node.
+
+ @contract(returns='ArcStarts')
+ def _handle__Break(self, node):
+ here = self.line_for_node(node)
+ break_start = ArcStart(here, cause="the break on line {lineno} wasn't executed")
+ self.process_break_exits([break_start])
+ return set()
+
+ @contract(returns='ArcStarts')
+ def _handle_decorated(self, node):
+ """Add arcs for things that can be decorated (classes and functions)."""
+ main_line = last = node.lineno
+ if node.decorator_list:
+ if env.PYBEHAVIOR.trace_decorated_def:
+ last = None
+ for dec_node in node.decorator_list:
+ dec_start = self.line_for_node(dec_node)
+ if last is not None and dec_start != last:
+ self.add_arc(last, dec_start)
+ last = dec_start
+ if env.PYBEHAVIOR.trace_decorated_def:
+ self.add_arc(last, main_line)
+ last = main_line
+ # The definition line may have been missed, but we should have it
+ # in `self.statements`. For some constructs, `line_for_node` is
+ # not what we'd think of as the first line in the statement, so map
+ # it to the first one.
+ if node.body:
+ body_start = self.line_for_node(node.body[0])
+ body_start = self.multiline.get(body_start, body_start)
+ for lineno in range(last+1, body_start):
+ if lineno in self.statements:
+ self.add_arc(last, lineno)
+ last = lineno
+ # The body is handled in collect_arcs.
+ return set([ArcStart(last)])
+
+ _handle__ClassDef = _handle_decorated
+
+ @contract(returns='ArcStarts')
+ def _handle__Continue(self, node):
+ here = self.line_for_node(node)
+ continue_start = ArcStart(here, cause="the continue on line {lineno} wasn't executed")
+ self.process_continue_exits([continue_start])
+ return set()
+
+ @contract(returns='ArcStarts')
+ def _handle__For(self, node):
+ start = self.line_for_node(node.iter)
+ self.block_stack.append(LoopBlock(start=start))
+ from_start = ArcStart(start, cause="the loop on line {lineno} never started")
+ exits = self.add_body_arcs(node.body, from_start=from_start)
+ # Any exit from the body will go back to the top of the loop.
+ for xit in exits:
+ self.add_arc(xit.lineno, start, xit.cause)
+ my_block = self.block_stack.pop()
+ exits = my_block.break_exits
+ from_start = ArcStart(start, cause="the loop on line {lineno} didn't complete")
+ if node.orelse:
+ else_exits = self.add_body_arcs(node.orelse, from_start=from_start)
+ exits |= else_exits
+ else:
+ # No else clause: exit from the for line.
+ exits.add(from_start)
+ return exits
+
+ _handle__AsyncFor = _handle__For
+
+ _handle__FunctionDef = _handle_decorated
+ _handle__AsyncFunctionDef = _handle_decorated
+
+ @contract(returns='ArcStarts')
+ def _handle__If(self, node):
+ start = self.line_for_node(node.test)
+ from_start = ArcStart(start, cause="the condition on line {lineno} was never true")
+ exits = self.add_body_arcs(node.body, from_start=from_start)
+ from_start = ArcStart(start, cause="the condition on line {lineno} was never false")
+ exits |= self.add_body_arcs(node.orelse, from_start=from_start)
+ return exits
+
+ @contract(returns='ArcStarts')
+ def _handle__NodeList(self, node):
+ start = self.line_for_node(node)
+ exits = self.add_body_arcs(node.body, from_start=ArcStart(start))
+ return exits
+
+ @contract(returns='ArcStarts')
+ def _handle__Raise(self, node):
+ here = self.line_for_node(node)
+ raise_start = ArcStart(here, cause="the raise on line {lineno} wasn't executed")
+ self.process_raise_exits([raise_start])
+ # `raise` statement jumps away, no exits from here.
+ return set()
+
+ @contract(returns='ArcStarts')
+ def _handle__Return(self, node):
+ here = self.line_for_node(node)
+ return_start = ArcStart(here, cause="the return on line {lineno} wasn't executed")
+ self.process_return_exits([return_start])
+ # `return` statement jumps away, no exits from here.
+ return set()
+
+ @contract(returns='ArcStarts')
+ def _handle__Try(self, node):
+ if node.handlers:
+ handler_start = self.line_for_node(node.handlers[0])
+ else:
+ handler_start = None
+
+ if node.finalbody:
+ final_start = self.line_for_node(node.finalbody[0])
+ else:
+ final_start = None
+
+ try_block = TryBlock(handler_start, final_start)
+ self.block_stack.append(try_block)
+
+ start = self.line_for_node(node)
+ exits = self.add_body_arcs(node.body, from_start=ArcStart(start))
+
+ # We're done with the `try` body, so this block no longer handles
+ # exceptions. We keep the block so the `finally` clause can pick up
+ # flows from the handlers and `else` clause.
+ if node.finalbody:
+ try_block.handler_start = None
+ if node.handlers:
+ # If there are `except` clauses, then raises in the try body
+ # will already jump to them. Start this set over for raises in
+ # `except` and `else`.
+ try_block.raise_from = set([])
+ else:
+ self.block_stack.pop()
+
+ handler_exits = set()
+
+ if node.handlers:
+ last_handler_start = None
+ for handler_node in node.handlers:
+ handler_start = self.line_for_node(handler_node)
+ if last_handler_start is not None:
+ self.add_arc(last_handler_start, handler_start)
+ last_handler_start = handler_start
+ from_cause = "the exception caught by line {lineno} didn't happen"
+ from_start = ArcStart(handler_start, cause=from_cause)
+ handler_exits |= self.add_body_arcs(handler_node.body, from_start=from_start)
+
+ if node.orelse:
+ exits = self.add_body_arcs(node.orelse, prev_starts=exits)
+
+ exits |= handler_exits
+
+ if node.finalbody:
+ self.block_stack.pop()
+ final_from = ( # You can get to the `finally` clause from:
+ exits | # the exits of the body or `else` clause,
+ try_block.break_from | # or a `break`,
+ try_block.continue_from | # or a `continue`,
+ try_block.raise_from | # or a `raise`,
+ try_block.return_from # or a `return`.
+ )
+
+ final_exits = self.add_body_arcs(node.finalbody, prev_starts=final_from)
+
+ if try_block.break_from:
+ if env.PYBEHAVIOR.finally_jumps_back:
+ for break_line in try_block.break_from:
+ lineno = break_line.lineno
+ cause = break_line.cause.format(lineno=lineno)
+ for final_exit in final_exits:
+ self.add_arc(final_exit.lineno, lineno, cause)
+ breaks = try_block.break_from
+ else:
+ breaks = self._combine_finally_starts(try_block.break_from, final_exits)
+ self.process_break_exits(breaks)
+
+ if try_block.continue_from:
+ if env.PYBEHAVIOR.finally_jumps_back:
+ for continue_line in try_block.continue_from:
+ lineno = continue_line.lineno
+ cause = continue_line.cause.format(lineno=lineno)
+ for final_exit in final_exits:
+ self.add_arc(final_exit.lineno, lineno, cause)
+ continues = try_block.continue_from
+ else:
+ continues = self._combine_finally_starts(try_block.continue_from, final_exits)
+ self.process_continue_exits(continues)
+
+ if try_block.raise_from:
+ self.process_raise_exits(
+ self._combine_finally_starts(try_block.raise_from, final_exits)
+ )
+
+ if try_block.return_from:
+ if env.PYBEHAVIOR.finally_jumps_back:
+ for return_line in try_block.return_from:
+ lineno = return_line.lineno
+ cause = return_line.cause.format(lineno=lineno)
+ for final_exit in final_exits:
+ self.add_arc(final_exit.lineno, lineno, cause)
+ returns = try_block.return_from
+ else:
+ returns = self._combine_finally_starts(try_block.return_from, final_exits)
+ self.process_return_exits(returns)
+
+ if exits:
+ # The finally clause's exits are only exits for the try block
+ # as a whole if the try block had some exits to begin with.
+ exits = final_exits
+
+ return exits
+
+ @contract(starts='ArcStarts', exits='ArcStarts', returns='ArcStarts')
+ def _combine_finally_starts(self, starts, exits):
+ """Helper for building the cause of `finally` branches.
+
+ "finally" clauses might not execute their exits, and the causes could
+ be due to a failure to execute any of the exits in the try block. So
+ we use the causes from `starts` as the causes for `exits`.
+ """
+ causes = []
+ for start in sorted(starts):
+ if start.cause is not None:
+ causes.append(start.cause.format(lineno=start.lineno))
+ cause = " or ".join(causes)
+ exits = set(ArcStart(xit.lineno, cause) for xit in exits)
+ return exits
+
+ @contract(returns='ArcStarts')
+ def _handle__TryExcept(self, node):
+ # Python 2.7 uses separate TryExcept and TryFinally nodes. If we get
+ # TryExcept, it means there was no finally, so fake it, and treat as
+ # a general Try node.
+ node.finalbody = []
+ return self._handle__Try(node)
+
+ @contract(returns='ArcStarts')
+ def _handle__TryFinally(self, node):
+ # Python 2.7 uses separate TryExcept and TryFinally nodes. If we get
+ # TryFinally, see if there's a TryExcept nested inside. If so, merge
+ # them. Otherwise, fake fields to complete a Try node.
+ node.handlers = []
+ node.orelse = []
+
+ first = node.body[0]
+ if first.__class__.__name__ == "TryExcept" and node.lineno == first.lineno:
+ assert len(node.body) == 1
+ node.body = first.body
+ node.handlers = first.handlers
+ node.orelse = first.orelse
+
+ return self._handle__Try(node)
+
+ @contract(returns='ArcStarts')
+ def _handle__While(self, node):
+ constant_test = self.is_constant_expr(node.test)
+ start = to_top = self.line_for_node(node.test)
+ if constant_test and (env.PY3 or constant_test == "Num"):
+ to_top = self.line_for_node(node.body[0])
+ self.block_stack.append(LoopBlock(start=to_top))
+ from_start = ArcStart(start, cause="the condition on line {lineno} was never true")
+ exits = self.add_body_arcs(node.body, from_start=from_start)
+ for xit in exits:
+ self.add_arc(xit.lineno, to_top, xit.cause)
+ exits = set()
+ my_block = self.block_stack.pop()
+ exits.update(my_block.break_exits)
+ from_start = ArcStart(start, cause="the condition on line {lineno} was never false")
+ if node.orelse:
+ else_exits = self.add_body_arcs(node.orelse, from_start=from_start)
+ exits |= else_exits
+ else:
+ # No `else` clause: you can exit from the start.
+ if not constant_test:
+ exits.add(from_start)
+ return exits
+
+ @contract(returns='ArcStarts')
+ def _handle__With(self, node):
+ start = self.line_for_node(node)
+ exits = self.add_body_arcs(node.body, from_start=ArcStart(start))
+ return exits
+
+ _handle__AsyncWith = _handle__With
+
+ def _code_object__Module(self, node):
+ start = self.line_for_node(node)
+ if node.body:
+ exits = self.add_body_arcs(node.body, from_start=ArcStart(-start))
+ for xit in exits:
+ self.add_arc(xit.lineno, -start, xit.cause, "didn't exit the module")
+ else:
+ # Empty module.
+ self.add_arc(-start, start)
+ self.add_arc(start, -start)
+
+ def _code_object__FunctionDef(self, node):
+ start = self.line_for_node(node)
+ self.block_stack.append(FunctionBlock(start=start, name=node.name))
+ exits = self.add_body_arcs(node.body, from_start=ArcStart(-start))
+ self.process_return_exits(exits)
+ self.block_stack.pop()
+
+ _code_object__AsyncFunctionDef = _code_object__FunctionDef
+
+ def _code_object__ClassDef(self, node):
+ start = self.line_for_node(node)
+ self.add_arc(-start, start)
+ exits = self.add_body_arcs(node.body, from_start=ArcStart(start))
+ for xit in exits:
+ self.add_arc(
+ xit.lineno, -start, xit.cause,
+ "didn't exit the body of class '{0}'".format(node.name),
+ )
+
+ def _make_oneline_code_method(noun): # pylint: disable=no-self-argument
+ """A function to make methods for online callable _code_object__ methods."""
+ def _code_object__oneline_callable(self, node):
+ start = self.line_for_node(node)
+ self.add_arc(-start, start, None, "didn't run the {0} on line {1}".format(noun, start))
+ self.add_arc(
+ start, -start, None,
+ "didn't finish the {0} on line {1}".format(noun, start),
+ )
+ return _code_object__oneline_callable
+
+ _code_object__Lambda = _make_oneline_code_method("lambda")
+ _code_object__GeneratorExp = _make_oneline_code_method("generator expression")
+ _code_object__DictComp = _make_oneline_code_method("dictionary comprehension")
+ _code_object__SetComp = _make_oneline_code_method("set comprehension")
+ if env.PY3:
+ _code_object__ListComp = _make_oneline_code_method("list comprehension")
+
+
+if AST_DUMP: # pragma: debugging
+ # Code only used when dumping the AST for debugging.
+
+ SKIP_DUMP_FIELDS = ["ctx"]
+
+ def _is_simple_value(value):
+ """Is `value` simple enough to be displayed on a single line?"""
+ return (
+ value in [None, [], (), {}, set()] or
+ isinstance(value, (string_class, int, float))
+ )
+
+ def ast_dump(node, depth=0):
+ """Dump the AST for `node`.
+
+ This recursively walks the AST, printing a readable version.
+
+ """
+ indent = " " * depth
+ if not isinstance(node, ast.AST):
+ print("{0}<{1} {2!r}>".format(indent, node.__class__.__name__, node))
+ return
+
+ lineno = getattr(node, "lineno", None)
+ if lineno is not None:
+ linemark = " @ {0}".format(node.lineno)
+ else:
+ linemark = ""
+ head = "{0}<{1}{2}".format(indent, node.__class__.__name__, linemark)
+
+ named_fields = [
+ (name, value)
+ for name, value in ast.iter_fields(node)
+ if name not in SKIP_DUMP_FIELDS
+ ]
+ if not named_fields:
+ print("{0}>".format(head))
+ elif len(named_fields) == 1 and _is_simple_value(named_fields[0][1]):
+ field_name, value = named_fields[0]
+ print("{0} {1}: {2!r}>".format(head, field_name, value))
+ else:
+ print(head)
+ if 0:
+ print("{0}# mro: {1}".format(
+ indent, ", ".join(c.__name__ for c in node.__class__.__mro__[1:]),
+ ))
+ next_indent = indent + " "
+ for field_name, value in named_fields:
+ prefix = "{0}{1}:".format(next_indent, field_name)
+ if _is_simple_value(value):
+ print("{0} {1!r}".format(prefix, value))
+ elif isinstance(value, list):
+ print("{0} [".format(prefix))
+ for n in value:
+ ast_dump(n, depth + 8)
+ print("{0}]".format(next_indent))
+ else:
+ print(prefix)
+ ast_dump(value, depth + 8)
+
+ print("{0}>".format(indent))
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/phystokens.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/phystokens.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2b23cfc34410003adf7bdc8e8a45a638d09b1d7
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/phystokens.py
@@ -0,0 +1,298 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""Better tokenizing for coverage.py."""
+
+import codecs
+import keyword
+import re
+import sys
+import token
+import tokenize
+
+from coverage import env
+from coverage.backward import iternext, unicode_class
+from coverage.misc import contract
+
+
+def phys_tokens(toks):
+ """Return all physical tokens, even line continuations.
+
+ tokenize.generate_tokens() doesn't return a token for the backslash that
+ continues lines. This wrapper provides those tokens so that we can
+ re-create a faithful representation of the original source.
+
+ Returns the same values as generate_tokens()
+
+ """
+ last_line = None
+ last_lineno = -1
+ last_ttype = None
+ for ttype, ttext, (slineno, scol), (elineno, ecol), ltext in toks:
+ if last_lineno != elineno:
+ if last_line and last_line.endswith("\\\n"):
+ # We are at the beginning of a new line, and the last line
+ # ended with a backslash. We probably have to inject a
+ # backslash token into the stream. Unfortunately, there's more
+ # to figure out. This code::
+ #
+ # usage = """\
+ # HEY THERE
+ # """
+ #
+ # triggers this condition, but the token text is::
+ #
+ # '"""\\\nHEY THERE\n"""'
+ #
+ # so we need to figure out if the backslash is already in the
+ # string token or not.
+ inject_backslash = True
+ if last_ttype == tokenize.COMMENT:
+ # Comments like this \
+ # should never result in a new token.
+ inject_backslash = False
+ elif ttype == token.STRING:
+ if "\n" in ttext and ttext.split('\n', 1)[0][-1] == '\\':
+ # It's a multi-line string and the first line ends with
+ # a backslash, so we don't need to inject another.
+ inject_backslash = False
+ if inject_backslash:
+ # Figure out what column the backslash is in.
+ ccol = len(last_line.split("\n")[-2]) - 1
+ # Yield the token, with a fake token type.
+ yield (
+ 99999, "\\\n",
+ (slineno, ccol), (slineno, ccol+2),
+ last_line
+ )
+ last_line = ltext
+ last_ttype = ttype
+ yield ttype, ttext, (slineno, scol), (elineno, ecol), ltext
+ last_lineno = elineno
+
+
+@contract(source='unicode')
+def source_token_lines(source):
+ """Generate a series of lines, one for each line in `source`.
+
+ Each line is a list of pairs, each pair is a token::
+
+ [('key', 'def'), ('ws', ' '), ('nam', 'hello'), ('op', '('), ... ]
+
+ Each pair has a token class, and the token text.
+
+ If you concatenate all the token texts, and then join them with newlines,
+ you should have your original `source` back, with two differences:
+ trailing whitespace is not preserved, and a final line with no newline
+ is indistinguishable from a final line with a newline.
+
+ """
+
+ ws_tokens = set([token.INDENT, token.DEDENT, token.NEWLINE, tokenize.NL])
+ line = []
+ col = 0
+
+ source = source.expandtabs(8).replace('\r\n', '\n')
+ tokgen = generate_tokens(source)
+
+ for ttype, ttext, (_, scol), (_, ecol), _ in phys_tokens(tokgen):
+ mark_start = True
+ for part in re.split('(\n)', ttext):
+ if part == '\n':
+ yield line
+ line = []
+ col = 0
+ mark_end = False
+ elif part == '':
+ mark_end = False
+ elif ttype in ws_tokens:
+ mark_end = False
+ else:
+ if mark_start and scol > col:
+ line.append(("ws", u" " * (scol - col)))
+ mark_start = False
+ tok_class = tokenize.tok_name.get(ttype, 'xx').lower()[:3]
+ if ttype == token.NAME and keyword.iskeyword(ttext):
+ tok_class = "key"
+ line.append((tok_class, part))
+ mark_end = True
+ scol = 0
+ if mark_end:
+ col = ecol
+
+ if line:
+ yield line
+
+
+class CachedTokenizer(object):
+ """A one-element cache around tokenize.generate_tokens.
+
+ When reporting, coverage.py tokenizes files twice, once to find the
+ structure of the file, and once to syntax-color it. Tokenizing is
+ expensive, and easily cached.
+
+ This is a one-element cache so that our twice-in-a-row tokenizing doesn't
+ actually tokenize twice.
+
+ """
+ def __init__(self):
+ self.last_text = None
+ self.last_tokens = None
+
+ @contract(text='unicode')
+ def generate_tokens(self, text):
+ """A stand-in for `tokenize.generate_tokens`."""
+ if text != self.last_text:
+ self.last_text = text
+ readline = iternext(text.splitlines(True))
+ self.last_tokens = list(tokenize.generate_tokens(readline))
+ return self.last_tokens
+
+# Create our generate_tokens cache as a callable replacement function.
+generate_tokens = CachedTokenizer().generate_tokens
+
+
+COOKIE_RE = re.compile(r"^[ \t]*#.*coding[:=][ \t]*([-\w.]+)", flags=re.MULTILINE)
+
+@contract(source='bytes')
+def _source_encoding_py2(source):
+ """Determine the encoding for `source`, according to PEP 263.
+
+ `source` is a byte string, the text of the program.
+
+ Returns a string, the name of the encoding.
+
+ """
+ assert isinstance(source, bytes)
+
+ # Do this so the detect_encode code we copied will work.
+ readline = iternext(source.splitlines(True))
+
+ # This is mostly code adapted from Py3.2's tokenize module.
+
+ def _get_normal_name(orig_enc):
+ """Imitates get_normal_name in tokenizer.c."""
+ # Only care about the first 12 characters.
+ enc = orig_enc[:12].lower().replace("_", "-")
+ if re.match(r"^utf-8($|-)", enc):
+ return "utf-8"
+ if re.match(r"^(latin-1|iso-8859-1|iso-latin-1)($|-)", enc):
+ return "iso-8859-1"
+ return orig_enc
+
+ # From detect_encode():
+ # It detects the encoding from the presence of a UTF-8 BOM or an encoding
+ # cookie as specified in PEP-0263. If both a BOM and a cookie are present,
+ # but disagree, a SyntaxError will be raised. If the encoding cookie is an
+ # invalid charset, raise a SyntaxError. Note that if a UTF-8 BOM is found,
+ # 'utf-8-sig' is returned.
+
+ # If no encoding is specified, then the default will be returned.
+ default = 'ascii'
+
+ bom_found = False
+ encoding = None
+
+ def read_or_stop():
+ """Get the next source line, or ''."""
+ try:
+ return readline()
+ except StopIteration:
+ return ''
+
+ def find_cookie(line):
+ """Find an encoding cookie in `line`."""
+ try:
+ line_string = line.decode('ascii')
+ except UnicodeDecodeError:
+ return None
+
+ matches = COOKIE_RE.findall(line_string)
+ if not matches:
+ return None
+ encoding = _get_normal_name(matches[0])
+ try:
+ codec = codecs.lookup(encoding)
+ except LookupError:
+ # This behavior mimics the Python interpreter
+ raise SyntaxError("unknown encoding: " + encoding)
+
+ if bom_found:
+ # codecs in 2.3 were raw tuples of functions, assume the best.
+ codec_name = getattr(codec, 'name', encoding)
+ if codec_name != 'utf-8':
+ # This behavior mimics the Python interpreter
+ raise SyntaxError('encoding problem: utf-8')
+ encoding += '-sig'
+ return encoding
+
+ first = read_or_stop()
+ if first.startswith(codecs.BOM_UTF8):
+ bom_found = True
+ first = first[3:]
+ default = 'utf-8-sig'
+ if not first:
+ return default
+
+ encoding = find_cookie(first)
+ if encoding:
+ return encoding
+
+ second = read_or_stop()
+ if not second:
+ return default
+
+ encoding = find_cookie(second)
+ if encoding:
+ return encoding
+
+ return default
+
+
+@contract(source='bytes')
+def _source_encoding_py3(source):
+ """Determine the encoding for `source`, according to PEP 263.
+
+ `source` is a byte string: the text of the program.
+
+ Returns a string, the name of the encoding.
+
+ """
+ readline = iternext(source.splitlines(True))
+ return tokenize.detect_encoding(readline)[0]
+
+
+if env.PY3:
+ source_encoding = _source_encoding_py3
+else:
+ source_encoding = _source_encoding_py2
+
+
+@contract(source='unicode')
+def compile_unicode(source, filename, mode):
+ """Just like the `compile` builtin, but works on any Unicode string.
+
+ Python 2's compile() builtin has a stupid restriction: if the source string
+ is Unicode, then it may not have a encoding declaration in it. Why not?
+ Who knows! It also decodes to utf8, and then tries to interpret those utf8
+ bytes according to the encoding declaration. Why? Who knows!
+
+ This function neuters the coding declaration, and compiles it.
+
+ """
+ source = neuter_encoding_declaration(source)
+ if env.PY2 and isinstance(filename, unicode_class):
+ filename = filename.encode(sys.getfilesystemencoding(), "replace")
+ code = compile(source, filename, mode)
+ return code
+
+
+@contract(source='unicode', returns='unicode')
+def neuter_encoding_declaration(source):
+ """Return `source`, with any encoding declaration neutered."""
+ if COOKIE_RE.search(source):
+ source_lines = source.splitlines(True)
+ for lineno in range(min(2, len(source_lines))):
+ source_lines[lineno] = COOKIE_RE.sub("# (deleted declaration)", source_lines[lineno])
+ source = "".join(source_lines)
+ return source
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/pickle2json.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/pickle2json.py
new file mode 100644
index 0000000000000000000000000000000000000000..95b42ef370457d717185670764675d305101a1fd
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/pickle2json.py
@@ -0,0 +1,47 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""Convert pickle to JSON for coverage.py."""
+
+from coverage.backward import pickle
+from coverage.data import CoverageData
+
+
+def pickle_read_raw_data(cls_unused, file_obj):
+ """Replacement for CoverageData._read_raw_data."""
+ return pickle.load(file_obj)
+
+
+def pickle2json(infile, outfile):
+ """Convert a coverage.py 3.x pickle data file to a 4.x JSON data file."""
+ try:
+ old_read_raw_data = CoverageData._read_raw_data
+ CoverageData._read_raw_data = pickle_read_raw_data
+
+ covdata = CoverageData()
+
+ with open(infile, 'rb') as inf:
+ covdata.read_fileobj(inf)
+
+ covdata.write_file(outfile)
+ finally:
+ CoverageData._read_raw_data = old_read_raw_data
+
+
+if __name__ == "__main__":
+ from optparse import OptionParser
+
+ parser = OptionParser(usage="usage: %s [options]" % __file__)
+ parser.description = "Convert .coverage files from pickle to JSON format"
+ parser.add_option(
+ "-i", "--input-file", action="store", default=".coverage",
+ help="Name of input file. Default .coverage",
+ )
+ parser.add_option(
+ "-o", "--output-file", action="store", default=".coverage",
+ help="Name of output file. Default .coverage",
+ )
+
+ (options, args) = parser.parse_args()
+
+ pickle2json(options.input_file, options.output_file)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/plugin.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/plugin.py
new file mode 100644
index 0000000000000000000000000000000000000000..db7ca0a76a54580d3d1114ad929667ca9d85e4d6
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/plugin.py
@@ -0,0 +1,482 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""
+.. versionadded:: 4.0
+
+Plug-in interfaces for coverage.py.
+
+Coverage.py supports a few different kinds of plug-ins that change its
+behavior:
+
+* File tracers implement tracing of non-Python file types.
+
+* Configurers add custom configuration, using Python code to change the
+ configuration.
+
+To write a coverage.py plug-in, create a module with a subclass of
+:class:`~coverage.CoveragePlugin`. You will override methods in your class to
+participate in various aspects of coverage.py's processing.
+Different types of plug-ins have to override different methods.
+
+Any plug-in can optionally implement :meth:`~coverage.CoveragePlugin.sys_info`
+to provide debugging information about their operation.
+
+Your module must also contain a ``coverage_init`` function that registers an
+instance of your plug-in class::
+
+ import coverage
+
+ class MyPlugin(coverage.CoveragePlugin):
+ ...
+
+ def coverage_init(reg, options):
+ reg.add_file_tracer(MyPlugin())
+
+You use the `reg` parameter passed to your ``coverage_init`` function to
+register your plug-in object. The registration method you call depends on
+what kind of plug-in it is.
+
+If your plug-in takes options, the `options` parameter is a dictionary of your
+plug-in's options from the coverage.py configuration file. Use them however
+you want to configure your object before registering it.
+
+Coverage.py will store its own information on your plug-in object, using
+attributes whose names start with ``_coverage_``. Don't be startled.
+
+.. warning::
+ Plug-ins are imported by coverage.py before it begins measuring code.
+ If you write a plugin in your own project, it might import your product
+ code before coverage.py can start measuring. This can result in your
+ own code being reported as missing.
+
+ One solution is to put your plugins in your project tree, but not in
+ your importable Python package.
+
+
+File Tracers
+============
+
+File tracers implement measurement support for non-Python files. File tracers
+implement the :meth:`~coverage.CoveragePlugin.file_tracer` method to claim
+files and the :meth:`~coverage.CoveragePlugin.file_reporter` method to report
+on those files.
+
+In your ``coverage_init`` function, use the ``add_file_tracer`` method to
+register your file tracer.
+
+
+Configurers
+===========
+
+.. versionadded:: 4.5
+
+Configurers modify the configuration of coverage.py during start-up.
+Configurers implement the :meth:`~coverage.CoveragePlugin.configure` method to
+change the configuration.
+
+In your ``coverage_init`` function, use the ``add_configurer`` method to
+register your configurer.
+
+"""
+
+from coverage import files
+from coverage.misc import contract, _needs_to_implement
+
+
+class CoveragePlugin(object):
+ """Base class for coverage.py plug-ins."""
+
+ def file_tracer(self, filename): # pylint: disable=unused-argument
+ """Get a :class:`FileTracer` object for a file.
+
+ Plug-in type: file tracer.
+
+ Every Python source file is offered to your plug-in to give it a chance
+ to take responsibility for tracing the file. If your plug-in can
+ handle the file, then return a :class:`FileTracer` object. Otherwise
+ return None.
+
+ There is no way to register your plug-in for particular files.
+ Instead, this method is invoked for all files, and the plug-in decides
+ whether it can trace the file or not. Be prepared for `filename` to
+ refer to all kinds of files that have nothing to do with your plug-in.
+
+ The file name will be a Python file being executed. There are two
+ broad categories of behavior for a plug-in, depending on the kind of
+ files your plug-in supports:
+
+ * Static file names: each of your original source files has been
+ converted into a distinct Python file. Your plug-in is invoked with
+ the Python file name, and it maps it back to its original source
+ file.
+
+ * Dynamic file names: all of your source files are executed by the same
+ Python file. In this case, your plug-in implements
+ :meth:`FileTracer.dynamic_source_filename` to provide the actual
+ source file for each execution frame.
+
+ `filename` is a string, the path to the file being considered. This is
+ the absolute real path to the file. If you are comparing to other
+ paths, be sure to take this into account.
+
+ Returns a :class:`FileTracer` object to use to trace `filename`, or
+ None if this plug-in cannot trace this file.
+
+ """
+ return None
+
+ def file_reporter(self, filename): # pylint: disable=unused-argument
+ """Get the :class:`FileReporter` class to use for a file.
+
+ Plug-in type: file tracer.
+
+ This will only be invoked if `filename` returns non-None from
+ :meth:`file_tracer`. It's an error to return None from this method.
+
+ Returns a :class:`FileReporter` object to use to report on `filename`.
+
+ """
+ _needs_to_implement(self, "file_reporter")
+
+ def find_executable_files(self, src_dir): # pylint: disable=unused-argument
+ """Yield all of the executable files in `src_dir`, recursively.
+
+ Plug-in type: file tracer.
+
+ Executability is a plug-in-specific property, but generally means files
+ which would have been considered for coverage analysis, had they been
+ included automatically.
+
+ Returns or yields a sequence of strings, the paths to files that could
+ have been executed, including files that had been executed.
+
+ """
+ return []
+
+ def configure(self, config):
+ """Modify the configuration of coverage.py.
+
+ Plug-in type: configurer.
+
+ This method is called during coverage.py start-up, to give your plug-in
+ a chance to change the configuration. The `config` parameter is an
+ object with :meth:`~coverage.Coverage.get_option` and
+ :meth:`~coverage.Coverage.set_option` methods. Do not call any other
+ methods on the `config` object.
+
+ """
+ pass
+
+ def sys_info(self):
+ """Get a list of information useful for debugging.
+
+ Plug-in type: any.
+
+ This method will be invoked for ``--debug=sys``. Your
+ plug-in can return any information it wants to be displayed.
+
+ Returns a list of pairs: `[(name, value), ...]`.
+
+ """
+ return []
+
+
+class FileTracer(object):
+ """Support needed for files during the execution phase.
+
+ File tracer plug-ins implement subclasses of FileTracer to return from
+ their :meth:`~CoveragePlugin.file_tracer` method.
+
+ You may construct this object from :meth:`CoveragePlugin.file_tracer` any
+ way you like. A natural choice would be to pass the file name given to
+ `file_tracer`.
+
+ `FileTracer` objects should only be created in the
+ :meth:`CoveragePlugin.file_tracer` method.
+
+ See :ref:`howitworks` for details of the different coverage.py phases.
+
+ """
+
+ def source_filename(self):
+ """The source file name for this file.
+
+ This may be any file name you like. A key responsibility of a plug-in
+ is to own the mapping from Python execution back to whatever source
+ file name was originally the source of the code.
+
+ See :meth:`CoveragePlugin.file_tracer` for details about static and
+ dynamic file names.
+
+ Returns the file name to credit with this execution.
+
+ """
+ _needs_to_implement(self, "source_filename")
+
+ def has_dynamic_source_filename(self):
+ """Does this FileTracer have dynamic source file names?
+
+ FileTracers can provide dynamically determined file names by
+ implementing :meth:`dynamic_source_filename`. Invoking that function
+ is expensive. To determine whether to invoke it, coverage.py uses the
+ result of this function to know if it needs to bother invoking
+ :meth:`dynamic_source_filename`.
+
+ See :meth:`CoveragePlugin.file_tracer` for details about static and
+ dynamic file names.
+
+ Returns True if :meth:`dynamic_source_filename` should be called to get
+ dynamic source file names.
+
+ """
+ return False
+
+ def dynamic_source_filename(self, filename, frame): # pylint: disable=unused-argument
+ """Get a dynamically computed source file name.
+
+ Some plug-ins need to compute the source file name dynamically for each
+ frame.
+
+ This function will not be invoked if
+ :meth:`has_dynamic_source_filename` returns False.
+
+ Returns the source file name for this frame, or None if this frame
+ shouldn't be measured.
+
+ """
+ return None
+
+ def line_number_range(self, frame):
+ """Get the range of source line numbers for a given a call frame.
+
+ The call frame is examined, and the source line number in the original
+ file is returned. The return value is a pair of numbers, the starting
+ line number and the ending line number, both inclusive. For example,
+ returning (5, 7) means that lines 5, 6, and 7 should be considered
+ executed.
+
+ This function might decide that the frame doesn't indicate any lines
+ from the source file were executed. Return (-1, -1) in this case to
+ tell coverage.py that no lines should be recorded for this frame.
+
+ """
+ lineno = frame.f_lineno
+ return lineno, lineno
+
+
+class FileReporter(object):
+ """Support needed for files during the analysis and reporting phases.
+
+ File tracer plug-ins implement a subclass of `FileReporter`, and return
+ instances from their :meth:`CoveragePlugin.file_reporter` method.
+
+ There are many methods here, but only :meth:`lines` is required, to provide
+ the set of executable lines in the file.
+
+ See :ref:`howitworks` for details of the different coverage.py phases.
+
+ """
+
+ def __init__(self, filename):
+ """Simple initialization of a `FileReporter`.
+
+ The `filename` argument is the path to the file being reported. This
+ will be available as the `.filename` attribute on the object. Other
+ method implementations on this base class rely on this attribute.
+
+ """
+ self.filename = filename
+
+ def __repr__(self):
+ return "<{0.__class__.__name__} filename={0.filename!r}>".format(self)
+
+ def relative_filename(self):
+ """Get the relative file name for this file.
+
+ This file path will be displayed in reports. The default
+ implementation will supply the actual project-relative file path. You
+ only need to supply this method if you have an unusual syntax for file
+ paths.
+
+ """
+ return files.relative_filename(self.filename)
+
+ @contract(returns='unicode')
+ def source(self):
+ """Get the source for the file.
+
+ Returns a Unicode string.
+
+ The base implementation simply reads the `self.filename` file and
+ decodes it as UTF8. Override this method if your file isn't readable
+ as a text file, or if you need other encoding support.
+
+ """
+ with open(self.filename, "rb") as f:
+ return f.read().decode("utf8")
+
+ def lines(self):
+ """Get the executable lines in this file.
+
+ Your plug-in must determine which lines in the file were possibly
+ executable. This method returns a set of those line numbers.
+
+ Returns a set of line numbers.
+
+ """
+ _needs_to_implement(self, "lines")
+
+ def excluded_lines(self):
+ """Get the excluded executable lines in this file.
+
+ Your plug-in can use any method it likes to allow the user to exclude
+ executable lines from consideration.
+
+ Returns a set of line numbers.
+
+ The base implementation returns the empty set.
+
+ """
+ return set()
+
+ def translate_lines(self, lines):
+ """Translate recorded lines into reported lines.
+
+ Some file formats will want to report lines slightly differently than
+ they are recorded. For example, Python records the last line of a
+ multi-line statement, but reports are nicer if they mention the first
+ line.
+
+ Your plug-in can optionally define this method to perform these kinds
+ of adjustment.
+
+ `lines` is a sequence of integers, the recorded line numbers.
+
+ Returns a set of integers, the adjusted line numbers.
+
+ The base implementation returns the numbers unchanged.
+
+ """
+ return set(lines)
+
+ def arcs(self):
+ """Get the executable arcs in this file.
+
+ To support branch coverage, your plug-in needs to be able to indicate
+ possible execution paths, as a set of line number pairs. Each pair is
+ a `(prev, next)` pair indicating that execution can transition from the
+ `prev` line number to the `next` line number.
+
+ Returns a set of pairs of line numbers. The default implementation
+ returns an empty set.
+
+ """
+ return set()
+
+ def no_branch_lines(self):
+ """Get the lines excused from branch coverage in this file.
+
+ Your plug-in can use any method it likes to allow the user to exclude
+ lines from consideration of branch coverage.
+
+ Returns a set of line numbers.
+
+ The base implementation returns the empty set.
+
+ """
+ return set()
+
+ def translate_arcs(self, arcs):
+ """Translate recorded arcs into reported arcs.
+
+ Similar to :meth:`translate_lines`, but for arcs. `arcs` is a set of
+ line number pairs.
+
+ Returns a set of line number pairs.
+
+ The default implementation returns `arcs` unchanged.
+
+ """
+ return arcs
+
+ def exit_counts(self):
+ """Get a count of exits from that each line.
+
+ To determine which lines are branches, coverage.py looks for lines that
+ have more than one exit. This function creates a dict mapping each
+ executable line number to a count of how many exits it has.
+
+ To be honest, this feels wrong, and should be refactored. Let me know
+ if you attempt to implement this method in your plug-in...
+
+ """
+ return {}
+
+ def missing_arc_description(self, start, end, executed_arcs=None): # pylint: disable=unused-argument
+ """Provide an English sentence describing a missing arc.
+
+ The `start` and `end` arguments are the line numbers of the missing
+ arc. Negative numbers indicate entering or exiting code objects.
+
+ The `executed_arcs` argument is a set of line number pairs, the arcs
+ that were executed in this file.
+
+ By default, this simply returns the string "Line {start} didn't jump
+ to {end}".
+
+ """
+ return "Line {start} didn't jump to line {end}".format(start=start, end=end)
+
+ def source_token_lines(self):
+ """Generate a series of tokenized lines, one for each line in `source`.
+
+ These tokens are used for syntax-colored reports.
+
+ Each line is a list of pairs, each pair is a token::
+
+ [('key', 'def'), ('ws', ' '), ('nam', 'hello'), ('op', '('), ... ]
+
+ Each pair has a token class, and the token text. The token classes
+ are:
+
+ * ``'com'``: a comment
+ * ``'key'``: a keyword
+ * ``'nam'``: a name, or identifier
+ * ``'num'``: a number
+ * ``'op'``: an operator
+ * ``'str'``: a string literal
+ * ``'txt'``: some other kind of text
+
+ If you concatenate all the token texts, and then join them with
+ newlines, you should have your original source back.
+
+ The default implementation simply returns each line tagged as
+ ``'txt'``.
+
+ """
+ for line in self.source().splitlines():
+ yield [('txt', line)]
+
+ # Annoying comparison operators. Py3k wants __lt__ etc, and Py2k needs all
+ # of them defined.
+
+ def __eq__(self, other):
+ return isinstance(other, FileReporter) and self.filename == other.filename
+
+ def __ne__(self, other):
+ return not (self == other)
+
+ def __lt__(self, other):
+ return self.filename < other.filename
+
+ def __le__(self, other):
+ return self.filename <= other.filename
+
+ def __gt__(self, other):
+ return self.filename > other.filename
+
+ def __ge__(self, other):
+ return self.filename >= other.filename
+
+ __hash__ = None # This object doesn't need to be hashed.
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/plugin_support.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/plugin_support.py
new file mode 100644
index 0000000000000000000000000000000000000000..c737a42c536b50695e1651724d22ae441750e8da
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/plugin_support.py
@@ -0,0 +1,257 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""Support for plugins."""
+
+import os
+import os.path
+import sys
+
+from coverage.misc import CoverageException, isolate_module
+from coverage.plugin import CoveragePlugin, FileTracer, FileReporter
+
+os = isolate_module(os)
+
+
+class Plugins(object):
+ """The currently loaded collection of coverage.py plugins."""
+
+ def __init__(self):
+ self.order = []
+ self.names = {}
+ self.file_tracers = []
+ self.configurers = []
+
+ self.current_module = None
+ self.debug = None
+
+ @classmethod
+ def load_plugins(cls, modules, config, debug=None):
+ """Load plugins from `modules`.
+
+ Returns a Plugins object with the loaded and configured plugins.
+
+ """
+ plugins = cls()
+ plugins.debug = debug
+
+ for module in modules:
+ plugins.current_module = module
+ __import__(module)
+ mod = sys.modules[module]
+
+ coverage_init = getattr(mod, "coverage_init", None)
+ if not coverage_init:
+ raise CoverageException(
+ "Plugin module %r didn't define a coverage_init function" % module
+ )
+
+ options = config.get_plugin_options(module)
+ coverage_init(plugins, options)
+
+ plugins.current_module = None
+ return plugins
+
+ def add_file_tracer(self, plugin):
+ """Add a file tracer plugin.
+
+ `plugin` is an instance of a third-party plugin class. It must
+ implement the :meth:`CoveragePlugin.file_tracer` method.
+
+ """
+ self._add_plugin(plugin, self.file_tracers)
+
+ def add_configurer(self, plugin):
+ """Add a configuring plugin.
+
+ `plugin` is an instance of a third-party plugin class. It must
+ implement the :meth:`CoveragePlugin.configure` method.
+
+ """
+ self._add_plugin(plugin, self.configurers)
+
+ def add_noop(self, plugin):
+ """Add a plugin that does nothing.
+
+ This is only useful for testing the plugin support.
+
+ """
+ self._add_plugin(plugin, None)
+
+ def _add_plugin(self, plugin, specialized):
+ """Add a plugin object.
+
+ `plugin` is a :class:`CoveragePlugin` instance to add. `specialized`
+ is a list to append the plugin to.
+
+ """
+ plugin_name = "%s.%s" % (self.current_module, plugin.__class__.__name__)
+ if self.debug and self.debug.should('plugin'):
+ self.debug.write("Loaded plugin %r: %r" % (self.current_module, plugin))
+ labelled = LabelledDebug("plugin %r" % (self.current_module,), self.debug)
+ plugin = DebugPluginWrapper(plugin, labelled)
+
+ # pylint: disable=attribute-defined-outside-init
+ plugin._coverage_plugin_name = plugin_name
+ plugin._coverage_enabled = True
+ self.order.append(plugin)
+ self.names[plugin_name] = plugin
+ if specialized is not None:
+ specialized.append(plugin)
+
+ def __nonzero__(self):
+ return bool(self.order)
+
+ __bool__ = __nonzero__
+
+ def __iter__(self):
+ return iter(self.order)
+
+ def get(self, plugin_name):
+ """Return a plugin by name."""
+ return self.names[plugin_name]
+
+
+class LabelledDebug(object):
+ """A Debug writer, but with labels for prepending to the messages."""
+
+ def __init__(self, label, debug, prev_labels=()):
+ self.labels = list(prev_labels) + [label]
+ self.debug = debug
+
+ def add_label(self, label):
+ """Add a label to the writer, and return a new `LabelledDebug`."""
+ return LabelledDebug(label, self.debug, self.labels)
+
+ def message_prefix(self):
+ """The prefix to use on messages, combining the labels."""
+ prefixes = self.labels + ['']
+ return ":\n".join(" "*i+label for i, label in enumerate(prefixes))
+
+ def write(self, message):
+ """Write `message`, but with the labels prepended."""
+ self.debug.write("%s%s" % (self.message_prefix(), message))
+
+
+class DebugPluginWrapper(CoveragePlugin):
+ """Wrap a plugin, and use debug to report on what it's doing."""
+
+ def __init__(self, plugin, debug):
+ super(DebugPluginWrapper, self).__init__()
+ self.plugin = plugin
+ self.debug = debug
+
+ def file_tracer(self, filename):
+ tracer = self.plugin.file_tracer(filename)
+ self.debug.write("file_tracer(%r) --> %r" % (filename, tracer))
+ if tracer:
+ debug = self.debug.add_label("file %r" % (filename,))
+ tracer = DebugFileTracerWrapper(tracer, debug)
+ return tracer
+
+ def file_reporter(self, filename):
+ reporter = self.plugin.file_reporter(filename)
+ self.debug.write("file_reporter(%r) --> %r" % (filename, reporter))
+ if reporter:
+ debug = self.debug.add_label("file %r" % (filename,))
+ reporter = DebugFileReporterWrapper(filename, reporter, debug)
+ return reporter
+
+ def sys_info(self):
+ return self.plugin.sys_info()
+
+
+class DebugFileTracerWrapper(FileTracer):
+ """A debugging `FileTracer`."""
+
+ def __init__(self, tracer, debug):
+ self.tracer = tracer
+ self.debug = debug
+
+ def _show_frame(self, frame):
+ """A short string identifying a frame, for debug messages."""
+ return "%s@%d" % (
+ os.path.basename(frame.f_code.co_filename),
+ frame.f_lineno,
+ )
+
+ def source_filename(self):
+ sfilename = self.tracer.source_filename()
+ self.debug.write("source_filename() --> %r" % (sfilename,))
+ return sfilename
+
+ def has_dynamic_source_filename(self):
+ has = self.tracer.has_dynamic_source_filename()
+ self.debug.write("has_dynamic_source_filename() --> %r" % (has,))
+ return has
+
+ def dynamic_source_filename(self, filename, frame):
+ dyn = self.tracer.dynamic_source_filename(filename, frame)
+ self.debug.write("dynamic_source_filename(%r, %s) --> %r" % (
+ filename, self._show_frame(frame), dyn,
+ ))
+ return dyn
+
+ def line_number_range(self, frame):
+ pair = self.tracer.line_number_range(frame)
+ self.debug.write("line_number_range(%s) --> %r" % (self._show_frame(frame), pair))
+ return pair
+
+
+class DebugFileReporterWrapper(FileReporter):
+ """A debugging `FileReporter`."""
+
+ def __init__(self, filename, reporter, debug):
+ super(DebugFileReporterWrapper, self).__init__(filename)
+ self.reporter = reporter
+ self.debug = debug
+
+ def relative_filename(self):
+ ret = self.reporter.relative_filename()
+ self.debug.write("relative_filename() --> %r" % (ret,))
+ return ret
+
+ def lines(self):
+ ret = self.reporter.lines()
+ self.debug.write("lines() --> %r" % (ret,))
+ return ret
+
+ def excluded_lines(self):
+ ret = self.reporter.excluded_lines()
+ self.debug.write("excluded_lines() --> %r" % (ret,))
+ return ret
+
+ def translate_lines(self, lines):
+ ret = self.reporter.translate_lines(lines)
+ self.debug.write("translate_lines(%r) --> %r" % (lines, ret))
+ return ret
+
+ def translate_arcs(self, arcs):
+ ret = self.reporter.translate_arcs(arcs)
+ self.debug.write("translate_arcs(%r) --> %r" % (arcs, ret))
+ return ret
+
+ def no_branch_lines(self):
+ ret = self.reporter.no_branch_lines()
+ self.debug.write("no_branch_lines() --> %r" % (ret,))
+ return ret
+
+ def exit_counts(self):
+ ret = self.reporter.exit_counts()
+ self.debug.write("exit_counts() --> %r" % (ret,))
+ return ret
+
+ def arcs(self):
+ ret = self.reporter.arcs()
+ self.debug.write("arcs() --> %r" % (ret,))
+ return ret
+
+ def source(self):
+ ret = self.reporter.source()
+ self.debug.write("source() --> %d chars" % (len(ret),))
+ return ret
+
+ def source_token_lines(self):
+ ret = list(self.reporter.source_token_lines())
+ self.debug.write("source_token_lines() --> %d tokens" % (len(ret),))
+ return ret
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/python.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/python.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b16acab8a32bc320a5d6f7f94f087a4b401e019
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/python.py
@@ -0,0 +1,244 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""Python source expertise for coverage.py"""
+
+import os.path
+import types
+import zipimport
+
+from coverage import env, files
+from coverage.misc import contract, expensive, isolate_module, join_regex
+from coverage.misc import CoverageException, NoSource
+from coverage.parser import PythonParser
+from coverage.phystokens import source_token_lines, source_encoding
+from coverage.plugin import FileReporter
+
+os = isolate_module(os)
+
+
+@contract(returns='bytes')
+def read_python_source(filename):
+ """Read the Python source text from `filename`.
+
+ Returns bytes.
+
+ """
+ with open(filename, "rb") as f:
+ source = f.read()
+
+ if env.IRONPYTHON:
+ # IronPython reads Unicode strings even for "rb" files.
+ source = bytes(source)
+
+ return source.replace(b"\r\n", b"\n").replace(b"\r", b"\n")
+
+
+@contract(returns='unicode')
+def get_python_source(filename):
+ """Return the source code, as unicode."""
+ base, ext = os.path.splitext(filename)
+ if ext == ".py" and env.WINDOWS:
+ exts = [".py", ".pyw"]
+ else:
+ exts = [ext]
+
+ for ext in exts:
+ try_filename = base + ext
+ if os.path.exists(try_filename):
+ # A regular text file: open it.
+ source = read_python_source(try_filename)
+ break
+
+ # Maybe it's in a zip file?
+ source = get_zip_bytes(try_filename)
+ if source is not None:
+ break
+ else:
+ # Couldn't find source.
+ exc_msg = "No source for code: '%s'.\n" % (filename,)
+ exc_msg += "Aborting report output, consider using -i."
+ raise NoSource(exc_msg)
+
+ # Replace \f because of http://bugs.python.org/issue19035
+ source = source.replace(b'\f', b' ')
+ source = source.decode(source_encoding(source), "replace")
+
+ # Python code should always end with a line with a newline.
+ if source and source[-1] != '\n':
+ source += '\n'
+
+ return source
+
+
+@contract(returns='bytes|None')
+def get_zip_bytes(filename):
+ """Get data from `filename` if it is a zip file path.
+
+ Returns the bytestring data read from the zip file, or None if no zip file
+ could be found or `filename` isn't in it. The data returned will be
+ an empty string if the file is empty.
+
+ """
+ markers = ['.zip'+os.sep, '.egg'+os.sep, '.pex'+os.sep]
+ for marker in markers:
+ if marker in filename:
+ parts = filename.split(marker)
+ try:
+ zi = zipimport.zipimporter(parts[0]+marker[:-1])
+ except zipimport.ZipImportError:
+ continue
+ try:
+ data = zi.get_data(parts[1])
+ except IOError:
+ continue
+ return data
+ return None
+
+
+def source_for_file(filename):
+ """Return the source file for `filename`.
+
+ Given a file name being traced, return the best guess as to the source
+ file to attribute it to.
+
+ """
+ if filename.endswith(".py"):
+ # .py files are themselves source files.
+ return filename
+
+ elif filename.endswith((".pyc", ".pyo")):
+ # Bytecode files probably have source files near them.
+ py_filename = filename[:-1]
+ if os.path.exists(py_filename):
+ # Found a .py file, use that.
+ return py_filename
+ if env.WINDOWS:
+ # On Windows, it could be a .pyw file.
+ pyw_filename = py_filename + "w"
+ if os.path.exists(pyw_filename):
+ return pyw_filename
+ # Didn't find source, but it's probably the .py file we want.
+ return py_filename
+
+ elif filename.endswith("$py.class"):
+ # Jython is easy to guess.
+ return filename[:-9] + ".py"
+
+ # No idea, just use the file name as-is.
+ return filename
+
+
+class PythonFileReporter(FileReporter):
+ """Report support for a Python file."""
+
+ def __init__(self, morf, coverage=None):
+ self.coverage = coverage
+
+ if hasattr(morf, '__file__') and morf.__file__:
+ filename = morf.__file__
+ elif isinstance(morf, types.ModuleType):
+ # A module should have had .__file__, otherwise we can't use it.
+ # This could be a PEP-420 namespace package.
+ raise CoverageException("Module {0} has no file".format(morf))
+ else:
+ filename = morf
+
+ filename = source_for_file(files.unicode_filename(filename))
+
+ super(PythonFileReporter, self).__init__(files.canonical_filename(filename))
+
+ if hasattr(morf, '__name__'):
+ name = morf.__name__.replace(".", os.sep)
+ if os.path.basename(filename).startswith('__init__.'):
+ name += os.sep + "__init__"
+ name += ".py"
+ name = files.unicode_filename(name)
+ else:
+ name = files.relative_filename(filename)
+ self.relname = name
+
+ self._source = None
+ self._parser = None
+ self._statements = None
+ self._excluded = None
+
+ def __repr__(self):
+ return "".format(self.filename)
+
+ @contract(returns='unicode')
+ def relative_filename(self):
+ return self.relname
+
+ @property
+ def parser(self):
+ """Lazily create a :class:`PythonParser`."""
+ if self._parser is None:
+ self._parser = PythonParser(
+ filename=self.filename,
+ exclude=self.coverage._exclude_regex('exclude'),
+ )
+ self._parser.parse_source()
+ return self._parser
+
+ def lines(self):
+ """Return the line numbers of statements in the file."""
+ return self.parser.statements
+
+ def excluded_lines(self):
+ """Return the line numbers of statements in the file."""
+ return self.parser.excluded
+
+ def translate_lines(self, lines):
+ return self.parser.translate_lines(lines)
+
+ def translate_arcs(self, arcs):
+ return self.parser.translate_arcs(arcs)
+
+ @expensive
+ def no_branch_lines(self):
+ no_branch = self.parser.lines_matching(
+ join_regex(self.coverage.config.partial_list),
+ join_regex(self.coverage.config.partial_always_list)
+ )
+ return no_branch
+
+ @expensive
+ def arcs(self):
+ return self.parser.arcs()
+
+ @expensive
+ def exit_counts(self):
+ return self.parser.exit_counts()
+
+ def missing_arc_description(self, start, end, executed_arcs=None):
+ return self.parser.missing_arc_description(start, end, executed_arcs)
+
+ @contract(returns='unicode')
+ def source(self):
+ if self._source is None:
+ self._source = get_python_source(self.filename)
+ return self._source
+
+ def should_be_python(self):
+ """Does it seem like this file should contain Python?
+
+ This is used to decide if a file reported as part of the execution of
+ a program was really likely to have contained Python in the first
+ place.
+
+ """
+ # Get the file extension.
+ _, ext = os.path.splitext(self.filename)
+
+ # Anything named *.py* should be Python.
+ if ext.startswith('.py'):
+ return True
+ # A file with no extension should be Python.
+ if not ext:
+ return True
+ # Everything else is probably not Python.
+ return False
+
+ def source_token_lines(self):
+ return source_token_lines(self.source())
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/pytracer.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/pytracer.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e70bab61ba3a661694383c6297275c02089a71d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/pytracer.py
@@ -0,0 +1,215 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""Raw data collector for coverage.py."""
+
+import atexit
+import dis
+import sys
+
+from coverage import env
+
+# We need the YIELD_VALUE opcode below, in a comparison-friendly form.
+YIELD_VALUE = dis.opmap['YIELD_VALUE']
+if env.PY2:
+ YIELD_VALUE = chr(YIELD_VALUE)
+
+
+class PyTracer(object):
+ """Python implementation of the raw data tracer."""
+
+ # Because of poor implementations of trace-function-manipulating tools,
+ # the Python trace function must be kept very simple. In particular, there
+ # must be only one function ever set as the trace function, both through
+ # sys.settrace, and as the return value from the trace function. Put
+ # another way, the trace function must always return itself. It cannot
+ # swap in other functions, or return None to avoid tracing a particular
+ # frame.
+ #
+ # The trace manipulator that introduced this restriction is DecoratorTools,
+ # which sets a trace function, and then later restores the pre-existing one
+ # by calling sys.settrace with a function it found in the current frame.
+ #
+ # Systems that use DecoratorTools (or similar trace manipulations) must use
+ # PyTracer to get accurate results. The command-line --timid argument is
+ # used to force the use of this tracer.
+
+ def __init__(self):
+ # Attributes set from the collector:
+ self.data = None
+ self.trace_arcs = False
+ self.should_trace = None
+ self.should_trace_cache = None
+ self.warn = None
+ # The threading module to use, if any.
+ self.threading = None
+
+ self.cur_file_dict = None
+ self.last_line = 0 # int, but uninitialized.
+ self.cur_file_name = None
+
+ self.data_stack = []
+ self.last_exc_back = None
+ self.last_exc_firstlineno = 0
+ self.thread = None
+ self.stopped = False
+ self._activity = False
+
+ self.in_atexit = False
+ # On exit, self.in_atexit = True
+ atexit.register(setattr, self, 'in_atexit', True)
+
+ def __repr__(self):
+ return "".format(
+ id(self),
+ sum(len(v) for v in self.data.values()),
+ len(self.data),
+ )
+
+ def log(self, marker, *args):
+ """For hard-core logging of what this tracer is doing."""
+ with open("/tmp/debug_trace.txt", "a") as f:
+ f.write("{} {:x}.{:x}[{}] {:x} {}\n".format(
+ marker,
+ id(self),
+ self.thread.ident,
+ len(self.data_stack),
+ self.threading.currentThread().ident,
+ " ".join(map(str, args))
+ ))
+
+ def _trace(self, frame, event, arg_unused):
+ """The trace function passed to sys.settrace."""
+
+ #self.log(":", frame.f_code.co_filename, frame.f_lineno, event)
+
+ if (self.stopped and sys.gettrace() == self._trace):
+ # The PyTrace.stop() method has been called, possibly by another
+ # thread, let's deactivate ourselves now.
+ #self.log("X", frame.f_code.co_filename, frame.f_lineno)
+ sys.settrace(None)
+ return None
+
+ if self.last_exc_back:
+ if frame == self.last_exc_back:
+ # Someone forgot a return event.
+ if self.trace_arcs and self.cur_file_dict:
+ pair = (self.last_line, -self.last_exc_firstlineno)
+ self.cur_file_dict[pair] = None
+ self.cur_file_dict, self.cur_file_name, self.last_line = self.data_stack.pop()
+ self.last_exc_back = None
+
+ if event == 'call':
+ # Entering a new function context. Decide if we should trace
+ # in this file.
+ self._activity = True
+ self.data_stack.append((self.cur_file_dict, self.cur_file_name, self.last_line))
+ filename = frame.f_code.co_filename
+ self.cur_file_name = filename
+ disp = self.should_trace_cache.get(filename)
+ if disp is None:
+ disp = self.should_trace(filename, frame)
+ self.should_trace_cache[filename] = disp
+
+ self.cur_file_dict = None
+ if disp.trace:
+ tracename = disp.source_filename
+ if tracename not in self.data:
+ self.data[tracename] = {}
+ self.cur_file_dict = self.data[tracename]
+ # The call event is really a "start frame" event, and happens for
+ # function calls and re-entering generators. The f_lasti field is
+ # -1 for calls, and a real offset for generators. Use <0 as the
+ # line number for calls, and the real line number for generators.
+ if getattr(frame, 'f_lasti', -1) < 0:
+ self.last_line = -frame.f_code.co_firstlineno
+ else:
+ self.last_line = frame.f_lineno
+ elif event == 'line':
+ # Record an executed line.
+ if self.cur_file_dict is not None:
+ lineno = frame.f_lineno
+ #if frame.f_code.co_filename != self.cur_file_name:
+ # self.log("*", frame.f_code.co_filename, self.cur_file_name, lineno)
+ if self.trace_arcs:
+ self.cur_file_dict[(self.last_line, lineno)] = None
+ else:
+ self.cur_file_dict[lineno] = None
+ self.last_line = lineno
+ elif event == 'return':
+ if self.trace_arcs and self.cur_file_dict:
+ # Record an arc leaving the function, but beware that a
+ # "return" event might just mean yielding from a generator.
+ # Jython seems to have an empty co_code, so just assume return.
+ code = frame.f_code.co_code
+ if (not code) or code[frame.f_lasti] != YIELD_VALUE:
+ first = frame.f_code.co_firstlineno
+ self.cur_file_dict[(self.last_line, -first)] = None
+ # Leaving this function, pop the filename stack.
+ self.cur_file_dict, self.cur_file_name, self.last_line = self.data_stack.pop()
+ elif event == 'exception':
+ self.last_exc_back = frame.f_back
+ self.last_exc_firstlineno = frame.f_code.co_firstlineno
+ return self._trace
+
+ def start(self):
+ """Start this Tracer.
+
+ Return a Python function suitable for use with sys.settrace().
+
+ """
+ self.stopped = False
+ if self.threading:
+ if self.thread is None:
+ self.thread = self.threading.currentThread()
+ else:
+ if self.thread.ident != self.threading.currentThread().ident:
+ # Re-starting from a different thread!? Don't set the trace
+ # function, but we are marked as running again, so maybe it
+ # will be ok?
+ #self.log("~", "starting on different threads")
+ return self._trace
+
+ sys.settrace(self._trace)
+ return self._trace
+
+ def stop(self):
+ """Stop this Tracer."""
+ # Get the activate tracer callback before setting the stop flag to be
+ # able to detect if the tracer was changed prior to stopping it.
+ tf = sys.gettrace()
+
+ # Set the stop flag. The actual call to sys.settrace(None) will happen
+ # in the self._trace callback itself to make sure to call it from the
+ # right thread.
+ self.stopped = True
+
+ if self.threading and self.thread.ident != self.threading.currentThread().ident:
+ # Called on a different thread than started us: we can't unhook
+ # ourselves, but we've set the flag that we should stop, so we
+ # won't do any more tracing.
+ #self.log("~", "stopping on different threads")
+ return
+
+ if self.warn:
+ # PyPy clears the trace function before running atexit functions,
+ # so don't warn if we are in atexit on PyPy and the trace function
+ # has changed to None.
+ dont_warn = (env.PYPY and env.PYPYVERSION >= (5, 4) and self.in_atexit and tf is None)
+ if (not dont_warn) and tf != self._trace:
+ self.warn(
+ "Trace function changed, measurement is likely wrong: %r" % (tf,),
+ slug="trace-changed",
+ )
+
+ def activity(self):
+ """Has there been any activity?"""
+ return self._activity
+
+ def reset_activity(self):
+ """Reset the activity() flag."""
+ self._activity = False
+
+ def get_stats(self):
+ """Return a dictionary of statistics, or None."""
+ return None
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/report.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/report.py
new file mode 100644
index 0000000000000000000000000000000000000000..b46086339f628f33996849932fa1e1214bf18eb6
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/report.py
@@ -0,0 +1,104 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""Reporter foundation for coverage.py."""
+
+import os
+import warnings
+
+from coverage.files import prep_patterns, FnmatchMatcher
+from coverage.misc import CoverageException, NoSource, NotPython, isolate_module
+
+os = isolate_module(os)
+
+
+class Reporter(object):
+ """A base class for all reporters."""
+
+ def __init__(self, coverage, config):
+ """Create a reporter.
+
+ `coverage` is the coverage instance. `config` is an instance of
+ CoverageConfig, for controlling all sorts of behavior.
+
+ """
+ self.coverage = coverage
+ self.config = config
+
+ # The directory into which to place the report, used by some derived
+ # classes.
+ self.directory = None
+
+ # Our method find_file_reporters used to set an attribute that other
+ # code could read. That's been refactored away, but some third parties
+ # were using that attribute. We'll continue to support it in a noisy
+ # way for now.
+ self._file_reporters = []
+
+ @property
+ def file_reporters(self):
+ """Keep .file_reporters working for private-grabbing tools."""
+ warnings.warn(
+ "Report.file_reporters will no longer be available in Coverage.py 4.2",
+ DeprecationWarning,
+ )
+ return self._file_reporters
+
+ def find_file_reporters(self, morfs):
+ """Find the FileReporters we'll report on.
+
+ `morfs` is a list of modules or file names.
+
+ Returns a list of FileReporters.
+
+ """
+ reporters = self.coverage._get_file_reporters(morfs)
+
+ if self.config.report_include:
+ matcher = FnmatchMatcher(prep_patterns(self.config.report_include))
+ reporters = [fr for fr in reporters if matcher.match(fr.filename)]
+
+ if self.config.report_omit:
+ matcher = FnmatchMatcher(prep_patterns(self.config.report_omit))
+ reporters = [fr for fr in reporters if not matcher.match(fr.filename)]
+
+ self._file_reporters = sorted(reporters)
+ return self._file_reporters
+
+ def report_files(self, report_fn, morfs, directory=None):
+ """Run a reporting function on a number of morfs.
+
+ `report_fn` is called for each relative morf in `morfs`. It is called
+ as::
+
+ report_fn(file_reporter, analysis)
+
+ where `file_reporter` is the `FileReporter` for the morf, and
+ `analysis` is the `Analysis` for the morf.
+
+ """
+ file_reporters = self.find_file_reporters(morfs)
+
+ if not file_reporters:
+ raise CoverageException("No data to report.")
+
+ self.directory = directory
+ if self.directory and not os.path.exists(self.directory):
+ os.makedirs(self.directory)
+
+ for fr in file_reporters:
+ try:
+ report_fn(fr, self.coverage._analyze(fr))
+ except NoSource:
+ if not self.config.ignore_errors:
+ raise
+ except NotPython:
+ # Only report errors for .py files, and only if we didn't
+ # explicitly suppress those errors.
+ # NotPython is only raised by PythonFileReporter, which has a
+ # should_be_python() method.
+ if fr.should_be_python():
+ if self.config.ignore_errors:
+ self.coverage._warn("Could not parse Python file {0}".format(fr.filename))
+ else:
+ raise
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/results.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/results.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f84a689f6b7aa12ce3b863d45dc2465562583c0
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/results.py
@@ -0,0 +1,289 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""Results of coverage measurement."""
+
+import collections
+
+from coverage.backward import iitems
+from coverage.misc import contract, format_lines, SimpleRepr
+
+
+class Analysis(object):
+ """The results of analyzing a FileReporter."""
+
+ def __init__(self, data, file_reporter):
+ self.data = data
+ self.file_reporter = file_reporter
+ self.filename = self.file_reporter.filename
+ self.statements = self.file_reporter.lines()
+ self.excluded = self.file_reporter.excluded_lines()
+
+ # Identify missing statements.
+ executed = self.data.lines(self.filename) or []
+ executed = self.file_reporter.translate_lines(executed)
+ self.missing = self.statements - executed
+
+ if self.data.has_arcs():
+ self._arc_possibilities = sorted(self.file_reporter.arcs())
+ self.exit_counts = self.file_reporter.exit_counts()
+ self.no_branch = self.file_reporter.no_branch_lines()
+ n_branches = self.total_branches()
+ mba = self.missing_branch_arcs()
+ n_partial_branches = sum(len(v) for k,v in iitems(mba) if k not in self.missing)
+ n_missing_branches = sum(len(v) for k,v in iitems(mba))
+ else:
+ self._arc_possibilities = []
+ self.exit_counts = {}
+ self.no_branch = set()
+ n_branches = n_partial_branches = n_missing_branches = 0
+
+ self.numbers = Numbers(
+ n_files=1,
+ n_statements=len(self.statements),
+ n_excluded=len(self.excluded),
+ n_missing=len(self.missing),
+ n_branches=n_branches,
+ n_partial_branches=n_partial_branches,
+ n_missing_branches=n_missing_branches,
+ )
+
+ def missing_formatted(self):
+ """The missing line numbers, formatted nicely.
+
+ Returns a string like "1-2, 5-11, 13-14".
+
+ """
+ return format_lines(self.statements, self.missing)
+
+ def has_arcs(self):
+ """Were arcs measured in this result?"""
+ return self.data.has_arcs()
+
+ def arc_possibilities(self):
+ """Returns a sorted list of the arcs in the code."""
+ return self._arc_possibilities
+
+ def arcs_executed(self):
+ """Returns a sorted list of the arcs actually executed in the code."""
+ executed = self.data.arcs(self.filename) or []
+ executed = self.file_reporter.translate_arcs(executed)
+ return sorted(executed)
+
+ def arcs_missing(self):
+ """Returns a sorted list of the arcs in the code not executed."""
+ possible = self.arc_possibilities()
+ executed = self.arcs_executed()
+ missing = (
+ p for p in possible
+ if p not in executed
+ and p[0] not in self.no_branch
+ )
+ return sorted(missing)
+
+ def arcs_missing_formatted(self):
+ """The missing branch arcs, formatted nicely.
+
+ Returns a string like "1->2, 1->3, 16->20". Omits any mention of
+ branches from missing lines, so if line 17 is missing, then 17->18
+ won't be included.
+
+ """
+ arcs = self.missing_branch_arcs()
+ missing = self.missing
+ line_exits = sorted(iitems(arcs))
+ pairs = []
+ for line, exits in line_exits:
+ for ex in sorted(exits):
+ if line not in missing:
+ pairs.append("%d->%s" % (line, (ex if ex > 0 else "exit")))
+ return ', '.join(pairs)
+
+ def arcs_unpredicted(self):
+ """Returns a sorted list of the executed arcs missing from the code."""
+ possible = self.arc_possibilities()
+ executed = self.arcs_executed()
+ # Exclude arcs here which connect a line to itself. They can occur
+ # in executed data in some cases. This is where they can cause
+ # trouble, and here is where it's the least burden to remove them.
+ # Also, generators can somehow cause arcs from "enter" to "exit", so
+ # make sure we have at least one positive value.
+ unpredicted = (
+ e for e in executed
+ if e not in possible
+ and e[0] != e[1]
+ and (e[0] > 0 or e[1] > 0)
+ )
+ return sorted(unpredicted)
+
+ def branch_lines(self):
+ """Returns a list of line numbers that have more than one exit."""
+ return [l1 for l1,count in iitems(self.exit_counts) if count > 1]
+
+ def total_branches(self):
+ """How many total branches are there?"""
+ return sum(count for count in self.exit_counts.values() if count > 1)
+
+ def missing_branch_arcs(self):
+ """Return arcs that weren't executed from branch lines.
+
+ Returns {l1:[l2a,l2b,...], ...}
+
+ """
+ missing = self.arcs_missing()
+ branch_lines = set(self.branch_lines())
+ mba = collections.defaultdict(list)
+ for l1, l2 in missing:
+ if l1 in branch_lines:
+ mba[l1].append(l2)
+ return mba
+
+ def branch_stats(self):
+ """Get stats about branches.
+
+ Returns a dict mapping line numbers to a tuple:
+ (total_exits, taken_exits).
+ """
+
+ missing_arcs = self.missing_branch_arcs()
+ stats = {}
+ for lnum in self.branch_lines():
+ exits = self.exit_counts[lnum]
+ try:
+ missing = len(missing_arcs[lnum])
+ except KeyError:
+ missing = 0
+ stats[lnum] = (exits, exits - missing)
+ return stats
+
+
+class Numbers(SimpleRepr):
+ """The numerical results of measuring coverage.
+
+ This holds the basic statistics from `Analysis`, and is used to roll
+ up statistics across files.
+
+ """
+ # A global to determine the precision on coverage percentages, the number
+ # of decimal places.
+ _precision = 0
+ _near0 = 1.0 # These will change when _precision is changed.
+ _near100 = 99.0
+
+ def __init__(self, n_files=0, n_statements=0, n_excluded=0, n_missing=0,
+ n_branches=0, n_partial_branches=0, n_missing_branches=0
+ ):
+ self.n_files = n_files
+ self.n_statements = n_statements
+ self.n_excluded = n_excluded
+ self.n_missing = n_missing
+ self.n_branches = n_branches
+ self.n_partial_branches = n_partial_branches
+ self.n_missing_branches = n_missing_branches
+
+ def init_args(self):
+ """Return a list for __init__(*args) to recreate this object."""
+ return [
+ self.n_files, self.n_statements, self.n_excluded, self.n_missing,
+ self.n_branches, self.n_partial_branches, self.n_missing_branches,
+ ]
+
+ @classmethod
+ def set_precision(cls, precision):
+ """Set the number of decimal places used to report percentages."""
+ assert 0 <= precision < 10
+ cls._precision = precision
+ cls._near0 = 1.0 / 10**precision
+ cls._near100 = 100.0 - cls._near0
+
+ @property
+ def n_executed(self):
+ """Returns the number of executed statements."""
+ return self.n_statements - self.n_missing
+
+ @property
+ def n_executed_branches(self):
+ """Returns the number of executed branches."""
+ return self.n_branches - self.n_missing_branches
+
+ @property
+ def pc_covered(self):
+ """Returns a single percentage value for coverage."""
+ if self.n_statements > 0:
+ numerator, denominator = self.ratio_covered
+ pc_cov = (100.0 * numerator) / denominator
+ else:
+ pc_cov = 100.0
+ return pc_cov
+
+ @property
+ def pc_covered_str(self):
+ """Returns the percent covered, as a string, without a percent sign.
+
+ Note that "0" is only returned when the value is truly zero, and "100"
+ is only returned when the value is truly 100. Rounding can never
+ result in either "0" or "100".
+
+ """
+ pc = self.pc_covered
+ if 0 < pc < self._near0:
+ pc = self._near0
+ elif self._near100 < pc < 100:
+ pc = self._near100
+ else:
+ pc = round(pc, self._precision)
+ return "%.*f" % (self._precision, pc)
+
+ @classmethod
+ def pc_str_width(cls):
+ """How many characters wide can pc_covered_str be?"""
+ width = 3 # "100"
+ if cls._precision > 0:
+ width += 1 + cls._precision
+ return width
+
+ @property
+ def ratio_covered(self):
+ """Return a numerator and denominator for the coverage ratio."""
+ numerator = self.n_executed + self.n_executed_branches
+ denominator = self.n_statements + self.n_branches
+ return numerator, denominator
+
+ def __add__(self, other):
+ nums = Numbers()
+ nums.n_files = self.n_files + other.n_files
+ nums.n_statements = self.n_statements + other.n_statements
+ nums.n_excluded = self.n_excluded + other.n_excluded
+ nums.n_missing = self.n_missing + other.n_missing
+ nums.n_branches = self.n_branches + other.n_branches
+ nums.n_partial_branches = (
+ self.n_partial_branches + other.n_partial_branches
+ )
+ nums.n_missing_branches = (
+ self.n_missing_branches + other.n_missing_branches
+ )
+ return nums
+
+ def __radd__(self, other):
+ # Implementing 0+Numbers allows us to sum() a list of Numbers.
+ if other == 0:
+ return self
+ return NotImplemented
+
+
+@contract(total='number', fail_under='number', precision=int, returns=bool)
+def should_fail_under(total, fail_under, precision):
+ """Determine if a total should fail due to fail-under.
+
+ `total` is a float, the coverage measurement total. `fail_under` is the
+ fail_under setting to compare with. `precision` is the number of digits
+ to consider after the decimal point.
+
+ Returns True if the total should fail.
+
+ """
+ # Special case for fail_under=100, it must really be 100.
+ if fail_under == 100.0 and total != 100.0:
+ return True
+
+ return round(total, precision) < fail_under
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/summary.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/summary.py
new file mode 100644
index 0000000000000000000000000000000000000000..271b648a8e0f5faa979720932ffab5f040309366
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/summary.py
@@ -0,0 +1,163 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""Summary reporting"""
+
+import sys
+
+from coverage import env
+from coverage.report import Reporter
+from coverage.results import Numbers
+from coverage.misc import NotPython, CoverageException, output_encoding, StopEverything
+
+
+class SummaryReporter(Reporter):
+ """A reporter for writing the summary report."""
+
+ def __init__(self, coverage, config):
+ super(SummaryReporter, self).__init__(coverage, config)
+ self.branches = coverage.data.has_arcs()
+
+ def report(self, morfs, outfile=None):
+ """Writes a report summarizing coverage statistics per module.
+
+ `outfile` is a file object to write the summary to. It must be opened
+ for native strings (bytes on Python 2, Unicode on Python 3).
+
+ """
+ if outfile is None:
+ outfile = sys.stdout
+
+ def writeout(line):
+ """Write a line to the output, adding a newline."""
+ if env.PY2:
+ line = line.encode(output_encoding())
+ outfile.write(line.rstrip())
+ outfile.write("\n")
+
+ fr_analysis = []
+ skipped_count = 0
+ total = Numbers()
+
+ fmt_err = u"%s %s: %s"
+
+ for fr in self.find_file_reporters(morfs):
+ try:
+ analysis = self.coverage._analyze(fr)
+ nums = analysis.numbers
+ total += nums
+
+ if self.config.skip_covered:
+ # Don't report on 100% files.
+ no_missing_lines = (nums.n_missing == 0)
+ no_missing_branches = (nums.n_partial_branches == 0)
+ if no_missing_lines and no_missing_branches:
+ skipped_count += 1
+ continue
+ fr_analysis.append((fr, analysis))
+ except StopEverything:
+ # Don't report this on single files, it's a systemic problem.
+ raise
+ except Exception:
+ report_it = not self.config.ignore_errors
+ if report_it:
+ typ, msg = sys.exc_info()[:2]
+ # NotPython is only raised by PythonFileReporter, which has a
+ # should_be_python() method.
+ if issubclass(typ, NotPython) and not fr.should_be_python():
+ report_it = False
+ if report_it:
+ writeout(fmt_err % (fr.relative_filename(), typ.__name__, msg))
+
+ # Prepare the formatting strings, header, and column sorting.
+ max_name = max([len(fr.relative_filename()) for (fr, analysis) in fr_analysis] + [5])
+ fmt_name = u"%%- %ds " % max_name
+ fmt_skip_covered = u"\n%s file%s skipped due to complete coverage."
+
+ header = (fmt_name % "Name") + u" Stmts Miss"
+ fmt_coverage = fmt_name + u"%6d %6d"
+ if self.branches:
+ header += u" Branch BrPart"
+ fmt_coverage += u" %6d %6d"
+ width100 = Numbers.pc_str_width()
+ header += u"%*s" % (width100+4, "Cover")
+ fmt_coverage += u"%%%ds%%%%" % (width100+3,)
+ if self.config.show_missing:
+ header += u" Missing"
+ fmt_coverage += u" %s"
+ rule = u"-" * len(header)
+
+ column_order = dict(name=0, stmts=1, miss=2, cover=-1)
+ if self.branches:
+ column_order.update(dict(branch=3, brpart=4))
+
+ # Write the header
+ writeout(header)
+ writeout(rule)
+
+ # `lines` is a list of pairs, (line text, line values). The line text
+ # is a string that will be printed, and line values is a tuple of
+ # sortable values.
+ lines = []
+
+ for (fr, analysis) in fr_analysis:
+ try:
+ nums = analysis.numbers
+
+ args = (fr.relative_filename(), nums.n_statements, nums.n_missing)
+ if self.branches:
+ args += (nums.n_branches, nums.n_partial_branches)
+ args += (nums.pc_covered_str,)
+ if self.config.show_missing:
+ missing_fmtd = analysis.missing_formatted()
+ if self.branches:
+ branches_fmtd = analysis.arcs_missing_formatted()
+ if branches_fmtd:
+ if missing_fmtd:
+ missing_fmtd += ", "
+ missing_fmtd += branches_fmtd
+ args += (missing_fmtd,)
+ text = fmt_coverage % args
+ # Add numeric percent coverage so that sorting makes sense.
+ args += (nums.pc_covered,)
+ lines.append((text, args))
+ except Exception:
+ report_it = not self.config.ignore_errors
+ if report_it:
+ typ, msg = sys.exc_info()[:2]
+ # NotPython is only raised by PythonFileReporter, which has a
+ # should_be_python() method.
+ if typ is NotPython and not fr.should_be_python():
+ report_it = False
+ if report_it:
+ writeout(fmt_err % (fr.relative_filename(), typ.__name__, msg))
+
+ # Sort the lines and write them out.
+ if getattr(self.config, 'sort', None):
+ position = column_order.get(self.config.sort.lower())
+ if position is None:
+ raise CoverageException("Invalid sorting option: {0!r}".format(self.config.sort))
+ lines.sort(key=lambda l: (l[1][position], l[0]))
+
+ for line in lines:
+ writeout(line[0])
+
+ # Write a TOTAl line if we had more than one file.
+ if total.n_files > 1:
+ writeout(rule)
+ args = ("TOTAL", total.n_statements, total.n_missing)
+ if self.branches:
+ args += (total.n_branches, total.n_partial_branches)
+ args += (total.pc_covered_str,)
+ if self.config.show_missing:
+ args += ("",)
+ writeout(fmt_coverage % args)
+
+ # Write other final lines.
+ if not total.n_files and not skipped_count:
+ raise CoverageException("No data to report.")
+
+ if self.config.skip_covered and skipped_count:
+ writeout(fmt_skip_covered % (skipped_count, 's' if skipped_count > 1 else ''))
+
+ return total.n_statements and total.pc_covered
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/templite.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/templite.py
new file mode 100644
index 0000000000000000000000000000000000000000..9944695a0dd77413c779ab7f117bace067b09d42
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/templite.py
@@ -0,0 +1,291 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""A simple Python template renderer, for a nano-subset of Django syntax.
+
+For a detailed discussion of this code, see this chapter from 500 Lines:
+http://aosabook.org/en/500L/a-template-engine.html
+
+"""
+
+# Coincidentally named the same as http://code.activestate.com/recipes/496702/
+
+import re
+
+from coverage import env
+
+
+class TempliteSyntaxError(ValueError):
+ """Raised when a template has a syntax error."""
+ pass
+
+
+class TempliteValueError(ValueError):
+ """Raised when an expression won't evaluate in a template."""
+ pass
+
+
+class CodeBuilder(object):
+ """Build source code conveniently."""
+
+ def __init__(self, indent=0):
+ self.code = []
+ self.indent_level = indent
+
+ def __str__(self):
+ return "".join(str(c) for c in self.code)
+
+ def add_line(self, line):
+ """Add a line of source to the code.
+
+ Indentation and newline will be added for you, don't provide them.
+
+ """
+ self.code.extend([" " * self.indent_level, line, "\n"])
+
+ def add_section(self):
+ """Add a section, a sub-CodeBuilder."""
+ section = CodeBuilder(self.indent_level)
+ self.code.append(section)
+ return section
+
+ INDENT_STEP = 4 # PEP8 says so!
+
+ def indent(self):
+ """Increase the current indent for following lines."""
+ self.indent_level += self.INDENT_STEP
+
+ def dedent(self):
+ """Decrease the current indent for following lines."""
+ self.indent_level -= self.INDENT_STEP
+
+ def get_globals(self):
+ """Execute the code, and return a dict of globals it defines."""
+ # A check that the caller really finished all the blocks they started.
+ assert self.indent_level == 0
+ # Get the Python source as a single string.
+ python_source = str(self)
+ # Execute the source, defining globals, and return them.
+ global_namespace = {}
+ exec(python_source, global_namespace)
+ return global_namespace
+
+
+class Templite(object):
+ """A simple template renderer, for a nano-subset of Django syntax.
+
+ Supported constructs are extended variable access::
+
+ {{var.modifier.modifier|filter|filter}}
+
+ loops::
+
+ {% for var in list %}...{% endfor %}
+
+ and ifs::
+
+ {% if var %}...{% endif %}
+
+ Comments are within curly-hash markers::
+
+ {# This will be ignored #}
+
+ Any of these constructs can have a hypen at the end (`-}}`, `-%}`, `-#}`),
+ which will collapse the whitespace following the tag.
+
+ Construct a Templite with the template text, then use `render` against a
+ dictionary context to create a finished string::
+
+ templite = Templite('''
+ Hello {{name|upper}}!
+ {% for topic in topics %}
+ You are interested in {{topic}}.
+ {% endif %}
+ ''',
+ {'upper': str.upper},
+ )
+ text = templite.render({
+ 'name': "Ned",
+ 'topics': ['Python', 'Geometry', 'Juggling'],
+ })
+
+ """
+ def __init__(self, text, *contexts):
+ """Construct a Templite with the given `text`.
+
+ `contexts` are dictionaries of values to use for future renderings.
+ These are good for filters and global values.
+
+ """
+ self.context = {}
+ for context in contexts:
+ self.context.update(context)
+
+ self.all_vars = set()
+ self.loop_vars = set()
+
+ # We construct a function in source form, then compile it and hold onto
+ # it, and execute it to render the template.
+ code = CodeBuilder()
+
+ code.add_line("def render_function(context, do_dots):")
+ code.indent()
+ vars_code = code.add_section()
+ code.add_line("result = []")
+ code.add_line("append_result = result.append")
+ code.add_line("extend_result = result.extend")
+ if env.PY2:
+ code.add_line("to_str = unicode")
+ else:
+ code.add_line("to_str = str")
+
+ buffered = []
+
+ def flush_output():
+ """Force `buffered` to the code builder."""
+ if len(buffered) == 1:
+ code.add_line("append_result(%s)" % buffered[0])
+ elif len(buffered) > 1:
+ code.add_line("extend_result([%s])" % ", ".join(buffered))
+ del buffered[:]
+
+ ops_stack = []
+
+ # Split the text to form a list of tokens.
+ tokens = re.split(r"(?s)({{.*?}}|{%.*?%}|{#.*?#})", text)
+
+ squash = False
+
+ for token in tokens:
+ if token.startswith('{'):
+ start, end = 2, -2
+ squash = (token[-3] == '-')
+ if squash:
+ end = -3
+
+ if token.startswith('{#'):
+ # Comment: ignore it and move on.
+ continue
+ elif token.startswith('{{'):
+ # An expression to evaluate.
+ expr = self._expr_code(token[start:end].strip())
+ buffered.append("to_str(%s)" % expr)
+ else:
+ # token.startswith('{%')
+ # Action tag: split into words and parse further.
+ flush_output()
+
+ words = token[start:end].strip().split()
+ if words[0] == 'if':
+ # An if statement: evaluate the expression to determine if.
+ if len(words) != 2:
+ self._syntax_error("Don't understand if", token)
+ ops_stack.append('if')
+ code.add_line("if %s:" % self._expr_code(words[1]))
+ code.indent()
+ elif words[0] == 'for':
+ # A loop: iterate over expression result.
+ if len(words) != 4 or words[2] != 'in':
+ self._syntax_error("Don't understand for", token)
+ ops_stack.append('for')
+ self._variable(words[1], self.loop_vars)
+ code.add_line(
+ "for c_%s in %s:" % (
+ words[1],
+ self._expr_code(words[3])
+ )
+ )
+ code.indent()
+ elif words[0].startswith('end'):
+ # Endsomething. Pop the ops stack.
+ if len(words) != 1:
+ self._syntax_error("Don't understand end", token)
+ end_what = words[0][3:]
+ if not ops_stack:
+ self._syntax_error("Too many ends", token)
+ start_what = ops_stack.pop()
+ if start_what != end_what:
+ self._syntax_error("Mismatched end tag", end_what)
+ code.dedent()
+ else:
+ self._syntax_error("Don't understand tag", words[0])
+ else:
+ # Literal content. If it isn't empty, output it.
+ if squash:
+ token = token.lstrip()
+ if token:
+ buffered.append(repr(token))
+
+ if ops_stack:
+ self._syntax_error("Unmatched action tag", ops_stack[-1])
+
+ flush_output()
+
+ for var_name in self.all_vars - self.loop_vars:
+ vars_code.add_line("c_%s = context[%r]" % (var_name, var_name))
+
+ code.add_line('return "".join(result)')
+ code.dedent()
+ self._render_function = code.get_globals()['render_function']
+
+ def _expr_code(self, expr):
+ """Generate a Python expression for `expr`."""
+ if "|" in expr:
+ pipes = expr.split("|")
+ code = self._expr_code(pipes[0])
+ for func in pipes[1:]:
+ self._variable(func, self.all_vars)
+ code = "c_%s(%s)" % (func, code)
+ elif "." in expr:
+ dots = expr.split(".")
+ code = self._expr_code(dots[0])
+ args = ", ".join(repr(d) for d in dots[1:])
+ code = "do_dots(%s, %s)" % (code, args)
+ else:
+ self._variable(expr, self.all_vars)
+ code = "c_%s" % expr
+ return code
+
+ def _syntax_error(self, msg, thing):
+ """Raise a syntax error using `msg`, and showing `thing`."""
+ raise TempliteSyntaxError("%s: %r" % (msg, thing))
+
+ def _variable(self, name, vars_set):
+ """Track that `name` is used as a variable.
+
+ Adds the name to `vars_set`, a set of variable names.
+
+ Raises an syntax error if `name` is not a valid name.
+
+ """
+ if not re.match(r"[_a-zA-Z][_a-zA-Z0-9]*$", name):
+ self._syntax_error("Not a valid name", name)
+ vars_set.add(name)
+
+ def render(self, context=None):
+ """Render this template by applying it to `context`.
+
+ `context` is a dictionary of values to use in this rendering.
+
+ """
+ # Make the complete context we'll use.
+ render_context = dict(self.context)
+ if context:
+ render_context.update(context)
+ return self._render_function(render_context, self._do_dots)
+
+ def _do_dots(self, value, *dots):
+ """Evaluate dotted expressions at run-time."""
+ for dot in dots:
+ try:
+ value = getattr(value, dot)
+ except AttributeError:
+ try:
+ value = value[dot]
+ except (TypeError, KeyError):
+ raise TempliteValueError(
+ "Couldn't evaluate %r.%s" % (value, dot)
+ )
+ if callable(value):
+ value = value()
+ return value
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/tracer.so b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/tracer.so
new file mode 100644
index 0000000000000000000000000000000000000000..559742f9c2f721cde95a533f32ab431408b9d4d2
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/tracer.so differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/version.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..91c0d850411cf15be8acc81bd5a1126c405f1c16
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/version.py
@@ -0,0 +1,33 @@
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""The version and URL for coverage.py"""
+# This file is exec'ed in setup.py, don't import anything!
+
+# Same semantics as sys.version_info.
+version_info = (4, 5, 4, 'final', 0)
+
+
+def _make_version(major, minor, micro, releaselevel, serial):
+ """Create a readable version string from version_info tuple components."""
+ assert releaselevel in ['alpha', 'beta', 'candidate', 'final']
+ version = "%d.%d" % (major, minor)
+ if micro:
+ version += ".%d" % (micro,)
+ if releaselevel != 'final':
+ short = {'alpha': 'a', 'beta': 'b', 'candidate': 'rc'}[releaselevel]
+ version += "%s%d" % (short, serial)
+ return version
+
+
+def _make_url(major, minor, micro, releaselevel, serial):
+ """Make the URL people should start at for this version of coverage.py."""
+ url = "https://coverage.readthedocs.io"
+ if releaselevel != 'final':
+ # For pre-releases, use a version-specific URL.
+ url += "/en/coverage-" + _make_version(major, minor, micro, releaselevel, serial)
+ return url
+
+
+__version__ = _make_version(*version_info)
+__url__ = _make_url(*version_info)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/xmlreport.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/xmlreport.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a400e78a6b9a8cdf39c2d6afd371d3aec1ab9cf
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/coverage/xmlreport.py
@@ -0,0 +1,239 @@
+# coding: utf-8
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
+
+"""XML reporting for coverage.py"""
+
+import os
+import os.path
+import re
+import sys
+import time
+import xml.dom.minidom
+
+from coverage import env
+from coverage import __url__, __version__, files
+from coverage.backward import iitems
+from coverage.misc import isolate_module
+from coverage.report import Reporter
+
+os = isolate_module(os)
+
+
+DTD_URL = 'https://raw.githubusercontent.com/cobertura/web/master/htdocs/xml/coverage-04.dtd'
+
+
+def rate(hit, num):
+ """Return the fraction of `hit`/`num`, as a string."""
+ if num == 0:
+ return "1"
+ else:
+ return "%.4g" % (float(hit) / num)
+
+
+class XmlReporter(Reporter):
+ """A reporter for writing Cobertura-style XML coverage results."""
+
+ def __init__(self, coverage, config):
+ super(XmlReporter, self).__init__(coverage, config)
+
+ self.source_paths = set()
+ if config.source:
+ for src in config.source:
+ if os.path.exists(src):
+ self.source_paths.add(files.canonical_filename(src))
+ self.packages = {}
+ self.xml_out = None
+ self.has_arcs = coverage.data.has_arcs()
+
+ def report(self, morfs, outfile=None):
+ """Generate a Cobertura-compatible XML report for `morfs`.
+
+ `morfs` is a list of modules or file names.
+
+ `outfile` is a file object to write the XML to.
+
+ """
+ # Initial setup.
+ outfile = outfile or sys.stdout
+
+ # Create the DOM that will store the data.
+ impl = xml.dom.minidom.getDOMImplementation()
+ self.xml_out = impl.createDocument(None, "coverage", None)
+
+ # Write header stuff.
+ xcoverage = self.xml_out.documentElement
+ xcoverage.setAttribute("version", __version__)
+ xcoverage.setAttribute("timestamp", str(int(time.time()*1000)))
+ xcoverage.appendChild(self.xml_out.createComment(
+ " Generated by coverage.py: %s " % __url__
+ ))
+ xcoverage.appendChild(self.xml_out.createComment(" Based on %s " % DTD_URL))
+
+ # Call xml_file for each file in the data.
+ self.report_files(self.xml_file, morfs)
+
+ xsources = self.xml_out.createElement("sources")
+ xcoverage.appendChild(xsources)
+
+ # Populate the XML DOM with the source info.
+ for path in sorted(self.source_paths):
+ xsource = self.xml_out.createElement("source")
+ xsources.appendChild(xsource)
+ txt = self.xml_out.createTextNode(path)
+ xsource.appendChild(txt)
+
+ lnum_tot, lhits_tot = 0, 0
+ bnum_tot, bhits_tot = 0, 0
+
+ xpackages = self.xml_out.createElement("packages")
+ xcoverage.appendChild(xpackages)
+
+ # Populate the XML DOM with the package info.
+ for pkg_name, pkg_data in sorted(iitems(self.packages)):
+ class_elts, lhits, lnum, bhits, bnum = pkg_data
+ xpackage = self.xml_out.createElement("package")
+ xpackages.appendChild(xpackage)
+ xclasses = self.xml_out.createElement("classes")
+ xpackage.appendChild(xclasses)
+ for _, class_elt in sorted(iitems(class_elts)):
+ xclasses.appendChild(class_elt)
+ xpackage.setAttribute("name", pkg_name.replace(os.sep, '.'))
+ xpackage.setAttribute("line-rate", rate(lhits, lnum))
+ if self.has_arcs:
+ branch_rate = rate(bhits, bnum)
+ else:
+ branch_rate = "0"
+ xpackage.setAttribute("branch-rate", branch_rate)
+ xpackage.setAttribute("complexity", "0")
+
+ lnum_tot += lnum
+ lhits_tot += lhits
+ bnum_tot += bnum
+ bhits_tot += bhits
+
+ xcoverage.setAttribute("lines-valid", str(lnum_tot))
+ xcoverage.setAttribute("lines-covered", str(lhits_tot))
+ xcoverage.setAttribute("line-rate", rate(lhits_tot, lnum_tot))
+ if self.has_arcs:
+ xcoverage.setAttribute("branches-valid", str(bnum_tot))
+ xcoverage.setAttribute("branches-covered", str(bhits_tot))
+ xcoverage.setAttribute("branch-rate", rate(bhits_tot, bnum_tot))
+ else:
+ xcoverage.setAttribute("branches-covered", "0")
+ xcoverage.setAttribute("branches-valid", "0")
+ xcoverage.setAttribute("branch-rate", "0")
+ xcoverage.setAttribute("complexity", "0")
+
+ # Write the output file.
+ outfile.write(serialize_xml(self.xml_out))
+
+ # Return the total percentage.
+ denom = lnum_tot + bnum_tot
+ if denom == 0:
+ pct = 0.0
+ else:
+ pct = 100.0 * (lhits_tot + bhits_tot) / denom
+ return pct
+
+ def xml_file(self, fr, analysis):
+ """Add to the XML report for a single file."""
+
+ # Create the 'lines' and 'package' XML elements, which
+ # are populated later. Note that a package == a directory.
+ filename = fr.filename.replace("\\", "/")
+ for source_path in self.source_paths:
+ if filename.startswith(source_path.replace("\\", "/") + "/"):
+ rel_name = filename[len(source_path)+1:]
+ break
+ else:
+ rel_name = fr.relative_filename()
+
+ dirname = os.path.dirname(rel_name) or u"."
+ dirname = "/".join(dirname.split("/")[:self.config.xml_package_depth])
+ package_name = dirname.replace("/", ".")
+
+ if rel_name != fr.filename:
+ self.source_paths.add(fr.filename[:-len(rel_name)].rstrip(r"\/"))
+ package = self.packages.setdefault(package_name, [{}, 0, 0, 0, 0])
+
+ xclass = self.xml_out.createElement("class")
+
+ xclass.appendChild(self.xml_out.createElement("methods"))
+
+ xlines = self.xml_out.createElement("lines")
+ xclass.appendChild(xlines)
+
+ xclass.setAttribute("name", os.path.relpath(rel_name, dirname))
+ xclass.setAttribute("filename", rel_name.replace("\\", "/"))
+ xclass.setAttribute("complexity", "0")
+
+ branch_stats = analysis.branch_stats()
+ missing_branch_arcs = analysis.missing_branch_arcs()
+
+ # For each statement, create an XML 'line' element.
+ for line in sorted(analysis.statements):
+ xline = self.xml_out.createElement("line")
+ xline.setAttribute("number", str(line))
+
+ # Q: can we get info about the number of times a statement is
+ # executed? If so, that should be recorded here.
+ xline.setAttribute("hits", str(int(line not in analysis.missing)))
+
+ if self.has_arcs:
+ if line in branch_stats:
+ total, taken = branch_stats[line]
+ xline.setAttribute("branch", "true")
+ xline.setAttribute(
+ "condition-coverage",
+ "%d%% (%d/%d)" % (100*taken//total, taken, total)
+ )
+ if line in missing_branch_arcs:
+ annlines = ["exit" if b < 0 else str(b) for b in missing_branch_arcs[line]]
+ xline.setAttribute("missing-branches", ",".join(annlines))
+ xlines.appendChild(xline)
+
+ class_lines = len(analysis.statements)
+ class_hits = class_lines - len(analysis.missing)
+
+ if self.has_arcs:
+ class_branches = sum(t for t, k in branch_stats.values())
+ missing_branches = sum(t - k for t, k in branch_stats.values())
+ class_br_hits = class_branches - missing_branches
+ else:
+ class_branches = 0.0
+ class_br_hits = 0.0
+
+ # Finalize the statistics that are collected in the XML DOM.
+ xclass.setAttribute("line-rate", rate(class_hits, class_lines))
+ if self.has_arcs:
+ branch_rate = rate(class_br_hits, class_branches)
+ else:
+ branch_rate = "0"
+ xclass.setAttribute("branch-rate", branch_rate)
+
+ package[0][rel_name] = xclass
+ package[1] += class_hits
+ package[2] += class_lines
+ package[3] += class_br_hits
+ package[4] += class_branches
+
+
+def serialize_xml(dom):
+ """Serialize a minidom node to XML."""
+ out = dom.toprettyxml()
+ if env.PY2:
+ out = out.encode("utf8")
+ # In Python 3.8, minidom lost the sorting of attributes: https://bugs.python.org/issue34160
+ # For the limited kinds of XML we produce, this re-sorts them.
+ if env.PYVERSION >= (3, 8):
+ rx_attr = r' [\w-]+="[^"]*"'
+ rx_attrs = r'(' + rx_attr + ')+'
+ fixed_lines = []
+ for line in out.splitlines(True):
+ hollow_line = re.sub(rx_attrs, u"☺", line)
+ attrs = sorted(re.findall(rx_attr, line))
+ new_line = hollow_line.replace(u"☺", "".join(attrs))
+ fixed_lines.append(new_line)
+ out = "".join(fixed_lines)
+ return out
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0defb82e21f21da442706e25145b4ef0b59d576c
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/__init__.py
@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+try:
+ from ._version import version as __version__
+except ImportError:
+ __version__ = 'unknown'
+
+__all__ = ['easter', 'parser', 'relativedelta', 'rrule', 'tz',
+ 'utils', 'zoneinfo']
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/_common.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/_common.py
new file mode 100644
index 0000000000000000000000000000000000000000..4eb2659bd2986125fcfb4afea5bae9efc2dcd1a0
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/_common.py
@@ -0,0 +1,43 @@
+"""
+Common code used in multiple modules.
+"""
+
+
+class weekday(object):
+ __slots__ = ["weekday", "n"]
+
+ def __init__(self, weekday, n=None):
+ self.weekday = weekday
+ self.n = n
+
+ def __call__(self, n):
+ if n == self.n:
+ return self
+ else:
+ return self.__class__(self.weekday, n)
+
+ def __eq__(self, other):
+ try:
+ if self.weekday != other.weekday or self.n != other.n:
+ return False
+ except AttributeError:
+ return False
+ return True
+
+ def __hash__(self):
+ return hash((
+ self.weekday,
+ self.n,
+ ))
+
+ def __ne__(self, other):
+ return not (self == other)
+
+ def __repr__(self):
+ s = ("MO", "TU", "WE", "TH", "FR", "SA", "SU")[self.weekday]
+ if not self.n:
+ return s
+ else:
+ return "%s(%+d)" % (s, self.n)
+
+# vim:ts=4:sw=4:et
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/_version.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..670d7ab7dede02a7ebbfba1b18d1abb2d009dfc5
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/_version.py
@@ -0,0 +1,4 @@
+# coding: utf-8
+# file generated by setuptools_scm
+# don't change, don't track in version control
+version = '2.8.0'
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/easter.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/easter.py
new file mode 100644
index 0000000000000000000000000000000000000000..53b7c78938f193d5b0a10216bb2e3888e9710dfa
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/easter.py
@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+"""
+This module offers a generic easter computing method for any given year, using
+Western, Orthodox or Julian algorithms.
+"""
+
+import datetime
+
+__all__ = ["easter", "EASTER_JULIAN", "EASTER_ORTHODOX", "EASTER_WESTERN"]
+
+EASTER_JULIAN = 1
+EASTER_ORTHODOX = 2
+EASTER_WESTERN = 3
+
+
+def easter(year, method=EASTER_WESTERN):
+ """
+ This method was ported from the work done by GM Arts,
+ on top of the algorithm by Claus Tondering, which was
+ based in part on the algorithm of Ouding (1940), as
+ quoted in "Explanatory Supplement to the Astronomical
+ Almanac", P. Kenneth Seidelmann, editor.
+
+ This algorithm implements three different easter
+ calculation methods:
+
+ 1 - Original calculation in Julian calendar, valid in
+ dates after 326 AD
+ 2 - Original method, with date converted to Gregorian
+ calendar, valid in years 1583 to 4099
+ 3 - Revised method, in Gregorian calendar, valid in
+ years 1583 to 4099 as well
+
+ These methods are represented by the constants:
+
+ * ``EASTER_JULIAN = 1``
+ * ``EASTER_ORTHODOX = 2``
+ * ``EASTER_WESTERN = 3``
+
+ The default method is method 3.
+
+ More about the algorithm may be found at:
+
+ `GM Arts: Easter Algorithms `_
+
+ and
+
+ `The Calendar FAQ: Easter `_
+
+ """
+
+ if not (1 <= method <= 3):
+ raise ValueError("invalid method")
+
+ # g - Golden year - 1
+ # c - Century
+ # h - (23 - Epact) mod 30
+ # i - Number of days from March 21 to Paschal Full Moon
+ # j - Weekday for PFM (0=Sunday, etc)
+ # p - Number of days from March 21 to Sunday on or before PFM
+ # (-6 to 28 methods 1 & 3, to 56 for method 2)
+ # e - Extra days to add for method 2 (converting Julian
+ # date to Gregorian date)
+
+ y = year
+ g = y % 19
+ e = 0
+ if method < 3:
+ # Old method
+ i = (19*g + 15) % 30
+ j = (y + y//4 + i) % 7
+ if method == 2:
+ # Extra dates to convert Julian to Gregorian date
+ e = 10
+ if y > 1600:
+ e = e + y//100 - 16 - (y//100 - 16)//4
+ else:
+ # New method
+ c = y//100
+ h = (c - c//4 - (8*c + 13)//25 + 19*g + 15) % 30
+ i = h - (h//28)*(1 - (h//28)*(29//(h + 1))*((21 - g)//11))
+ j = (y + y//4 + i + 2 - c + c//4) % 7
+
+ # p can be from -6 to 56 corresponding to dates 22 March to 23 May
+ # (later dates apply to method 2, although 23 May never actually occurs)
+ p = i - j + e
+ d = 1 + (p + 27 + (p + 6)//40) % 31
+ m = 3 + (p + 26)//30
+ return datetime.date(int(y), int(m), int(d))
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/relativedelta.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/relativedelta.py
new file mode 100644
index 0000000000000000000000000000000000000000..c65c66e66e539c9f691926d12eca0a52b160d34c
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/relativedelta.py
@@ -0,0 +1,599 @@
+# -*- coding: utf-8 -*-
+import datetime
+import calendar
+
+import operator
+from math import copysign
+
+from six import integer_types
+from warnings import warn
+
+from ._common import weekday
+
+MO, TU, WE, TH, FR, SA, SU = weekdays = tuple(weekday(x) for x in range(7))
+
+__all__ = ["relativedelta", "MO", "TU", "WE", "TH", "FR", "SA", "SU"]
+
+
+class relativedelta(object):
+ """
+ The relativedelta type is designed to be applied to an existing datetime and
+ can replace specific components of that datetime, or represents an interval
+ of time.
+
+ It is based on the specification of the excellent work done by M.-A. Lemburg
+ in his
+ `mx.DateTime `_,
+including support for caching of results.
+"""
+import itertools
+import datetime
+import calendar
+import re
+import sys
+
+try:
+ from math import gcd
+except ImportError:
+ from fractions import gcd
+
+from six import advance_iterator, integer_types
+from six.moves import _thread, range
+import heapq
+
+from ._common import weekday as weekdaybase
+from .tz import tzutc, tzlocal
+
+# For warning about deprecation of until and count
+from warnings import warn
+
+__all__ = ["rrule", "rruleset", "rrulestr",
+ "YEARLY", "MONTHLY", "WEEKLY", "DAILY",
+ "HOURLY", "MINUTELY", "SECONDLY",
+ "MO", "TU", "WE", "TH", "FR", "SA", "SU"]
+
+# Every mask is 7 days longer to handle cross-year weekly periods.
+M366MASK = tuple([1]*31+[2]*29+[3]*31+[4]*30+[5]*31+[6]*30 +
+ [7]*31+[8]*31+[9]*30+[10]*31+[11]*30+[12]*31+[1]*7)
+M365MASK = list(M366MASK)
+M29, M30, M31 = list(range(1, 30)), list(range(1, 31)), list(range(1, 32))
+MDAY366MASK = tuple(M31+M29+M31+M30+M31+M30+M31+M31+M30+M31+M30+M31+M31[:7])
+MDAY365MASK = list(MDAY366MASK)
+M29, M30, M31 = list(range(-29, 0)), list(range(-30, 0)), list(range(-31, 0))
+NMDAY366MASK = tuple(M31+M29+M31+M30+M31+M30+M31+M31+M30+M31+M30+M31+M31[:7])
+NMDAY365MASK = list(NMDAY366MASK)
+M366RANGE = (0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366)
+M365RANGE = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365)
+WDAYMASK = [0, 1, 2, 3, 4, 5, 6]*55
+del M29, M30, M31, M365MASK[59], MDAY365MASK[59], NMDAY365MASK[31]
+MDAY365MASK = tuple(MDAY365MASK)
+M365MASK = tuple(M365MASK)
+
+FREQNAMES = ['YEARLY', 'MONTHLY', 'WEEKLY', 'DAILY', 'HOURLY', 'MINUTELY', 'SECONDLY']
+
+(YEARLY,
+ MONTHLY,
+ WEEKLY,
+ DAILY,
+ HOURLY,
+ MINUTELY,
+ SECONDLY) = list(range(7))
+
+# Imported on demand.
+easter = None
+parser = None
+
+
+class weekday(weekdaybase):
+ """
+ This version of weekday does not allow n = 0.
+ """
+ def __init__(self, wkday, n=None):
+ if n == 0:
+ raise ValueError("Can't create weekday with n==0")
+
+ super(weekday, self).__init__(wkday, n)
+
+
+MO, TU, WE, TH, FR, SA, SU = weekdays = tuple(weekday(x) for x in range(7))
+
+
+def _invalidates_cache(f):
+ """
+ Decorator for rruleset methods which may invalidate the
+ cached length.
+ """
+ def inner_func(self, *args, **kwargs):
+ rv = f(self, *args, **kwargs)
+ self._invalidate_cache()
+ return rv
+
+ return inner_func
+
+
+class rrulebase(object):
+ def __init__(self, cache=False):
+ if cache:
+ self._cache = []
+ self._cache_lock = _thread.allocate_lock()
+ self._invalidate_cache()
+ else:
+ self._cache = None
+ self._cache_complete = False
+ self._len = None
+
+ def __iter__(self):
+ if self._cache_complete:
+ return iter(self._cache)
+ elif self._cache is None:
+ return self._iter()
+ else:
+ return self._iter_cached()
+
+ def _invalidate_cache(self):
+ if self._cache is not None:
+ self._cache = []
+ self._cache_complete = False
+ self._cache_gen = self._iter()
+
+ if self._cache_lock.locked():
+ self._cache_lock.release()
+
+ self._len = None
+
+ def _iter_cached(self):
+ i = 0
+ gen = self._cache_gen
+ cache = self._cache
+ acquire = self._cache_lock.acquire
+ release = self._cache_lock.release
+ while gen:
+ if i == len(cache):
+ acquire()
+ if self._cache_complete:
+ break
+ try:
+ for j in range(10):
+ cache.append(advance_iterator(gen))
+ except StopIteration:
+ self._cache_gen = gen = None
+ self._cache_complete = True
+ break
+ release()
+ yield cache[i]
+ i += 1
+ while i < self._len:
+ yield cache[i]
+ i += 1
+
+ def __getitem__(self, item):
+ if self._cache_complete:
+ return self._cache[item]
+ elif isinstance(item, slice):
+ if item.step and item.step < 0:
+ return list(iter(self))[item]
+ else:
+ return list(itertools.islice(self,
+ item.start or 0,
+ item.stop or sys.maxsize,
+ item.step or 1))
+ elif item >= 0:
+ gen = iter(self)
+ try:
+ for i in range(item+1):
+ res = advance_iterator(gen)
+ except StopIteration:
+ raise IndexError
+ return res
+ else:
+ return list(iter(self))[item]
+
+ def __contains__(self, item):
+ if self._cache_complete:
+ return item in self._cache
+ else:
+ for i in self:
+ if i == item:
+ return True
+ elif i > item:
+ return False
+ return False
+
+ # __len__() introduces a large performance penality.
+ def count(self):
+ """ Returns the number of recurrences in this set. It will have go
+ trough the whole recurrence, if this hasn't been done before. """
+ if self._len is None:
+ for x in self:
+ pass
+ return self._len
+
+ def before(self, dt, inc=False):
+ """ Returns the last recurrence before the given datetime instance. The
+ inc keyword defines what happens if dt is an occurrence. With
+ inc=True, if dt itself is an occurrence, it will be returned. """
+ if self._cache_complete:
+ gen = self._cache
+ else:
+ gen = self
+ last = None
+ if inc:
+ for i in gen:
+ if i > dt:
+ break
+ last = i
+ else:
+ for i in gen:
+ if i >= dt:
+ break
+ last = i
+ return last
+
+ def after(self, dt, inc=False):
+ """ Returns the first recurrence after the given datetime instance. The
+ inc keyword defines what happens if dt is an occurrence. With
+ inc=True, if dt itself is an occurrence, it will be returned. """
+ if self._cache_complete:
+ gen = self._cache
+ else:
+ gen = self
+ if inc:
+ for i in gen:
+ if i >= dt:
+ return i
+ else:
+ for i in gen:
+ if i > dt:
+ return i
+ return None
+
+ def xafter(self, dt, count=None, inc=False):
+ """
+ Generator which yields up to `count` recurrences after the given
+ datetime instance, equivalent to `after`.
+
+ :param dt:
+ The datetime at which to start generating recurrences.
+
+ :param count:
+ The maximum number of recurrences to generate. If `None` (default),
+ dates are generated until the recurrence rule is exhausted.
+
+ :param inc:
+ If `dt` is an instance of the rule and `inc` is `True`, it is
+ included in the output.
+
+ :yields: Yields a sequence of `datetime` objects.
+ """
+
+ if self._cache_complete:
+ gen = self._cache
+ else:
+ gen = self
+
+ # Select the comparison function
+ if inc:
+ comp = lambda dc, dtc: dc >= dtc
+ else:
+ comp = lambda dc, dtc: dc > dtc
+
+ # Generate dates
+ n = 0
+ for d in gen:
+ if comp(d, dt):
+ if count is not None:
+ n += 1
+ if n > count:
+ break
+
+ yield d
+
+ def between(self, after, before, inc=False, count=1):
+ """ Returns all the occurrences of the rrule between after and before.
+ The inc keyword defines what happens if after and/or before are
+ themselves occurrences. With inc=True, they will be included in the
+ list, if they are found in the recurrence set. """
+ if self._cache_complete:
+ gen = self._cache
+ else:
+ gen = self
+ started = False
+ l = []
+ if inc:
+ for i in gen:
+ if i > before:
+ break
+ elif not started:
+ if i >= after:
+ started = True
+ l.append(i)
+ else:
+ l.append(i)
+ else:
+ for i in gen:
+ if i >= before:
+ break
+ elif not started:
+ if i > after:
+ started = True
+ l.append(i)
+ else:
+ l.append(i)
+ return l
+
+
+class rrule(rrulebase):
+ """
+ That's the base of the rrule operation. It accepts all the keywords
+ defined in the RFC as its constructor parameters (except byday,
+ which was renamed to byweekday) and more. The constructor prototype is::
+
+ rrule(freq)
+
+ Where freq must be one of YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY,
+ or SECONDLY.
+
+ .. note::
+ Per RFC section 3.3.10, recurrence instances falling on invalid dates
+ and times are ignored rather than coerced:
+
+ Recurrence rules may generate recurrence instances with an invalid
+ date (e.g., February 30) or nonexistent local time (e.g., 1:30 AM
+ on a day where the local time is moved forward by an hour at 1:00
+ AM). Such recurrence instances MUST be ignored and MUST NOT be
+ counted as part of the recurrence set.
+
+ This can lead to possibly surprising behavior when, for example, the
+ start date occurs at the end of the month:
+
+ >>> from dateutil.rrule import rrule, MONTHLY
+ >>> from datetime import datetime
+ >>> start_date = datetime(2014, 12, 31)
+ >>> list(rrule(freq=MONTHLY, count=4, dtstart=start_date))
+ ... # doctest: +NORMALIZE_WHITESPACE
+ [datetime.datetime(2014, 12, 31, 0, 0),
+ datetime.datetime(2015, 1, 31, 0, 0),
+ datetime.datetime(2015, 3, 31, 0, 0),
+ datetime.datetime(2015, 5, 31, 0, 0)]
+
+ Additionally, it supports the following keyword arguments:
+
+ :param dtstart:
+ The recurrence start. Besides being the base for the recurrence,
+ missing parameters in the final recurrence instances will also be
+ extracted from this date. If not given, datetime.now() will be used
+ instead.
+ :param interval:
+ The interval between each freq iteration. For example, when using
+ YEARLY, an interval of 2 means once every two years, but with HOURLY,
+ it means once every two hours. The default interval is 1.
+ :param wkst:
+ The week start day. Must be one of the MO, TU, WE constants, or an
+ integer, specifying the first day of the week. This will affect
+ recurrences based on weekly periods. The default week start is got
+ from calendar.firstweekday(), and may be modified by
+ calendar.setfirstweekday().
+ :param count:
+ If given, this determines how many occurrences will be generated.
+
+ .. note::
+ As of version 2.5.0, the use of the keyword ``until`` in conjunction
+ with ``count`` is deprecated, to make sure ``dateutil`` is fully
+ compliant with `RFC-5545 Sec. 3.3.10 `_. Therefore, ``until`` and ``count``
+ **must not** occur in the same call to ``rrule``.
+ :param until:
+ If given, this must be a datetime instance specifying the upper-bound
+ limit of the recurrence. The last recurrence in the rule is the greatest
+ datetime that is less than or equal to the value specified in the
+ ``until`` parameter.
+
+ .. note::
+ As of version 2.5.0, the use of the keyword ``until`` in conjunction
+ with ``count`` is deprecated, to make sure ``dateutil`` is fully
+ compliant with `RFC-5545 Sec. 3.3.10 `_. Therefore, ``until`` and ``count``
+ **must not** occur in the same call to ``rrule``.
+ :param bysetpos:
+ If given, it must be either an integer, or a sequence of integers,
+ positive or negative. Each given integer will specify an occurrence
+ number, corresponding to the nth occurrence of the rule inside the
+ frequency period. For example, a bysetpos of -1 if combined with a
+ MONTHLY frequency, and a byweekday of (MO, TU, WE, TH, FR), will
+ result in the last work day of every month.
+ :param bymonth:
+ If given, it must be either an integer, or a sequence of integers,
+ meaning the months to apply the recurrence to.
+ :param bymonthday:
+ If given, it must be either an integer, or a sequence of integers,
+ meaning the month days to apply the recurrence to.
+ :param byyearday:
+ If given, it must be either an integer, or a sequence of integers,
+ meaning the year days to apply the recurrence to.
+ :param byeaster:
+ If given, it must be either an integer, or a sequence of integers,
+ positive or negative. Each integer will define an offset from the
+ Easter Sunday. Passing the offset 0 to byeaster will yield the Easter
+ Sunday itself. This is an extension to the RFC specification.
+ :param byweekno:
+ If given, it must be either an integer, or a sequence of integers,
+ meaning the week numbers to apply the recurrence to. Week numbers
+ have the meaning described in ISO8601, that is, the first week of
+ the year is that containing at least four days of the new year.
+ :param byweekday:
+ If given, it must be either an integer (0 == MO), a sequence of
+ integers, one of the weekday constants (MO, TU, etc), or a sequence
+ of these constants. When given, these variables will define the
+ weekdays where the recurrence will be applied. It's also possible to
+ use an argument n for the weekday instances, which will mean the nth
+ occurrence of this weekday in the period. For example, with MONTHLY,
+ or with YEARLY and BYMONTH, using FR(+1) in byweekday will specify the
+ first friday of the month where the recurrence happens. Notice that in
+ the RFC documentation, this is specified as BYDAY, but was renamed to
+ avoid the ambiguity of that keyword.
+ :param byhour:
+ If given, it must be either an integer, or a sequence of integers,
+ meaning the hours to apply the recurrence to.
+ :param byminute:
+ If given, it must be either an integer, or a sequence of integers,
+ meaning the minutes to apply the recurrence to.
+ :param bysecond:
+ If given, it must be either an integer, or a sequence of integers,
+ meaning the seconds to apply the recurrence to.
+ :param cache:
+ If given, it must be a boolean value specifying to enable or disable
+ caching of results. If you will use the same rrule instance multiple
+ times, enabling caching will improve the performance considerably.
+ """
+ def __init__(self, freq, dtstart=None,
+ interval=1, wkst=None, count=None, until=None, bysetpos=None,
+ bymonth=None, bymonthday=None, byyearday=None, byeaster=None,
+ byweekno=None, byweekday=None,
+ byhour=None, byminute=None, bysecond=None,
+ cache=False):
+ super(rrule, self).__init__(cache)
+ global easter
+ if not dtstart:
+ if until and until.tzinfo:
+ dtstart = datetime.datetime.now(tz=until.tzinfo).replace(microsecond=0)
+ else:
+ dtstart = datetime.datetime.now().replace(microsecond=0)
+ elif not isinstance(dtstart, datetime.datetime):
+ dtstart = datetime.datetime.fromordinal(dtstart.toordinal())
+ else:
+ dtstart = dtstart.replace(microsecond=0)
+ self._dtstart = dtstart
+ self._tzinfo = dtstart.tzinfo
+ self._freq = freq
+ self._interval = interval
+ self._count = count
+
+ # Cache the original byxxx rules, if they are provided, as the _byxxx
+ # attributes do not necessarily map to the inputs, and this can be
+ # a problem in generating the strings. Only store things if they've
+ # been supplied (the string retrieval will just use .get())
+ self._original_rule = {}
+
+ if until and not isinstance(until, datetime.datetime):
+ until = datetime.datetime.fromordinal(until.toordinal())
+ self._until = until
+
+ if self._dtstart and self._until:
+ if (self._dtstart.tzinfo is not None) != (self._until.tzinfo is not None):
+ # According to RFC5545 Section 3.3.10:
+ # https://tools.ietf.org/html/rfc5545#section-3.3.10
+ #
+ # > If the "DTSTART" property is specified as a date with UTC
+ # > time or a date with local time and time zone reference,
+ # > then the UNTIL rule part MUST be specified as a date with
+ # > UTC time.
+ raise ValueError(
+ 'RRULE UNTIL values must be specified in UTC when DTSTART '
+ 'is timezone-aware'
+ )
+
+ if count is not None and until:
+ warn("Using both 'count' and 'until' is inconsistent with RFC 5545"
+ " and has been deprecated in dateutil. Future versions will "
+ "raise an error.", DeprecationWarning)
+
+ if wkst is None:
+ self._wkst = calendar.firstweekday()
+ elif isinstance(wkst, integer_types):
+ self._wkst = wkst
+ else:
+ self._wkst = wkst.weekday
+
+ if bysetpos is None:
+ self._bysetpos = None
+ elif isinstance(bysetpos, integer_types):
+ if bysetpos == 0 or not (-366 <= bysetpos <= 366):
+ raise ValueError("bysetpos must be between 1 and 366, "
+ "or between -366 and -1")
+ self._bysetpos = (bysetpos,)
+ else:
+ self._bysetpos = tuple(bysetpos)
+ for pos in self._bysetpos:
+ if pos == 0 or not (-366 <= pos <= 366):
+ raise ValueError("bysetpos must be between 1 and 366, "
+ "or between -366 and -1")
+
+ if self._bysetpos:
+ self._original_rule['bysetpos'] = self._bysetpos
+
+ if (byweekno is None and byyearday is None and bymonthday is None and
+ byweekday is None and byeaster is None):
+ if freq == YEARLY:
+ if bymonth is None:
+ bymonth = dtstart.month
+ self._original_rule['bymonth'] = None
+ bymonthday = dtstart.day
+ self._original_rule['bymonthday'] = None
+ elif freq == MONTHLY:
+ bymonthday = dtstart.day
+ self._original_rule['bymonthday'] = None
+ elif freq == WEEKLY:
+ byweekday = dtstart.weekday()
+ self._original_rule['byweekday'] = None
+
+ # bymonth
+ if bymonth is None:
+ self._bymonth = None
+ else:
+ if isinstance(bymonth, integer_types):
+ bymonth = (bymonth,)
+
+ self._bymonth = tuple(sorted(set(bymonth)))
+
+ if 'bymonth' not in self._original_rule:
+ self._original_rule['bymonth'] = self._bymonth
+
+ # byyearday
+ if byyearday is None:
+ self._byyearday = None
+ else:
+ if isinstance(byyearday, integer_types):
+ byyearday = (byyearday,)
+
+ self._byyearday = tuple(sorted(set(byyearday)))
+ self._original_rule['byyearday'] = self._byyearday
+
+ # byeaster
+ if byeaster is not None:
+ if not easter:
+ from dateutil import easter
+ if isinstance(byeaster, integer_types):
+ self._byeaster = (byeaster,)
+ else:
+ self._byeaster = tuple(sorted(byeaster))
+
+ self._original_rule['byeaster'] = self._byeaster
+ else:
+ self._byeaster = None
+
+ # bymonthday
+ if bymonthday is None:
+ self._bymonthday = ()
+ self._bynmonthday = ()
+ else:
+ if isinstance(bymonthday, integer_types):
+ bymonthday = (bymonthday,)
+
+ bymonthday = set(bymonthday) # Ensure it's unique
+
+ self._bymonthday = tuple(sorted(x for x in bymonthday if x > 0))
+ self._bynmonthday = tuple(sorted(x for x in bymonthday if x < 0))
+
+ # Storing positive numbers first, then negative numbers
+ if 'bymonthday' not in self._original_rule:
+ self._original_rule['bymonthday'] = tuple(
+ itertools.chain(self._bymonthday, self._bynmonthday))
+
+ # byweekno
+ if byweekno is None:
+ self._byweekno = None
+ else:
+ if isinstance(byweekno, integer_types):
+ byweekno = (byweekno,)
+
+ self._byweekno = tuple(sorted(set(byweekno)))
+
+ self._original_rule['byweekno'] = self._byweekno
+
+ # byweekday / bynweekday
+ if byweekday is None:
+ self._byweekday = None
+ self._bynweekday = None
+ else:
+ # If it's one of the valid non-sequence types, convert to a
+ # single-element sequence before the iterator that builds the
+ # byweekday set.
+ if isinstance(byweekday, integer_types) or hasattr(byweekday, "n"):
+ byweekday = (byweekday,)
+
+ self._byweekday = set()
+ self._bynweekday = set()
+ for wday in byweekday:
+ if isinstance(wday, integer_types):
+ self._byweekday.add(wday)
+ elif not wday.n or freq > MONTHLY:
+ self._byweekday.add(wday.weekday)
+ else:
+ self._bynweekday.add((wday.weekday, wday.n))
+
+ if not self._byweekday:
+ self._byweekday = None
+ elif not self._bynweekday:
+ self._bynweekday = None
+
+ if self._byweekday is not None:
+ self._byweekday = tuple(sorted(self._byweekday))
+ orig_byweekday = [weekday(x) for x in self._byweekday]
+ else:
+ orig_byweekday = ()
+
+ if self._bynweekday is not None:
+ self._bynweekday = tuple(sorted(self._bynweekday))
+ orig_bynweekday = [weekday(*x) for x in self._bynweekday]
+ else:
+ orig_bynweekday = ()
+
+ if 'byweekday' not in self._original_rule:
+ self._original_rule['byweekday'] = tuple(itertools.chain(
+ orig_byweekday, orig_bynweekday))
+
+ # byhour
+ if byhour is None:
+ if freq < HOURLY:
+ self._byhour = {dtstart.hour}
+ else:
+ self._byhour = None
+ else:
+ if isinstance(byhour, integer_types):
+ byhour = (byhour,)
+
+ if freq == HOURLY:
+ self._byhour = self.__construct_byset(start=dtstart.hour,
+ byxxx=byhour,
+ base=24)
+ else:
+ self._byhour = set(byhour)
+
+ self._byhour = tuple(sorted(self._byhour))
+ self._original_rule['byhour'] = self._byhour
+
+ # byminute
+ if byminute is None:
+ if freq < MINUTELY:
+ self._byminute = {dtstart.minute}
+ else:
+ self._byminute = None
+ else:
+ if isinstance(byminute, integer_types):
+ byminute = (byminute,)
+
+ if freq == MINUTELY:
+ self._byminute = self.__construct_byset(start=dtstart.minute,
+ byxxx=byminute,
+ base=60)
+ else:
+ self._byminute = set(byminute)
+
+ self._byminute = tuple(sorted(self._byminute))
+ self._original_rule['byminute'] = self._byminute
+
+ # bysecond
+ if bysecond is None:
+ if freq < SECONDLY:
+ self._bysecond = ((dtstart.second,))
+ else:
+ self._bysecond = None
+ else:
+ if isinstance(bysecond, integer_types):
+ bysecond = (bysecond,)
+
+ self._bysecond = set(bysecond)
+
+ if freq == SECONDLY:
+ self._bysecond = self.__construct_byset(start=dtstart.second,
+ byxxx=bysecond,
+ base=60)
+ else:
+ self._bysecond = set(bysecond)
+
+ self._bysecond = tuple(sorted(self._bysecond))
+ self._original_rule['bysecond'] = self._bysecond
+
+ if self._freq >= HOURLY:
+ self._timeset = None
+ else:
+ self._timeset = []
+ for hour in self._byhour:
+ for minute in self._byminute:
+ for second in self._bysecond:
+ self._timeset.append(
+ datetime.time(hour, minute, second,
+ tzinfo=self._tzinfo))
+ self._timeset.sort()
+ self._timeset = tuple(self._timeset)
+
+ def __str__(self):
+ """
+ Output a string that would generate this RRULE if passed to rrulestr.
+ This is mostly compatible with RFC5545, except for the
+ dateutil-specific extension BYEASTER.
+ """
+
+ output = []
+ h, m, s = [None] * 3
+ if self._dtstart:
+ output.append(self._dtstart.strftime('DTSTART:%Y%m%dT%H%M%S'))
+ h, m, s = self._dtstart.timetuple()[3:6]
+
+ parts = ['FREQ=' + FREQNAMES[self._freq]]
+ if self._interval != 1:
+ parts.append('INTERVAL=' + str(self._interval))
+
+ if self._wkst:
+ parts.append('WKST=' + repr(weekday(self._wkst))[0:2])
+
+ if self._count is not None:
+ parts.append('COUNT=' + str(self._count))
+
+ if self._until:
+ parts.append(self._until.strftime('UNTIL=%Y%m%dT%H%M%S'))
+
+ if self._original_rule.get('byweekday') is not None:
+ # The str() method on weekday objects doesn't generate
+ # RFC5545-compliant strings, so we should modify that.
+ original_rule = dict(self._original_rule)
+ wday_strings = []
+ for wday in original_rule['byweekday']:
+ if wday.n:
+ wday_strings.append('{n:+d}{wday}'.format(
+ n=wday.n,
+ wday=repr(wday)[0:2]))
+ else:
+ wday_strings.append(repr(wday))
+
+ original_rule['byweekday'] = wday_strings
+ else:
+ original_rule = self._original_rule
+
+ partfmt = '{name}={vals}'
+ for name, key in [('BYSETPOS', 'bysetpos'),
+ ('BYMONTH', 'bymonth'),
+ ('BYMONTHDAY', 'bymonthday'),
+ ('BYYEARDAY', 'byyearday'),
+ ('BYWEEKNO', 'byweekno'),
+ ('BYDAY', 'byweekday'),
+ ('BYHOUR', 'byhour'),
+ ('BYMINUTE', 'byminute'),
+ ('BYSECOND', 'bysecond'),
+ ('BYEASTER', 'byeaster')]:
+ value = original_rule.get(key)
+ if value:
+ parts.append(partfmt.format(name=name, vals=(','.join(str(v)
+ for v in value))))
+
+ output.append('RRULE:' + ';'.join(parts))
+ return '\n'.join(output)
+
+ def replace(self, **kwargs):
+ """Return new rrule with same attributes except for those attributes given new
+ values by whichever keyword arguments are specified."""
+ new_kwargs = {"interval": self._interval,
+ "count": self._count,
+ "dtstart": self._dtstart,
+ "freq": self._freq,
+ "until": self._until,
+ "wkst": self._wkst,
+ "cache": False if self._cache is None else True }
+ new_kwargs.update(self._original_rule)
+ new_kwargs.update(kwargs)
+ return rrule(**new_kwargs)
+
+ def _iter(self):
+ year, month, day, hour, minute, second, weekday, yearday, _ = \
+ self._dtstart.timetuple()
+
+ # Some local variables to speed things up a bit
+ freq = self._freq
+ interval = self._interval
+ wkst = self._wkst
+ until = self._until
+ bymonth = self._bymonth
+ byweekno = self._byweekno
+ byyearday = self._byyearday
+ byweekday = self._byweekday
+ byeaster = self._byeaster
+ bymonthday = self._bymonthday
+ bynmonthday = self._bynmonthday
+ bysetpos = self._bysetpos
+ byhour = self._byhour
+ byminute = self._byminute
+ bysecond = self._bysecond
+
+ ii = _iterinfo(self)
+ ii.rebuild(year, month)
+
+ getdayset = {YEARLY: ii.ydayset,
+ MONTHLY: ii.mdayset,
+ WEEKLY: ii.wdayset,
+ DAILY: ii.ddayset,
+ HOURLY: ii.ddayset,
+ MINUTELY: ii.ddayset,
+ SECONDLY: ii.ddayset}[freq]
+
+ if freq < HOURLY:
+ timeset = self._timeset
+ else:
+ gettimeset = {HOURLY: ii.htimeset,
+ MINUTELY: ii.mtimeset,
+ SECONDLY: ii.stimeset}[freq]
+ if ((freq >= HOURLY and
+ self._byhour and hour not in self._byhour) or
+ (freq >= MINUTELY and
+ self._byminute and minute not in self._byminute) or
+ (freq >= SECONDLY and
+ self._bysecond and second not in self._bysecond)):
+ timeset = ()
+ else:
+ timeset = gettimeset(hour, minute, second)
+
+ total = 0
+ count = self._count
+ while True:
+ # Get dayset with the right frequency
+ dayset, start, end = getdayset(year, month, day)
+
+ # Do the "hard" work ;-)
+ filtered = False
+ for i in dayset[start:end]:
+ if ((bymonth and ii.mmask[i] not in bymonth) or
+ (byweekno and not ii.wnomask[i]) or
+ (byweekday and ii.wdaymask[i] not in byweekday) or
+ (ii.nwdaymask and not ii.nwdaymask[i]) or
+ (byeaster and not ii.eastermask[i]) or
+ ((bymonthday or bynmonthday) and
+ ii.mdaymask[i] not in bymonthday and
+ ii.nmdaymask[i] not in bynmonthday) or
+ (byyearday and
+ ((i < ii.yearlen and i+1 not in byyearday and
+ -ii.yearlen+i not in byyearday) or
+ (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
+ -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
+ dayset[i] = None
+ filtered = True
+
+ # Output results
+ if bysetpos and timeset:
+ poslist = []
+ for pos in bysetpos:
+ if pos < 0:
+ daypos, timepos = divmod(pos, len(timeset))
+ else:
+ daypos, timepos = divmod(pos-1, len(timeset))
+ try:
+ i = [x for x in dayset[start:end]
+ if x is not None][daypos]
+ time = timeset[timepos]
+ except IndexError:
+ pass
+ else:
+ date = datetime.date.fromordinal(ii.yearordinal+i)
+ res = datetime.datetime.combine(date, time)
+ if res not in poslist:
+ poslist.append(res)
+ poslist.sort()
+ for res in poslist:
+ if until and res > until:
+ self._len = total
+ return
+ elif res >= self._dtstart:
+ if count is not None:
+ count -= 1
+ if count < 0:
+ self._len = total
+ return
+ total += 1
+ yield res
+ else:
+ for i in dayset[start:end]:
+ if i is not None:
+ date = datetime.date.fromordinal(ii.yearordinal + i)
+ for time in timeset:
+ res = datetime.datetime.combine(date, time)
+ if until and res > until:
+ self._len = total
+ return
+ elif res >= self._dtstart:
+ if count is not None:
+ count -= 1
+ if count < 0:
+ self._len = total
+ return
+
+ total += 1
+ yield res
+
+ # Handle frequency and interval
+ fixday = False
+ if freq == YEARLY:
+ year += interval
+ if year > datetime.MAXYEAR:
+ self._len = total
+ return
+ ii.rebuild(year, month)
+ elif freq == MONTHLY:
+ month += interval
+ if month > 12:
+ div, mod = divmod(month, 12)
+ month = mod
+ year += div
+ if month == 0:
+ month = 12
+ year -= 1
+ if year > datetime.MAXYEAR:
+ self._len = total
+ return
+ ii.rebuild(year, month)
+ elif freq == WEEKLY:
+ if wkst > weekday:
+ day += -(weekday+1+(6-wkst))+self._interval*7
+ else:
+ day += -(weekday-wkst)+self._interval*7
+ weekday = wkst
+ fixday = True
+ elif freq == DAILY:
+ day += interval
+ fixday = True
+ elif freq == HOURLY:
+ if filtered:
+ # Jump to one iteration before next day
+ hour += ((23-hour)//interval)*interval
+
+ if byhour:
+ ndays, hour = self.__mod_distance(value=hour,
+ byxxx=self._byhour,
+ base=24)
+ else:
+ ndays, hour = divmod(hour+interval, 24)
+
+ if ndays:
+ day += ndays
+ fixday = True
+
+ timeset = gettimeset(hour, minute, second)
+ elif freq == MINUTELY:
+ if filtered:
+ # Jump to one iteration before next day
+ minute += ((1439-(hour*60+minute))//interval)*interval
+
+ valid = False
+ rep_rate = (24*60)
+ for j in range(rep_rate // gcd(interval, rep_rate)):
+ if byminute:
+ nhours, minute = \
+ self.__mod_distance(value=minute,
+ byxxx=self._byminute,
+ base=60)
+ else:
+ nhours, minute = divmod(minute+interval, 60)
+
+ div, hour = divmod(hour+nhours, 24)
+ if div:
+ day += div
+ fixday = True
+ filtered = False
+
+ if not byhour or hour in byhour:
+ valid = True
+ break
+
+ if not valid:
+ raise ValueError('Invalid combination of interval and ' +
+ 'byhour resulting in empty rule.')
+
+ timeset = gettimeset(hour, minute, second)
+ elif freq == SECONDLY:
+ if filtered:
+ # Jump to one iteration before next day
+ second += (((86399 - (hour * 3600 + minute * 60 + second))
+ // interval) * interval)
+
+ rep_rate = (24 * 3600)
+ valid = False
+ for j in range(0, rep_rate // gcd(interval, rep_rate)):
+ if bysecond:
+ nminutes, second = \
+ self.__mod_distance(value=second,
+ byxxx=self._bysecond,
+ base=60)
+ else:
+ nminutes, second = divmod(second+interval, 60)
+
+ div, minute = divmod(minute+nminutes, 60)
+ if div:
+ hour += div
+ div, hour = divmod(hour, 24)
+ if div:
+ day += div
+ fixday = True
+
+ if ((not byhour or hour in byhour) and
+ (not byminute or minute in byminute) and
+ (not bysecond or second in bysecond)):
+ valid = True
+ break
+
+ if not valid:
+ raise ValueError('Invalid combination of interval, ' +
+ 'byhour and byminute resulting in empty' +
+ ' rule.')
+
+ timeset = gettimeset(hour, minute, second)
+
+ if fixday and day > 28:
+ daysinmonth = calendar.monthrange(year, month)[1]
+ if day > daysinmonth:
+ while day > daysinmonth:
+ day -= daysinmonth
+ month += 1
+ if month == 13:
+ month = 1
+ year += 1
+ if year > datetime.MAXYEAR:
+ self._len = total
+ return
+ daysinmonth = calendar.monthrange(year, month)[1]
+ ii.rebuild(year, month)
+
+ def __construct_byset(self, start, byxxx, base):
+ """
+ If a `BYXXX` sequence is passed to the constructor at the same level as
+ `FREQ` (e.g. `FREQ=HOURLY,BYHOUR={2,4,7},INTERVAL=3`), there are some
+ specifications which cannot be reached given some starting conditions.
+
+ This occurs whenever the interval is not coprime with the base of a
+ given unit and the difference between the starting position and the
+ ending position is not coprime with the greatest common denominator
+ between the interval and the base. For example, with a FREQ of hourly
+ starting at 17:00 and an interval of 4, the only valid values for
+ BYHOUR would be {21, 1, 5, 9, 13, 17}, because 4 and 24 are not
+ coprime.
+
+ :param start:
+ Specifies the starting position.
+ :param byxxx:
+ An iterable containing the list of allowed values.
+ :param base:
+ The largest allowable value for the specified frequency (e.g.
+ 24 hours, 60 minutes).
+
+ This does not preserve the type of the iterable, returning a set, since
+ the values should be unique and the order is irrelevant, this will
+ speed up later lookups.
+
+ In the event of an empty set, raises a :exception:`ValueError`, as this
+ results in an empty rrule.
+ """
+
+ cset = set()
+
+ # Support a single byxxx value.
+ if isinstance(byxxx, integer_types):
+ byxxx = (byxxx, )
+
+ for num in byxxx:
+ i_gcd = gcd(self._interval, base)
+ # Use divmod rather than % because we need to wrap negative nums.
+ if i_gcd == 1 or divmod(num - start, i_gcd)[1] == 0:
+ cset.add(num)
+
+ if len(cset) == 0:
+ raise ValueError("Invalid rrule byxxx generates an empty set.")
+
+ return cset
+
+ def __mod_distance(self, value, byxxx, base):
+ """
+ Calculates the next value in a sequence where the `FREQ` parameter is
+ specified along with a `BYXXX` parameter at the same "level"
+ (e.g. `HOURLY` specified with `BYHOUR`).
+
+ :param value:
+ The old value of the component.
+ :param byxxx:
+ The `BYXXX` set, which should have been generated by
+ `rrule._construct_byset`, or something else which checks that a
+ valid rule is present.
+ :param base:
+ The largest allowable value for the specified frequency (e.g.
+ 24 hours, 60 minutes).
+
+ If a valid value is not found after `base` iterations (the maximum
+ number before the sequence would start to repeat), this raises a
+ :exception:`ValueError`, as no valid values were found.
+
+ This returns a tuple of `divmod(n*interval, base)`, where `n` is the
+ smallest number of `interval` repetitions until the next specified
+ value in `byxxx` is found.
+ """
+ accumulator = 0
+ for ii in range(1, base + 1):
+ # Using divmod() over % to account for negative intervals
+ div, value = divmod(value + self._interval, base)
+ accumulator += div
+ if value in byxxx:
+ return (accumulator, value)
+
+
+class _iterinfo(object):
+ __slots__ = ["rrule", "lastyear", "lastmonth",
+ "yearlen", "nextyearlen", "yearordinal", "yearweekday",
+ "mmask", "mrange", "mdaymask", "nmdaymask",
+ "wdaymask", "wnomask", "nwdaymask", "eastermask"]
+
+ def __init__(self, rrule):
+ for attr in self.__slots__:
+ setattr(self, attr, None)
+ self.rrule = rrule
+
+ def rebuild(self, year, month):
+ # Every mask is 7 days longer to handle cross-year weekly periods.
+ rr = self.rrule
+ if year != self.lastyear:
+ self.yearlen = 365 + calendar.isleap(year)
+ self.nextyearlen = 365 + calendar.isleap(year + 1)
+ firstyday = datetime.date(year, 1, 1)
+ self.yearordinal = firstyday.toordinal()
+ self.yearweekday = firstyday.weekday()
+
+ wday = datetime.date(year, 1, 1).weekday()
+ if self.yearlen == 365:
+ self.mmask = M365MASK
+ self.mdaymask = MDAY365MASK
+ self.nmdaymask = NMDAY365MASK
+ self.wdaymask = WDAYMASK[wday:]
+ self.mrange = M365RANGE
+ else:
+ self.mmask = M366MASK
+ self.mdaymask = MDAY366MASK
+ self.nmdaymask = NMDAY366MASK
+ self.wdaymask = WDAYMASK[wday:]
+ self.mrange = M366RANGE
+
+ if not rr._byweekno:
+ self.wnomask = None
+ else:
+ self.wnomask = [0]*(self.yearlen+7)
+ # no1wkst = firstwkst = self.wdaymask.index(rr._wkst)
+ no1wkst = firstwkst = (7-self.yearweekday+rr._wkst) % 7
+ if no1wkst >= 4:
+ no1wkst = 0
+ # Number of days in the year, plus the days we got
+ # from last year.
+ wyearlen = self.yearlen+(self.yearweekday-rr._wkst) % 7
+ else:
+ # Number of days in the year, minus the days we
+ # left in last year.
+ wyearlen = self.yearlen-no1wkst
+ div, mod = divmod(wyearlen, 7)
+ numweeks = div+mod//4
+ for n in rr._byweekno:
+ if n < 0:
+ n += numweeks+1
+ if not (0 < n <= numweeks):
+ continue
+ if n > 1:
+ i = no1wkst+(n-1)*7
+ if no1wkst != firstwkst:
+ i -= 7-firstwkst
+ else:
+ i = no1wkst
+ for j in range(7):
+ self.wnomask[i] = 1
+ i += 1
+ if self.wdaymask[i] == rr._wkst:
+ break
+ if 1 in rr._byweekno:
+ # Check week number 1 of next year as well
+ # TODO: Check -numweeks for next year.
+ i = no1wkst+numweeks*7
+ if no1wkst != firstwkst:
+ i -= 7-firstwkst
+ if i < self.yearlen:
+ # If week starts in next year, we
+ # don't care about it.
+ for j in range(7):
+ self.wnomask[i] = 1
+ i += 1
+ if self.wdaymask[i] == rr._wkst:
+ break
+ if no1wkst:
+ # Check last week number of last year as
+ # well. If no1wkst is 0, either the year
+ # started on week start, or week number 1
+ # got days from last year, so there are no
+ # days from last year's last week number in
+ # this year.
+ if -1 not in rr._byweekno:
+ lyearweekday = datetime.date(year-1, 1, 1).weekday()
+ lno1wkst = (7-lyearweekday+rr._wkst) % 7
+ lyearlen = 365+calendar.isleap(year-1)
+ if lno1wkst >= 4:
+ lno1wkst = 0
+ lnumweeks = 52+(lyearlen +
+ (lyearweekday-rr._wkst) % 7) % 7//4
+ else:
+ lnumweeks = 52+(self.yearlen-no1wkst) % 7//4
+ else:
+ lnumweeks = -1
+ if lnumweeks in rr._byweekno:
+ for i in range(no1wkst):
+ self.wnomask[i] = 1
+
+ if (rr._bynweekday and (month != self.lastmonth or
+ year != self.lastyear)):
+ ranges = []
+ if rr._freq == YEARLY:
+ if rr._bymonth:
+ for month in rr._bymonth:
+ ranges.append(self.mrange[month-1:month+1])
+ else:
+ ranges = [(0, self.yearlen)]
+ elif rr._freq == MONTHLY:
+ ranges = [self.mrange[month-1:month+1]]
+ if ranges:
+ # Weekly frequency won't get here, so we may not
+ # care about cross-year weekly periods.
+ self.nwdaymask = [0]*self.yearlen
+ for first, last in ranges:
+ last -= 1
+ for wday, n in rr._bynweekday:
+ if n < 0:
+ i = last+(n+1)*7
+ i -= (self.wdaymask[i]-wday) % 7
+ else:
+ i = first+(n-1)*7
+ i += (7-self.wdaymask[i]+wday) % 7
+ if first <= i <= last:
+ self.nwdaymask[i] = 1
+
+ if rr._byeaster:
+ self.eastermask = [0]*(self.yearlen+7)
+ eyday = easter.easter(year).toordinal()-self.yearordinal
+ for offset in rr._byeaster:
+ self.eastermask[eyday+offset] = 1
+
+ self.lastyear = year
+ self.lastmonth = month
+
+ def ydayset(self, year, month, day):
+ return list(range(self.yearlen)), 0, self.yearlen
+
+ def mdayset(self, year, month, day):
+ dset = [None]*self.yearlen
+ start, end = self.mrange[month-1:month+1]
+ for i in range(start, end):
+ dset[i] = i
+ return dset, start, end
+
+ def wdayset(self, year, month, day):
+ # We need to handle cross-year weeks here.
+ dset = [None]*(self.yearlen+7)
+ i = datetime.date(year, month, day).toordinal()-self.yearordinal
+ start = i
+ for j in range(7):
+ dset[i] = i
+ i += 1
+ # if (not (0 <= i < self.yearlen) or
+ # self.wdaymask[i] == self.rrule._wkst):
+ # This will cross the year boundary, if necessary.
+ if self.wdaymask[i] == self.rrule._wkst:
+ break
+ return dset, start, i
+
+ def ddayset(self, year, month, day):
+ dset = [None] * self.yearlen
+ i = datetime.date(year, month, day).toordinal() - self.yearordinal
+ dset[i] = i
+ return dset, i, i + 1
+
+ def htimeset(self, hour, minute, second):
+ tset = []
+ rr = self.rrule
+ for minute in rr._byminute:
+ for second in rr._bysecond:
+ tset.append(datetime.time(hour, minute, second,
+ tzinfo=rr._tzinfo))
+ tset.sort()
+ return tset
+
+ def mtimeset(self, hour, minute, second):
+ tset = []
+ rr = self.rrule
+ for second in rr._bysecond:
+ tset.append(datetime.time(hour, minute, second, tzinfo=rr._tzinfo))
+ tset.sort()
+ return tset
+
+ def stimeset(self, hour, minute, second):
+ return (datetime.time(hour, minute, second,
+ tzinfo=self.rrule._tzinfo),)
+
+
+class rruleset(rrulebase):
+ """ The rruleset type allows more complex recurrence setups, mixing
+ multiple rules, dates, exclusion rules, and exclusion dates. The type
+ constructor takes the following keyword arguments:
+
+ :param cache: If True, caching of results will be enabled, improving
+ performance of multiple queries considerably. """
+
+ class _genitem(object):
+ def __init__(self, genlist, gen):
+ try:
+ self.dt = advance_iterator(gen)
+ genlist.append(self)
+ except StopIteration:
+ pass
+ self.genlist = genlist
+ self.gen = gen
+
+ def __next__(self):
+ try:
+ self.dt = advance_iterator(self.gen)
+ except StopIteration:
+ if self.genlist[0] is self:
+ heapq.heappop(self.genlist)
+ else:
+ self.genlist.remove(self)
+ heapq.heapify(self.genlist)
+
+ next = __next__
+
+ def __lt__(self, other):
+ return self.dt < other.dt
+
+ def __gt__(self, other):
+ return self.dt > other.dt
+
+ def __eq__(self, other):
+ return self.dt == other.dt
+
+ def __ne__(self, other):
+ return self.dt != other.dt
+
+ def __init__(self, cache=False):
+ super(rruleset, self).__init__(cache)
+ self._rrule = []
+ self._rdate = []
+ self._exrule = []
+ self._exdate = []
+
+ @_invalidates_cache
+ def rrule(self, rrule):
+ """ Include the given :py:class:`rrule` instance in the recurrence set
+ generation. """
+ self._rrule.append(rrule)
+
+ @_invalidates_cache
+ def rdate(self, rdate):
+ """ Include the given :py:class:`datetime` instance in the recurrence
+ set generation. """
+ self._rdate.append(rdate)
+
+ @_invalidates_cache
+ def exrule(self, exrule):
+ """ Include the given rrule instance in the recurrence set exclusion
+ list. Dates which are part of the given recurrence rules will not
+ be generated, even if some inclusive rrule or rdate matches them.
+ """
+ self._exrule.append(exrule)
+
+ @_invalidates_cache
+ def exdate(self, exdate):
+ """ Include the given datetime instance in the recurrence set
+ exclusion list. Dates included that way will not be generated,
+ even if some inclusive rrule or rdate matches them. """
+ self._exdate.append(exdate)
+
+ def _iter(self):
+ rlist = []
+ self._rdate.sort()
+ self._genitem(rlist, iter(self._rdate))
+ for gen in [iter(x) for x in self._rrule]:
+ self._genitem(rlist, gen)
+ exlist = []
+ self._exdate.sort()
+ self._genitem(exlist, iter(self._exdate))
+ for gen in [iter(x) for x in self._exrule]:
+ self._genitem(exlist, gen)
+ lastdt = None
+ total = 0
+ heapq.heapify(rlist)
+ heapq.heapify(exlist)
+ while rlist:
+ ritem = rlist[0]
+ if not lastdt or lastdt != ritem.dt:
+ while exlist and exlist[0] < ritem:
+ exitem = exlist[0]
+ advance_iterator(exitem)
+ if exlist and exlist[0] is exitem:
+ heapq.heapreplace(exlist, exitem)
+ if not exlist or ritem != exlist[0]:
+ total += 1
+ yield ritem.dt
+ lastdt = ritem.dt
+ advance_iterator(ritem)
+ if rlist and rlist[0] is ritem:
+ heapq.heapreplace(rlist, ritem)
+ self._len = total
+
+
+
+
+class _rrulestr(object):
+ """ Parses a string representation of a recurrence rule or set of
+ recurrence rules.
+
+ :param s:
+ Required, a string defining one or more recurrence rules.
+
+ :param dtstart:
+ If given, used as the default recurrence start if not specified in the
+ rule string.
+
+ :param cache:
+ If set ``True`` caching of results will be enabled, improving
+ performance of multiple queries considerably.
+
+ :param unfold:
+ If set ``True`` indicates that a rule string is split over more
+ than one line and should be joined before processing.
+
+ :param forceset:
+ If set ``True`` forces a :class:`dateutil.rrule.rruleset` to
+ be returned.
+
+ :param compatible:
+ If set ``True`` forces ``unfold`` and ``forceset`` to be ``True``.
+
+ :param ignoretz:
+ If set ``True``, time zones in parsed strings are ignored and a naive
+ :class:`datetime.datetime` object is returned.
+
+ :param tzids:
+ If given, a callable or mapping used to retrieve a
+ :class:`datetime.tzinfo` from a string representation.
+ Defaults to :func:`dateutil.tz.gettz`.
+
+ :param tzinfos:
+ Additional time zone names / aliases which may be present in a string
+ representation. See :func:`dateutil.parser.parse` for more
+ information.
+
+ :return:
+ Returns a :class:`dateutil.rrule.rruleset` or
+ :class:`dateutil.rrule.rrule`
+ """
+
+ _freq_map = {"YEARLY": YEARLY,
+ "MONTHLY": MONTHLY,
+ "WEEKLY": WEEKLY,
+ "DAILY": DAILY,
+ "HOURLY": HOURLY,
+ "MINUTELY": MINUTELY,
+ "SECONDLY": SECONDLY}
+
+ _weekday_map = {"MO": 0, "TU": 1, "WE": 2, "TH": 3,
+ "FR": 4, "SA": 5, "SU": 6}
+
+ def _handle_int(self, rrkwargs, name, value, **kwargs):
+ rrkwargs[name.lower()] = int(value)
+
+ def _handle_int_list(self, rrkwargs, name, value, **kwargs):
+ rrkwargs[name.lower()] = [int(x) for x in value.split(',')]
+
+ _handle_INTERVAL = _handle_int
+ _handle_COUNT = _handle_int
+ _handle_BYSETPOS = _handle_int_list
+ _handle_BYMONTH = _handle_int_list
+ _handle_BYMONTHDAY = _handle_int_list
+ _handle_BYYEARDAY = _handle_int_list
+ _handle_BYEASTER = _handle_int_list
+ _handle_BYWEEKNO = _handle_int_list
+ _handle_BYHOUR = _handle_int_list
+ _handle_BYMINUTE = _handle_int_list
+ _handle_BYSECOND = _handle_int_list
+
+ def _handle_FREQ(self, rrkwargs, name, value, **kwargs):
+ rrkwargs["freq"] = self._freq_map[value]
+
+ def _handle_UNTIL(self, rrkwargs, name, value, **kwargs):
+ global parser
+ if not parser:
+ from dateutil import parser
+ try:
+ rrkwargs["until"] = parser.parse(value,
+ ignoretz=kwargs.get("ignoretz"),
+ tzinfos=kwargs.get("tzinfos"))
+ except ValueError:
+ raise ValueError("invalid until date")
+
+ def _handle_WKST(self, rrkwargs, name, value, **kwargs):
+ rrkwargs["wkst"] = self._weekday_map[value]
+
+ def _handle_BYWEEKDAY(self, rrkwargs, name, value, **kwargs):
+ """
+ Two ways to specify this: +1MO or MO(+1)
+ """
+ l = []
+ for wday in value.split(','):
+ if '(' in wday:
+ # If it's of the form TH(+1), etc.
+ splt = wday.split('(')
+ w = splt[0]
+ n = int(splt[1][:-1])
+ elif len(wday):
+ # If it's of the form +1MO
+ for i in range(len(wday)):
+ if wday[i] not in '+-0123456789':
+ break
+ n = wday[:i] or None
+ w = wday[i:]
+ if n:
+ n = int(n)
+ else:
+ raise ValueError("Invalid (empty) BYDAY specification.")
+
+ l.append(weekdays[self._weekday_map[w]](n))
+ rrkwargs["byweekday"] = l
+
+ _handle_BYDAY = _handle_BYWEEKDAY
+
+ def _parse_rfc_rrule(self, line,
+ dtstart=None,
+ cache=False,
+ ignoretz=False,
+ tzinfos=None):
+ if line.find(':') != -1:
+ name, value = line.split(':')
+ if name != "RRULE":
+ raise ValueError("unknown parameter name")
+ else:
+ value = line
+ rrkwargs = {}
+ for pair in value.split(';'):
+ name, value = pair.split('=')
+ name = name.upper()
+ value = value.upper()
+ try:
+ getattr(self, "_handle_"+name)(rrkwargs, name, value,
+ ignoretz=ignoretz,
+ tzinfos=tzinfos)
+ except AttributeError:
+ raise ValueError("unknown parameter '%s'" % name)
+ except (KeyError, ValueError):
+ raise ValueError("invalid '%s': %s" % (name, value))
+ return rrule(dtstart=dtstart, cache=cache, **rrkwargs)
+
+ def _parse_date_value(self, date_value, parms, rule_tzids,
+ ignoretz, tzids, tzinfos):
+ global parser
+ if not parser:
+ from dateutil import parser
+
+ datevals = []
+ value_found = False
+ TZID = None
+
+ for parm in parms:
+ if parm.startswith("TZID="):
+ try:
+ tzkey = rule_tzids[parm.split('TZID=')[-1]]
+ except KeyError:
+ continue
+ if tzids is None:
+ from . import tz
+ tzlookup = tz.gettz
+ elif callable(tzids):
+ tzlookup = tzids
+ else:
+ tzlookup = getattr(tzids, 'get', None)
+ if tzlookup is None:
+ msg = ('tzids must be a callable, mapping, or None, '
+ 'not %s' % tzids)
+ raise ValueError(msg)
+
+ TZID = tzlookup(tzkey)
+ continue
+
+ # RFC 5445 3.8.2.4: The VALUE parameter is optional, but may be found
+ # only once.
+ if parm not in {"VALUE=DATE-TIME", "VALUE=DATE"}:
+ raise ValueError("unsupported parm: " + parm)
+ else:
+ if value_found:
+ msg = ("Duplicate value parameter found in: " + parm)
+ raise ValueError(msg)
+ value_found = True
+
+ for datestr in date_value.split(','):
+ date = parser.parse(datestr, ignoretz=ignoretz, tzinfos=tzinfos)
+ if TZID is not None:
+ if date.tzinfo is None:
+ date = date.replace(tzinfo=TZID)
+ else:
+ raise ValueError('DTSTART/EXDATE specifies multiple timezone')
+ datevals.append(date)
+
+ return datevals
+
+ def _parse_rfc(self, s,
+ dtstart=None,
+ cache=False,
+ unfold=False,
+ forceset=False,
+ compatible=False,
+ ignoretz=False,
+ tzids=None,
+ tzinfos=None):
+ global parser
+ if compatible:
+ forceset = True
+ unfold = True
+
+ TZID_NAMES = dict(map(
+ lambda x: (x.upper(), x),
+ re.findall('TZID=(?P[^:]+):', s)
+ ))
+ s = s.upper()
+ if not s.strip():
+ raise ValueError("empty string")
+ if unfold:
+ lines = s.splitlines()
+ i = 0
+ while i < len(lines):
+ line = lines[i].rstrip()
+ if not line:
+ del lines[i]
+ elif i > 0 and line[0] == " ":
+ lines[i-1] += line[1:]
+ del lines[i]
+ else:
+ i += 1
+ else:
+ lines = s.split()
+ if (not forceset and len(lines) == 1 and (s.find(':') == -1 or
+ s.startswith('RRULE:'))):
+ return self._parse_rfc_rrule(lines[0], cache=cache,
+ dtstart=dtstart, ignoretz=ignoretz,
+ tzinfos=tzinfos)
+ else:
+ rrulevals = []
+ rdatevals = []
+ exrulevals = []
+ exdatevals = []
+ for line in lines:
+ if not line:
+ continue
+ if line.find(':') == -1:
+ name = "RRULE"
+ value = line
+ else:
+ name, value = line.split(':', 1)
+ parms = name.split(';')
+ if not parms:
+ raise ValueError("empty property name")
+ name = parms[0]
+ parms = parms[1:]
+ if name == "RRULE":
+ for parm in parms:
+ raise ValueError("unsupported RRULE parm: "+parm)
+ rrulevals.append(value)
+ elif name == "RDATE":
+ for parm in parms:
+ if parm != "VALUE=DATE-TIME":
+ raise ValueError("unsupported RDATE parm: "+parm)
+ rdatevals.append(value)
+ elif name == "EXRULE":
+ for parm in parms:
+ raise ValueError("unsupported EXRULE parm: "+parm)
+ exrulevals.append(value)
+ elif name == "EXDATE":
+ exdatevals.extend(
+ self._parse_date_value(value, parms,
+ TZID_NAMES, ignoretz,
+ tzids, tzinfos)
+ )
+ elif name == "DTSTART":
+ dtvals = self._parse_date_value(value, parms, TZID_NAMES,
+ ignoretz, tzids, tzinfos)
+ if len(dtvals) != 1:
+ raise ValueError("Multiple DTSTART values specified:" +
+ value)
+ dtstart = dtvals[0]
+ else:
+ raise ValueError("unsupported property: "+name)
+ if (forceset or len(rrulevals) > 1 or rdatevals
+ or exrulevals or exdatevals):
+ if not parser and (rdatevals or exdatevals):
+ from dateutil import parser
+ rset = rruleset(cache=cache)
+ for value in rrulevals:
+ rset.rrule(self._parse_rfc_rrule(value, dtstart=dtstart,
+ ignoretz=ignoretz,
+ tzinfos=tzinfos))
+ for value in rdatevals:
+ for datestr in value.split(','):
+ rset.rdate(parser.parse(datestr,
+ ignoretz=ignoretz,
+ tzinfos=tzinfos))
+ for value in exrulevals:
+ rset.exrule(self._parse_rfc_rrule(value, dtstart=dtstart,
+ ignoretz=ignoretz,
+ tzinfos=tzinfos))
+ for value in exdatevals:
+ rset.exdate(value)
+ if compatible and dtstart:
+ rset.rdate(dtstart)
+ return rset
+ else:
+ return self._parse_rfc_rrule(rrulevals[0],
+ dtstart=dtstart,
+ cache=cache,
+ ignoretz=ignoretz,
+ tzinfos=tzinfos)
+
+ def __call__(self, s, **kwargs):
+ return self._parse_rfc(s, **kwargs)
+
+
+rrulestr = _rrulestr()
+
+# vim:ts=4:sw=4:et
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/tzwin.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/tzwin.py
new file mode 100644
index 0000000000000000000000000000000000000000..cebc673e40fc376653ebf037e96f0a6d0b33e906
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/tzwin.py
@@ -0,0 +1,2 @@
+# tzwin has moved to dateutil.tz.win
+from .tz.win import *
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/utils.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebcce6aa2a7e1f1a49bba54330e3ad2f08985c3d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/dateutil/utils.py
@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+"""
+This module offers general convenience and utility functions for dealing with
+datetimes.
+
+.. versionadded:: 2.7.0
+"""
+from __future__ import unicode_literals
+
+from datetime import datetime, time
+
+
+def today(tzinfo=None):
+ """
+ Returns a :py:class:`datetime` representing the current day at midnight
+
+ :param tzinfo:
+ The time zone to attach (also used to determine the current day).
+
+ :return:
+ A :py:class:`datetime.datetime` object representing the current day
+ at midnight.
+ """
+
+ dt = datetime.now(tzinfo)
+ return datetime.combine(dt.date(), time(0, tzinfo=tzinfo))
+
+
+def default_tzinfo(dt, tzinfo):
+ """
+ Sets the the ``tzinfo`` parameter on naive datetimes only
+
+ This is useful for example when you are provided a datetime that may have
+ either an implicit or explicit time zone, such as when parsing a time zone
+ string.
+
+ .. doctest::
+
+ >>> from dateutil.tz import tzoffset
+ >>> from dateutil.parser import parse
+ >>> from dateutil.utils import default_tzinfo
+ >>> dflt_tz = tzoffset("EST", -18000)
+ >>> print(default_tzinfo(parse('2014-01-01 12:30 UTC'), dflt_tz))
+ 2014-01-01 12:30:00+00:00
+ >>> print(default_tzinfo(parse('2014-01-01 12:30'), dflt_tz))
+ 2014-01-01 12:30:00-05:00
+
+ :param dt:
+ The datetime on which to replace the time zone
+
+ :param tzinfo:
+ The :py:class:`datetime.tzinfo` subclass instance to assign to
+ ``dt`` if (and only if) it is naive.
+
+ :return:
+ Returns an aware :py:class:`datetime.datetime`.
+ """
+ if dt.tzinfo is not None:
+ return dt
+ else:
+ return dt.replace(tzinfo=tzinfo)
+
+
+def within_delta(dt1, dt2, delta):
+ """
+ Useful for comparing two datetimes that may a negilible difference
+ to be considered equal.
+ """
+ delta = abs(delta)
+ difference = dt1 - dt2
+ return -delta <= difference <= delta
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/DESCRIPTION.rst b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/DESCRIPTION.rst
new file mode 100644
index 0000000000000000000000000000000000000000..c9acbda168b761545707a89dee56d2fa5445c451
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/DESCRIPTION.rst
@@ -0,0 +1,355 @@
+.. funcsigs documentation master file, created by
+ sphinx-quickstart on Fri Apr 20 20:27:52 2012.
+ You can adapt this file completely to your liking, but it should at least
+ contain the root `toctree` directive.
+
+Introducing funcsigs
+====================
+
+The Funcsigs Package
+--------------------
+
+``funcsigs`` is a backport of the `PEP 362`_ function signature features from
+Python 3.3's `inspect`_ module. The backport is compatible with Python 2.6, 2.7
+as well as 3.3 and up. 3.2 was supported by version 0.4, but with setuptools and
+pip no longer supporting 3.2, we cannot make any statement about 3.2
+compatibility.
+
+Compatibility
+`````````````
+
+The ``funcsigs`` backport has been tested against:
+
+* CPython 2.6
+* CPython 2.7
+* CPython 3.3
+* CPython 3.4
+* CPython 3.5
+* CPython nightlies
+* PyPy and PyPy3(currently failing CI)
+
+Continuous integration testing is provided by `Travis CI`_.
+
+Under Python 2.x there is a compatibility issue when a function is assigned to
+the ``__wrapped__`` property of a class after it has been constructed.
+Similiarily there under PyPy directly passing the ``__call__`` method of a
+builtin is also a compatibility issues. Otherwise the functionality is
+believed to be uniform between both Python2 and Python3.
+
+Issues
+``````
+
+Source code for ``funcsigs`` is hosted on `GitHub`_. Any bug reports or feature
+requests can be made using GitHub's `issues system`_. |build_status| |coverage|
+
+Example
+-------
+
+To obtain a `Signature` object, pass the target function to the
+``funcsigs.signature`` function.
+
+.. code-block:: python
+
+ >>> from funcsigs import signature
+ >>> def foo(a, b=None, *args, **kwargs):
+ ... pass
+ ...
+ >>> sig = signature(foo)
+ >>> sig
+
+ >>> sig.parameters
+ OrderedDict([('a', ), ('b', ), ('args', ), ('kwargs', )])
+ >>> sig.return_annotation
+
+
+Introspecting callables with the Signature object
+-------------------------------------------------
+
+.. note::
+
+ This section of documentation is a direct reproduction of the Python
+ standard library documentation for the inspect module.
+
+The Signature object represents the call signature of a callable object and its
+return annotation. To retrieve a Signature object, use the :func:`signature`
+function.
+
+.. function:: signature(callable)
+
+ Return a :class:`Signature` object for the given ``callable``::
+
+ >>> from funcsigs import signature
+ >>> def foo(a, *, b:int, **kwargs):
+ ... pass
+
+ >>> sig = signature(foo)
+
+ >>> str(sig)
+ '(a, *, b:int, **kwargs)'
+
+ >>> str(sig.parameters['b'])
+ 'b:int'
+
+ >>> sig.parameters['b'].annotation
+
+
+ Accepts a wide range of python callables, from plain functions and classes to
+ :func:`functools.partial` objects.
+
+ .. note::
+
+ Some callables may not be introspectable in certain implementations of
+ Python. For example, in CPython, built-in functions defined in C provide
+ no metadata about their arguments.
+
+
+.. class:: Signature
+
+ A Signature object represents the call signature of a function and its return
+ annotation. For each parameter accepted by the function it stores a
+ :class:`Parameter` object in its :attr:`parameters` collection.
+
+ Signature objects are *immutable*. Use :meth:`Signature.replace` to make a
+ modified copy.
+
+ .. attribute:: Signature.empty
+
+ A special class-level marker to specify absence of a return annotation.
+
+ .. attribute:: Signature.parameters
+
+ An ordered mapping of parameters' names to the corresponding
+ :class:`Parameter` objects.
+
+ .. attribute:: Signature.return_annotation
+
+ The "return" annotation for the callable. If the callable has no "return"
+ annotation, this attribute is set to :attr:`Signature.empty`.
+
+ .. method:: Signature.bind(*args, **kwargs)
+
+ Create a mapping from positional and keyword arguments to parameters.
+ Returns :class:`BoundArguments` if ``*args`` and ``**kwargs`` match the
+ signature, or raises a :exc:`TypeError`.
+
+ .. method:: Signature.bind_partial(*args, **kwargs)
+
+ Works the same way as :meth:`Signature.bind`, but allows the omission of
+ some required arguments (mimics :func:`functools.partial` behavior.)
+ Returns :class:`BoundArguments`, or raises a :exc:`TypeError` if the
+ passed arguments do not match the signature.
+
+ .. method:: Signature.replace(*[, parameters][, return_annotation])
+
+ Create a new Signature instance based on the instance replace was invoked
+ on. It is possible to pass different ``parameters`` and/or
+ ``return_annotation`` to override the corresponding properties of the base
+ signature. To remove return_annotation from the copied Signature, pass in
+ :attr:`Signature.empty`.
+
+ ::
+
+ >>> def test(a, b):
+ ... pass
+ >>> sig = signature(test)
+ >>> new_sig = sig.replace(return_annotation="new return anno")
+ >>> str(new_sig)
+ "(a, b) -> 'new return anno'"
+
+
+.. class:: Parameter
+
+ Parameter objects are *immutable*. Instead of modifying a Parameter object,
+ you can use :meth:`Parameter.replace` to create a modified copy.
+
+ .. attribute:: Parameter.empty
+
+ A special class-level marker to specify absence of default values and
+ annotations.
+
+ .. attribute:: Parameter.name
+
+ The name of the parameter as a string. Must be a valid python identifier
+ name (with the exception of ``POSITIONAL_ONLY`` parameters, which can have
+ it set to ``None``).
+
+ .. attribute:: Parameter.default
+
+ The default value for the parameter. If the parameter has no default
+ value, this attribute is set to :attr:`Parameter.empty`.
+
+ .. attribute:: Parameter.annotation
+
+ The annotation for the parameter. If the parameter has no annotation,
+ this attribute is set to :attr:`Parameter.empty`.
+
+ .. attribute:: Parameter.kind
+
+ Describes how argument values are bound to the parameter. Possible values
+ (accessible via :class:`Parameter`, like ``Parameter.KEYWORD_ONLY``):
+
+ +------------------------+----------------------------------------------+
+ | Name | Meaning |
+ +========================+==============================================+
+ | *POSITIONAL_ONLY* | Value must be supplied as a positional |
+ | | argument. |
+ | | |
+ | | Python has no explicit syntax for defining |
+ | | positional-only parameters, but many built-in|
+ | | and extension module functions (especially |
+ | | those that accept only one or two parameters)|
+ | | accept them. |
+ +------------------------+----------------------------------------------+
+ | *POSITIONAL_OR_KEYWORD*| Value may be supplied as either a keyword or |
+ | | positional argument (this is the standard |
+ | | binding behaviour for functions implemented |
+ | | in Python.) |
+ +------------------------+----------------------------------------------+
+ | *VAR_POSITIONAL* | A tuple of positional arguments that aren't |
+ | | bound to any other parameter. This |
+ | | corresponds to a ``*args`` parameter in a |
+ | | Python function definition. |
+ +------------------------+----------------------------------------------+
+ | *KEYWORD_ONLY* | Value must be supplied as a keyword argument.|
+ | | Keyword only parameters are those which |
+ | | appear after a ``*`` or ``*args`` entry in a |
+ | | Python function definition. |
+ +------------------------+----------------------------------------------+
+ | *VAR_KEYWORD* | A dict of keyword arguments that aren't bound|
+ | | to any other parameter. This corresponds to a|
+ | | ``**kwargs`` parameter in a Python function |
+ | | definition. |
+ +------------------------+----------------------------------------------+
+
+ Example: print all keyword-only arguments without default values::
+
+ >>> def foo(a, b, *, c, d=10):
+ ... pass
+
+ >>> sig = signature(foo)
+ >>> for param in sig.parameters.values():
+ ... if (param.kind == param.KEYWORD_ONLY and
+ ... param.default is param.empty):
+ ... print('Parameter:', param)
+ Parameter: c
+
+ .. method:: Parameter.replace(*[, name][, kind][, default][, annotation])
+
+ Create a new Parameter instance based on the instance replaced was invoked
+ on. To override a :class:`Parameter` attribute, pass the corresponding
+ argument. To remove a default value or/and an annotation from a
+ Parameter, pass :attr:`Parameter.empty`.
+
+ ::
+
+ >>> from funcsigs import Parameter
+ >>> param = Parameter('foo', Parameter.KEYWORD_ONLY, default=42)
+ >>> str(param)
+ 'foo=42'
+
+ >>> str(param.replace()) # Will create a shallow copy of 'param'
+ 'foo=42'
+
+ >>> str(param.replace(default=Parameter.empty, annotation='spam'))
+ "foo:'spam'"
+
+
+.. class:: BoundArguments
+
+ Result of a :meth:`Signature.bind` or :meth:`Signature.bind_partial` call.
+ Holds the mapping of arguments to the function's parameters.
+
+ .. attribute:: BoundArguments.arguments
+
+ An ordered, mutable mapping (:class:`collections.OrderedDict`) of
+ parameters' names to arguments' values. Contains only explicitly bound
+ arguments. Changes in :attr:`arguments` will reflect in :attr:`args` and
+ :attr:`kwargs`.
+
+ Should be used in conjunction with :attr:`Signature.parameters` for any
+ argument processing purposes.
+
+ .. note::
+
+ Arguments for which :meth:`Signature.bind` or
+ :meth:`Signature.bind_partial` relied on a default value are skipped.
+ However, if needed, it is easy to include them.
+
+ ::
+
+ >>> def foo(a, b=10):
+ ... pass
+
+ >>> sig = signature(foo)
+ >>> ba = sig.bind(5)
+
+ >>> ba.args, ba.kwargs
+ ((5,), {})
+
+ >>> for param in sig.parameters.values():
+ ... if param.name not in ba.arguments:
+ ... ba.arguments[param.name] = param.default
+
+ >>> ba.args, ba.kwargs
+ ((5, 10), {})
+
+
+ .. attribute:: BoundArguments.args
+
+ A tuple of positional arguments values. Dynamically computed from the
+ :attr:`arguments` attribute.
+
+ .. attribute:: BoundArguments.kwargs
+
+ A dict of keyword arguments values. Dynamically computed from the
+ :attr:`arguments` attribute.
+
+ The :attr:`args` and :attr:`kwargs` properties can be used to invoke
+ functions::
+
+ def test(a, *, b):
+ ...
+
+ sig = signature(test)
+ ba = sig.bind(10, b=20)
+ test(*ba.args, **ba.kwargs)
+
+
+.. seealso::
+
+ :pep:`362` - Function Signature Object.
+ The detailed specification, implementation details and examples.
+
+Copyright
+---------
+
+*funcsigs* is a derived work of CPython under the terms of the `PSF License
+Agreement`_. The original CPython inspect module, its unit tests and
+documentation are the copyright of the Python Software Foundation. The derived
+work is distributed under the `Apache License Version 2.0`_.
+
+.. _PSF License Agreement: http://docs.python.org/3/license.html#terms-and-conditions-for-accessing-or-otherwise-using-python
+.. _Apache License Version 2.0: http://opensource.org/licenses/Apache-2.0
+.. _GitHub: https://github.com/testing-cabal/funcsigs
+.. _PSF License Agreement: http://docs.python.org/3/license.html#terms-and-conditions-for-accessing-or-otherwise-using-python
+.. _Travis CI: http://travis-ci.org/
+.. _Read The Docs: http://funcsigs.readthedocs.org/
+.. _PEP 362: http://www.python.org/dev/peps/pep-0362/
+.. _inspect: http://docs.python.org/3/library/inspect.html#introspecting-callables-with-the-signature-object
+.. _issues system: https://github.com/testing-cabal/funcsigs/issues
+
+.. |build_status| image:: https://secure.travis-ci.org/aliles/funcsigs.png?branch=master
+ :target: http://travis-ci.org/#!/aliles/funcsigs
+ :alt: Current build status
+
+.. |coverage| image:: https://coveralls.io/repos/aliles/funcsigs/badge.png?branch=master
+ :target: https://coveralls.io/r/aliles/funcsigs?branch=master
+ :alt: Coverage status
+
+.. |pypi_version| image:: https://pypip.in/v/funcsigs/badge.png
+ :target: https://crate.io/packages/funcsigs/
+ :alt: Latest PyPI version
+
+
+
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/INSTALLER b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/METADATA b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..d584890b947f1d85d866a16ee43064eae6bb83fb
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/METADATA
@@ -0,0 +1,381 @@
+Metadata-Version: 2.0
+Name: funcsigs
+Version: 1.0.2
+Summary: Python function signatures from PEP362 for Python 2.6, 2.7 and 3.2+
+Home-page: http://funcsigs.readthedocs.org
+Author: Testing Cabal
+Author-email: testing-in-python@lists.idyll.org
+License: ASL
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: ordereddict; python_version<"2.7"
+
+.. funcsigs documentation master file, created by
+ sphinx-quickstart on Fri Apr 20 20:27:52 2012.
+ You can adapt this file completely to your liking, but it should at least
+ contain the root `toctree` directive.
+
+Introducing funcsigs
+====================
+
+The Funcsigs Package
+--------------------
+
+``funcsigs`` is a backport of the `PEP 362`_ function signature features from
+Python 3.3's `inspect`_ module. The backport is compatible with Python 2.6, 2.7
+as well as 3.3 and up. 3.2 was supported by version 0.4, but with setuptools and
+pip no longer supporting 3.2, we cannot make any statement about 3.2
+compatibility.
+
+Compatibility
+`````````````
+
+The ``funcsigs`` backport has been tested against:
+
+* CPython 2.6
+* CPython 2.7
+* CPython 3.3
+* CPython 3.4
+* CPython 3.5
+* CPython nightlies
+* PyPy and PyPy3(currently failing CI)
+
+Continuous integration testing is provided by `Travis CI`_.
+
+Under Python 2.x there is a compatibility issue when a function is assigned to
+the ``__wrapped__`` property of a class after it has been constructed.
+Similiarily there under PyPy directly passing the ``__call__`` method of a
+builtin is also a compatibility issues. Otherwise the functionality is
+believed to be uniform between both Python2 and Python3.
+
+Issues
+``````
+
+Source code for ``funcsigs`` is hosted on `GitHub`_. Any bug reports or feature
+requests can be made using GitHub's `issues system`_. |build_status| |coverage|
+
+Example
+-------
+
+To obtain a `Signature` object, pass the target function to the
+``funcsigs.signature`` function.
+
+.. code-block:: python
+
+ >>> from funcsigs import signature
+ >>> def foo(a, b=None, *args, **kwargs):
+ ... pass
+ ...
+ >>> sig = signature(foo)
+ >>> sig
+
+ >>> sig.parameters
+ OrderedDict([('a', ), ('b', ), ('args', ), ('kwargs', )])
+ >>> sig.return_annotation
+
+
+Introspecting callables with the Signature object
+-------------------------------------------------
+
+.. note::
+
+ This section of documentation is a direct reproduction of the Python
+ standard library documentation for the inspect module.
+
+The Signature object represents the call signature of a callable object and its
+return annotation. To retrieve a Signature object, use the :func:`signature`
+function.
+
+.. function:: signature(callable)
+
+ Return a :class:`Signature` object for the given ``callable``::
+
+ >>> from funcsigs import signature
+ >>> def foo(a, *, b:int, **kwargs):
+ ... pass
+
+ >>> sig = signature(foo)
+
+ >>> str(sig)
+ '(a, *, b:int, **kwargs)'
+
+ >>> str(sig.parameters['b'])
+ 'b:int'
+
+ >>> sig.parameters['b'].annotation
+
+
+ Accepts a wide range of python callables, from plain functions and classes to
+ :func:`functools.partial` objects.
+
+ .. note::
+
+ Some callables may not be introspectable in certain implementations of
+ Python. For example, in CPython, built-in functions defined in C provide
+ no metadata about their arguments.
+
+
+.. class:: Signature
+
+ A Signature object represents the call signature of a function and its return
+ annotation. For each parameter accepted by the function it stores a
+ :class:`Parameter` object in its :attr:`parameters` collection.
+
+ Signature objects are *immutable*. Use :meth:`Signature.replace` to make a
+ modified copy.
+
+ .. attribute:: Signature.empty
+
+ A special class-level marker to specify absence of a return annotation.
+
+ .. attribute:: Signature.parameters
+
+ An ordered mapping of parameters' names to the corresponding
+ :class:`Parameter` objects.
+
+ .. attribute:: Signature.return_annotation
+
+ The "return" annotation for the callable. If the callable has no "return"
+ annotation, this attribute is set to :attr:`Signature.empty`.
+
+ .. method:: Signature.bind(*args, **kwargs)
+
+ Create a mapping from positional and keyword arguments to parameters.
+ Returns :class:`BoundArguments` if ``*args`` and ``**kwargs`` match the
+ signature, or raises a :exc:`TypeError`.
+
+ .. method:: Signature.bind_partial(*args, **kwargs)
+
+ Works the same way as :meth:`Signature.bind`, but allows the omission of
+ some required arguments (mimics :func:`functools.partial` behavior.)
+ Returns :class:`BoundArguments`, or raises a :exc:`TypeError` if the
+ passed arguments do not match the signature.
+
+ .. method:: Signature.replace(*[, parameters][, return_annotation])
+
+ Create a new Signature instance based on the instance replace was invoked
+ on. It is possible to pass different ``parameters`` and/or
+ ``return_annotation`` to override the corresponding properties of the base
+ signature. To remove return_annotation from the copied Signature, pass in
+ :attr:`Signature.empty`.
+
+ ::
+
+ >>> def test(a, b):
+ ... pass
+ >>> sig = signature(test)
+ >>> new_sig = sig.replace(return_annotation="new return anno")
+ >>> str(new_sig)
+ "(a, b) -> 'new return anno'"
+
+
+.. class:: Parameter
+
+ Parameter objects are *immutable*. Instead of modifying a Parameter object,
+ you can use :meth:`Parameter.replace` to create a modified copy.
+
+ .. attribute:: Parameter.empty
+
+ A special class-level marker to specify absence of default values and
+ annotations.
+
+ .. attribute:: Parameter.name
+
+ The name of the parameter as a string. Must be a valid python identifier
+ name (with the exception of ``POSITIONAL_ONLY`` parameters, which can have
+ it set to ``None``).
+
+ .. attribute:: Parameter.default
+
+ The default value for the parameter. If the parameter has no default
+ value, this attribute is set to :attr:`Parameter.empty`.
+
+ .. attribute:: Parameter.annotation
+
+ The annotation for the parameter. If the parameter has no annotation,
+ this attribute is set to :attr:`Parameter.empty`.
+
+ .. attribute:: Parameter.kind
+
+ Describes how argument values are bound to the parameter. Possible values
+ (accessible via :class:`Parameter`, like ``Parameter.KEYWORD_ONLY``):
+
+ +------------------------+----------------------------------------------+
+ | Name | Meaning |
+ +========================+==============================================+
+ | *POSITIONAL_ONLY* | Value must be supplied as a positional |
+ | | argument. |
+ | | |
+ | | Python has no explicit syntax for defining |
+ | | positional-only parameters, but many built-in|
+ | | and extension module functions (especially |
+ | | those that accept only one or two parameters)|
+ | | accept them. |
+ +------------------------+----------------------------------------------+
+ | *POSITIONAL_OR_KEYWORD*| Value may be supplied as either a keyword or |
+ | | positional argument (this is the standard |
+ | | binding behaviour for functions implemented |
+ | | in Python.) |
+ +------------------------+----------------------------------------------+
+ | *VAR_POSITIONAL* | A tuple of positional arguments that aren't |
+ | | bound to any other parameter. This |
+ | | corresponds to a ``*args`` parameter in a |
+ | | Python function definition. |
+ +------------------------+----------------------------------------------+
+ | *KEYWORD_ONLY* | Value must be supplied as a keyword argument.|
+ | | Keyword only parameters are those which |
+ | | appear after a ``*`` or ``*args`` entry in a |
+ | | Python function definition. |
+ +------------------------+----------------------------------------------+
+ | *VAR_KEYWORD* | A dict of keyword arguments that aren't bound|
+ | | to any other parameter. This corresponds to a|
+ | | ``**kwargs`` parameter in a Python function |
+ | | definition. |
+ +------------------------+----------------------------------------------+
+
+ Example: print all keyword-only arguments without default values::
+
+ >>> def foo(a, b, *, c, d=10):
+ ... pass
+
+ >>> sig = signature(foo)
+ >>> for param in sig.parameters.values():
+ ... if (param.kind == param.KEYWORD_ONLY and
+ ... param.default is param.empty):
+ ... print('Parameter:', param)
+ Parameter: c
+
+ .. method:: Parameter.replace(*[, name][, kind][, default][, annotation])
+
+ Create a new Parameter instance based on the instance replaced was invoked
+ on. To override a :class:`Parameter` attribute, pass the corresponding
+ argument. To remove a default value or/and an annotation from a
+ Parameter, pass :attr:`Parameter.empty`.
+
+ ::
+
+ >>> from funcsigs import Parameter
+ >>> param = Parameter('foo', Parameter.KEYWORD_ONLY, default=42)
+ >>> str(param)
+ 'foo=42'
+
+ >>> str(param.replace()) # Will create a shallow copy of 'param'
+ 'foo=42'
+
+ >>> str(param.replace(default=Parameter.empty, annotation='spam'))
+ "foo:'spam'"
+
+
+.. class:: BoundArguments
+
+ Result of a :meth:`Signature.bind` or :meth:`Signature.bind_partial` call.
+ Holds the mapping of arguments to the function's parameters.
+
+ .. attribute:: BoundArguments.arguments
+
+ An ordered, mutable mapping (:class:`collections.OrderedDict`) of
+ parameters' names to arguments' values. Contains only explicitly bound
+ arguments. Changes in :attr:`arguments` will reflect in :attr:`args` and
+ :attr:`kwargs`.
+
+ Should be used in conjunction with :attr:`Signature.parameters` for any
+ argument processing purposes.
+
+ .. note::
+
+ Arguments for which :meth:`Signature.bind` or
+ :meth:`Signature.bind_partial` relied on a default value are skipped.
+ However, if needed, it is easy to include them.
+
+ ::
+
+ >>> def foo(a, b=10):
+ ... pass
+
+ >>> sig = signature(foo)
+ >>> ba = sig.bind(5)
+
+ >>> ba.args, ba.kwargs
+ ((5,), {})
+
+ >>> for param in sig.parameters.values():
+ ... if param.name not in ba.arguments:
+ ... ba.arguments[param.name] = param.default
+
+ >>> ba.args, ba.kwargs
+ ((5, 10), {})
+
+
+ .. attribute:: BoundArguments.args
+
+ A tuple of positional arguments values. Dynamically computed from the
+ :attr:`arguments` attribute.
+
+ .. attribute:: BoundArguments.kwargs
+
+ A dict of keyword arguments values. Dynamically computed from the
+ :attr:`arguments` attribute.
+
+ The :attr:`args` and :attr:`kwargs` properties can be used to invoke
+ functions::
+
+ def test(a, *, b):
+ ...
+
+ sig = signature(test)
+ ba = sig.bind(10, b=20)
+ test(*ba.args, **ba.kwargs)
+
+
+.. seealso::
+
+ :pep:`362` - Function Signature Object.
+ The detailed specification, implementation details and examples.
+
+Copyright
+---------
+
+*funcsigs* is a derived work of CPython under the terms of the `PSF License
+Agreement`_. The original CPython inspect module, its unit tests and
+documentation are the copyright of the Python Software Foundation. The derived
+work is distributed under the `Apache License Version 2.0`_.
+
+.. _PSF License Agreement: http://docs.python.org/3/license.html#terms-and-conditions-for-accessing-or-otherwise-using-python
+.. _Apache License Version 2.0: http://opensource.org/licenses/Apache-2.0
+.. _GitHub: https://github.com/testing-cabal/funcsigs
+.. _PSF License Agreement: http://docs.python.org/3/license.html#terms-and-conditions-for-accessing-or-otherwise-using-python
+.. _Travis CI: http://travis-ci.org/
+.. _Read The Docs: http://funcsigs.readthedocs.org/
+.. _PEP 362: http://www.python.org/dev/peps/pep-0362/
+.. _inspect: http://docs.python.org/3/library/inspect.html#introspecting-callables-with-the-signature-object
+.. _issues system: https://github.com/testing-cabal/funcsigs/issues
+
+.. |build_status| image:: https://secure.travis-ci.org/aliles/funcsigs.png?branch=master
+ :target: http://travis-ci.org/#!/aliles/funcsigs
+ :alt: Current build status
+
+.. |coverage| image:: https://coveralls.io/repos/aliles/funcsigs/badge.png?branch=master
+ :target: https://coveralls.io/r/aliles/funcsigs?branch=master
+ :alt: Coverage status
+
+.. |pypi_version| image:: https://pypip.in/v/funcsigs/badge.png
+ :target: https://crate.io/packages/funcsigs/
+ :alt: Latest PyPI version
+
+
+
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/RECORD b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..8b93a82f119754322bf617e3b8e5a14be2b6e340
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/RECORD
@@ -0,0 +1,12 @@
+funcsigs-1.0.2.dist-info/DESCRIPTION.rst,sha256=aVg6hYTYjY6A9-oI4-lhQ9UEqeu0L3kn7LthaPgOYtY,13297
+funcsigs-1.0.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+funcsigs-1.0.2.dist-info/METADATA,sha256=fIBrN18etIHPSCZe0aq8SUSlmBwfvtl02Ce_thKVFtk,14420
+funcsigs-1.0.2.dist-info/RECORD,,
+funcsigs-1.0.2.dist-info/WHEEL,sha256=o2k-Qa-RMNIJmUdIc7KU6VWR_ErNRbWNlxDIpl7lm34,110
+funcsigs-1.0.2.dist-info/metadata.json,sha256=NDDdI0osHQ-zi-4gvTivhTHSrTxME8fHKRCAfJ5NXj0,1294
+funcsigs-1.0.2.dist-info/pbr.json,sha256=TM9nSbjgR_z-OvEdNqbILWOYhlmpDbujt8yM_OHBwxM,46
+funcsigs-1.0.2.dist-info/top_level.txt,sha256=p0FFcT9rWjPboZWPK-LlnMEST6D8xzf6RvETJeNIsNs,9
+funcsigs/__init__.py,sha256=GV4YulgeGW1IDS3l4__glZnbTJolLD_UGAFAhSGWOC8,30390
+funcsigs/__init__.pyc,,
+funcsigs/version.py,sha256=Y3LSfRioSl2xch70pq_ULlvyECXyEtN3krVaWeGyaxk,22
+funcsigs/version.pyc,,
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/metadata.json b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/metadata.json
new file mode 100644
index 0000000000000000000000000000000000000000..0753fdfb9ff96ad8c995e12f8824836de9332cf4
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/metadata.json
@@ -0,0 +1 @@
+{"classifiers": ["Development Status :: 4 - Beta", "Intended Audience :: Developers", "License :: OSI Approved :: Apache Software License", "Operating System :: OS Independent", "Programming Language :: Python", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: Implementation :: CPython", "Programming Language :: Python :: Implementation :: PyPy", "Topic :: Software Development :: Libraries :: Python Modules"], "extensions": {"python.details": {"contacts": [{"email": "testing-in-python@lists.idyll.org", "name": "Testing Cabal", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "http://funcsigs.readthedocs.org"}}}, "extras": [], "generator": "bdist_wheel (0.29.0)", "license": "ASL", "metadata_version": "2.0", "name": "funcsigs", "run_requires": [{"environment": "python_version<\"2.7\"", "requires": ["ordereddict"]}], "summary": "Python function signatures from PEP362 for Python 2.6, 2.7 and 3.2+", "test_requires": [{"requires": ["unittest2"]}], "version": "1.0.2"}
\ No newline at end of file
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/pbr.json b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/pbr.json
new file mode 100644
index 0000000000000000000000000000000000000000..16c4e27a88570457ea274e7ee2ee195536a13fb6
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs-1.0.2.dist-info/pbr.json
@@ -0,0 +1 @@
+{"is_release": true, "git_version": "1b88d78"}
\ No newline at end of file
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f5378b42a6d27cf490d66ae2b79c76bb466cedf
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs/__init__.py
@@ -0,0 +1,829 @@
+# Copyright 2001-2013 Python Software Foundation; All Rights Reserved
+"""Function signature objects for callables
+
+Back port of Python 3.3's function signature tools from the inspect module,
+modified to be compatible with Python 2.6, 2.7 and 3.3+.
+"""
+from __future__ import absolute_import, division, print_function
+import itertools
+import functools
+import re
+import types
+
+try:
+ from collections import OrderedDict
+except ImportError:
+ from ordereddict import OrderedDict
+
+from funcsigs.version import __version__
+
+__all__ = ['BoundArguments', 'Parameter', 'Signature', 'signature']
+
+
+_WrapperDescriptor = type(type.__call__)
+_MethodWrapper = type(all.__call__)
+
+_NonUserDefinedCallables = (_WrapperDescriptor,
+ _MethodWrapper,
+ types.BuiltinFunctionType)
+
+
+def formatannotation(annotation, base_module=None):
+ if isinstance(annotation, type):
+ if annotation.__module__ in ('builtins', '__builtin__', base_module):
+ return annotation.__name__
+ return annotation.__module__+'.'+annotation.__name__
+ return repr(annotation)
+
+
+def _get_user_defined_method(cls, method_name, *nested):
+ try:
+ if cls is type:
+ return
+ meth = getattr(cls, method_name)
+ for name in nested:
+ meth = getattr(meth, name, meth)
+ except AttributeError:
+ return
+ else:
+ if not isinstance(meth, _NonUserDefinedCallables):
+ # Once '__signature__' will be added to 'C'-level
+ # callables, this check won't be necessary
+ return meth
+
+
+def signature(obj):
+ '''Get a signature object for the passed callable.'''
+
+ if not callable(obj):
+ raise TypeError('{0!r} is not a callable object'.format(obj))
+
+ if isinstance(obj, types.MethodType):
+ sig = signature(obj.__func__)
+ if obj.__self__ is None:
+ # Unbound method - preserve as-is.
+ return sig
+ else:
+ # Bound method. Eat self - if we can.
+ params = tuple(sig.parameters.values())
+
+ if not params or params[0].kind in (_VAR_KEYWORD, _KEYWORD_ONLY):
+ raise ValueError('invalid method signature')
+
+ kind = params[0].kind
+ if kind in (_POSITIONAL_OR_KEYWORD, _POSITIONAL_ONLY):
+ # Drop first parameter:
+ # '(p1, p2[, ...])' -> '(p2[, ...])'
+ params = params[1:]
+ else:
+ if kind is not _VAR_POSITIONAL:
+ # Unless we add a new parameter type we never
+ # get here
+ raise ValueError('invalid argument type')
+ # It's a var-positional parameter.
+ # Do nothing. '(*args[, ...])' -> '(*args[, ...])'
+
+ return sig.replace(parameters=params)
+
+ try:
+ sig = obj.__signature__
+ except AttributeError:
+ pass
+ else:
+ if sig is not None:
+ return sig
+
+ try:
+ # Was this function wrapped by a decorator?
+ wrapped = obj.__wrapped__
+ except AttributeError:
+ pass
+ else:
+ return signature(wrapped)
+
+ if isinstance(obj, types.FunctionType):
+ return Signature.from_function(obj)
+
+ if isinstance(obj, functools.partial):
+ sig = signature(obj.func)
+
+ new_params = OrderedDict(sig.parameters.items())
+
+ partial_args = obj.args or ()
+ partial_keywords = obj.keywords or {}
+ try:
+ ba = sig.bind_partial(*partial_args, **partial_keywords)
+ except TypeError as ex:
+ msg = 'partial object {0!r} has incorrect arguments'.format(obj)
+ raise ValueError(msg)
+
+ for arg_name, arg_value in ba.arguments.items():
+ param = new_params[arg_name]
+ if arg_name in partial_keywords:
+ # We set a new default value, because the following code
+ # is correct:
+ #
+ # >>> def foo(a): print(a)
+ # >>> print(partial(partial(foo, a=10), a=20)())
+ # 20
+ # >>> print(partial(partial(foo, a=10), a=20)(a=30))
+ # 30
+ #
+ # So, with 'partial' objects, passing a keyword argument is
+ # like setting a new default value for the corresponding
+ # parameter
+ #
+ # We also mark this parameter with '_partial_kwarg'
+ # flag. Later, in '_bind', the 'default' value of this
+ # parameter will be added to 'kwargs', to simulate
+ # the 'functools.partial' real call.
+ new_params[arg_name] = param.replace(default=arg_value,
+ _partial_kwarg=True)
+
+ elif (param.kind not in (_VAR_KEYWORD, _VAR_POSITIONAL) and
+ not param._partial_kwarg):
+ new_params.pop(arg_name)
+
+ return sig.replace(parameters=new_params.values())
+
+ sig = None
+ if isinstance(obj, type):
+ # obj is a class or a metaclass
+
+ # First, let's see if it has an overloaded __call__ defined
+ # in its metaclass
+ call = _get_user_defined_method(type(obj), '__call__')
+ if call is not None:
+ sig = signature(call)
+ else:
+ # Now we check if the 'obj' class has a '__new__' method
+ new = _get_user_defined_method(obj, '__new__')
+ if new is not None:
+ sig = signature(new)
+ else:
+ # Finally, we should have at least __init__ implemented
+ init = _get_user_defined_method(obj, '__init__')
+ if init is not None:
+ sig = signature(init)
+ elif not isinstance(obj, _NonUserDefinedCallables):
+ # An object with __call__
+ # We also check that the 'obj' is not an instance of
+ # _WrapperDescriptor or _MethodWrapper to avoid
+ # infinite recursion (and even potential segfault)
+ call = _get_user_defined_method(type(obj), '__call__', 'im_func')
+ if call is not None:
+ sig = signature(call)
+
+ if sig is not None:
+ # For classes and objects we skip the first parameter of their
+ # __call__, __new__, or __init__ methods
+ return sig.replace(parameters=tuple(sig.parameters.values())[1:])
+
+ if isinstance(obj, types.BuiltinFunctionType):
+ # Raise a nicer error message for builtins
+ msg = 'no signature found for builtin function {0!r}'.format(obj)
+ raise ValueError(msg)
+
+ raise ValueError('callable {0!r} is not supported by signature'.format(obj))
+
+
+class _void(object):
+ '''A private marker - used in Parameter & Signature'''
+
+
+class _empty(object):
+ pass
+
+
+class _ParameterKind(int):
+ def __new__(self, *args, **kwargs):
+ obj = int.__new__(self, *args)
+ obj._name = kwargs['name']
+ return obj
+
+ def __str__(self):
+ return self._name
+
+ def __repr__(self):
+ return '<_ParameterKind: {0!r}>'.format(self._name)
+
+
+_POSITIONAL_ONLY = _ParameterKind(0, name='POSITIONAL_ONLY')
+_POSITIONAL_OR_KEYWORD = _ParameterKind(1, name='POSITIONAL_OR_KEYWORD')
+_VAR_POSITIONAL = _ParameterKind(2, name='VAR_POSITIONAL')
+_KEYWORD_ONLY = _ParameterKind(3, name='KEYWORD_ONLY')
+_VAR_KEYWORD = _ParameterKind(4, name='VAR_KEYWORD')
+
+
+class Parameter(object):
+ '''Represents a parameter in a function signature.
+
+ Has the following public attributes:
+
+ * name : str
+ The name of the parameter as a string.
+ * default : object
+ The default value for the parameter if specified. If the
+ parameter has no default value, this attribute is not set.
+ * annotation
+ The annotation for the parameter if specified. If the
+ parameter has no annotation, this attribute is not set.
+ * kind : str
+ Describes how argument values are bound to the parameter.
+ Possible values: `Parameter.POSITIONAL_ONLY`,
+ `Parameter.POSITIONAL_OR_KEYWORD`, `Parameter.VAR_POSITIONAL`,
+ `Parameter.KEYWORD_ONLY`, `Parameter.VAR_KEYWORD`.
+ '''
+
+ __slots__ = ('_name', '_kind', '_default', '_annotation', '_partial_kwarg')
+
+ POSITIONAL_ONLY = _POSITIONAL_ONLY
+ POSITIONAL_OR_KEYWORD = _POSITIONAL_OR_KEYWORD
+ VAR_POSITIONAL = _VAR_POSITIONAL
+ KEYWORD_ONLY = _KEYWORD_ONLY
+ VAR_KEYWORD = _VAR_KEYWORD
+
+ empty = _empty
+
+ def __init__(self, name, kind, default=_empty, annotation=_empty,
+ _partial_kwarg=False):
+
+ if kind not in (_POSITIONAL_ONLY, _POSITIONAL_OR_KEYWORD,
+ _VAR_POSITIONAL, _KEYWORD_ONLY, _VAR_KEYWORD):
+ raise ValueError("invalid value for 'Parameter.kind' attribute")
+ self._kind = kind
+
+ if default is not _empty:
+ if kind in (_VAR_POSITIONAL, _VAR_KEYWORD):
+ msg = '{0} parameters cannot have default values'.format(kind)
+ raise ValueError(msg)
+ self._default = default
+ self._annotation = annotation
+
+ if name is None:
+ if kind != _POSITIONAL_ONLY:
+ raise ValueError("None is not a valid name for a "
+ "non-positional-only parameter")
+ self._name = name
+ else:
+ name = str(name)
+ if kind != _POSITIONAL_ONLY and not re.match(r'[a-z_]\w*$', name, re.I):
+ msg = '{0!r} is not a valid parameter name'.format(name)
+ raise ValueError(msg)
+ self._name = name
+
+ self._partial_kwarg = _partial_kwarg
+
+ @property
+ def name(self):
+ return self._name
+
+ @property
+ def default(self):
+ return self._default
+
+ @property
+ def annotation(self):
+ return self._annotation
+
+ @property
+ def kind(self):
+ return self._kind
+
+ def replace(self, name=_void, kind=_void, annotation=_void,
+ default=_void, _partial_kwarg=_void):
+ '''Creates a customized copy of the Parameter.'''
+
+ if name is _void:
+ name = self._name
+
+ if kind is _void:
+ kind = self._kind
+
+ if annotation is _void:
+ annotation = self._annotation
+
+ if default is _void:
+ default = self._default
+
+ if _partial_kwarg is _void:
+ _partial_kwarg = self._partial_kwarg
+
+ return type(self)(name, kind, default=default, annotation=annotation,
+ _partial_kwarg=_partial_kwarg)
+
+ def __str__(self):
+ kind = self.kind
+
+ formatted = self._name
+ if kind == _POSITIONAL_ONLY:
+ if formatted is None:
+ formatted = ''
+ formatted = '<{0}>'.format(formatted)
+
+ # Add annotation and default value
+ if self._annotation is not _empty:
+ formatted = '{0}:{1}'.format(formatted,
+ formatannotation(self._annotation))
+
+ if self._default is not _empty:
+ formatted = '{0}={1}'.format(formatted, repr(self._default))
+
+ if kind == _VAR_POSITIONAL:
+ formatted = '*' + formatted
+ elif kind == _VAR_KEYWORD:
+ formatted = '**' + formatted
+
+ return formatted
+
+ def __repr__(self):
+ return '<{0} at {1:#x} {2!r}>'.format(self.__class__.__name__,
+ id(self), self.name)
+
+ def __hash__(self):
+ msg = "unhashable type: '{0}'".format(self.__class__.__name__)
+ raise TypeError(msg)
+
+ def __eq__(self, other):
+ return (issubclass(other.__class__, Parameter) and
+ self._name == other._name and
+ self._kind == other._kind and
+ self._default == other._default and
+ self._annotation == other._annotation)
+
+ def __ne__(self, other):
+ return not self.__eq__(other)
+
+
+class BoundArguments(object):
+ '''Result of `Signature.bind` call. Holds the mapping of arguments
+ to the function's parameters.
+
+ Has the following public attributes:
+
+ * arguments : OrderedDict
+ An ordered mutable mapping of parameters' names to arguments' values.
+ Does not contain arguments' default values.
+ * signature : Signature
+ The Signature object that created this instance.
+ * args : tuple
+ Tuple of positional arguments values.
+ * kwargs : dict
+ Dict of keyword arguments values.
+ '''
+
+ def __init__(self, signature, arguments):
+ self.arguments = arguments
+ self._signature = signature
+
+ @property
+ def signature(self):
+ return self._signature
+
+ @property
+ def args(self):
+ args = []
+ for param_name, param in self._signature.parameters.items():
+ if (param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY) or
+ param._partial_kwarg):
+ # Keyword arguments mapped by 'functools.partial'
+ # (Parameter._partial_kwarg is True) are mapped
+ # in 'BoundArguments.kwargs', along with VAR_KEYWORD &
+ # KEYWORD_ONLY
+ break
+
+ try:
+ arg = self.arguments[param_name]
+ except KeyError:
+ # We're done here. Other arguments
+ # will be mapped in 'BoundArguments.kwargs'
+ break
+ else:
+ if param.kind == _VAR_POSITIONAL:
+ # *args
+ args.extend(arg)
+ else:
+ # plain argument
+ args.append(arg)
+
+ return tuple(args)
+
+ @property
+ def kwargs(self):
+ kwargs = {}
+ kwargs_started = False
+ for param_name, param in self._signature.parameters.items():
+ if not kwargs_started:
+ if (param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY) or
+ param._partial_kwarg):
+ kwargs_started = True
+ else:
+ if param_name not in self.arguments:
+ kwargs_started = True
+ continue
+
+ if not kwargs_started:
+ continue
+
+ try:
+ arg = self.arguments[param_name]
+ except KeyError:
+ pass
+ else:
+ if param.kind == _VAR_KEYWORD:
+ # **kwargs
+ kwargs.update(arg)
+ else:
+ # plain keyword argument
+ kwargs[param_name] = arg
+
+ return kwargs
+
+ def __hash__(self):
+ msg = "unhashable type: '{0}'".format(self.__class__.__name__)
+ raise TypeError(msg)
+
+ def __eq__(self, other):
+ return (issubclass(other.__class__, BoundArguments) and
+ self.signature == other.signature and
+ self.arguments == other.arguments)
+
+ def __ne__(self, other):
+ return not self.__eq__(other)
+
+
+class Signature(object):
+ '''A Signature object represents the overall signature of a function.
+ It stores a Parameter object for each parameter accepted by the
+ function, as well as information specific to the function itself.
+
+ A Signature object has the following public attributes and methods:
+
+ * parameters : OrderedDict
+ An ordered mapping of parameters' names to the corresponding
+ Parameter objects (keyword-only arguments are in the same order
+ as listed in `code.co_varnames`).
+ * return_annotation : object
+ The annotation for the return type of the function if specified.
+ If the function has no annotation for its return type, this
+ attribute is not set.
+ * bind(*args, **kwargs) -> BoundArguments
+ Creates a mapping from positional and keyword arguments to
+ parameters.
+ * bind_partial(*args, **kwargs) -> BoundArguments
+ Creates a partial mapping from positional and keyword arguments
+ to parameters (simulating 'functools.partial' behavior.)
+ '''
+
+ __slots__ = ('_return_annotation', '_parameters')
+
+ _parameter_cls = Parameter
+ _bound_arguments_cls = BoundArguments
+
+ empty = _empty
+
+ def __init__(self, parameters=None, return_annotation=_empty,
+ __validate_parameters__=True):
+ '''Constructs Signature from the given list of Parameter
+ objects and 'return_annotation'. All arguments are optional.
+ '''
+
+ if parameters is None:
+ params = OrderedDict()
+ else:
+ if __validate_parameters__:
+ params = OrderedDict()
+ top_kind = _POSITIONAL_ONLY
+
+ for idx, param in enumerate(parameters):
+ kind = param.kind
+ if kind < top_kind:
+ msg = 'wrong parameter order: {0} before {1}'
+ msg = msg.format(top_kind, param.kind)
+ raise ValueError(msg)
+ else:
+ top_kind = kind
+
+ name = param.name
+ if name is None:
+ name = str(idx)
+ param = param.replace(name=name)
+
+ if name in params:
+ msg = 'duplicate parameter name: {0!r}'.format(name)
+ raise ValueError(msg)
+ params[name] = param
+ else:
+ params = OrderedDict(((param.name, param)
+ for param in parameters))
+
+ self._parameters = params
+ self._return_annotation = return_annotation
+
+ @classmethod
+ def from_function(cls, func):
+ '''Constructs Signature for the given python function'''
+
+ if not isinstance(func, types.FunctionType):
+ raise TypeError('{0!r} is not a Python function'.format(func))
+
+ Parameter = cls._parameter_cls
+
+ # Parameter information.
+ func_code = func.__code__
+ pos_count = func_code.co_argcount
+ arg_names = func_code.co_varnames
+ positional = tuple(arg_names[:pos_count])
+ keyword_only_count = getattr(func_code, 'co_kwonlyargcount', 0)
+ keyword_only = arg_names[pos_count:(pos_count + keyword_only_count)]
+ annotations = getattr(func, '__annotations__', {})
+ defaults = func.__defaults__
+ kwdefaults = getattr(func, '__kwdefaults__', None)
+
+ if defaults:
+ pos_default_count = len(defaults)
+ else:
+ pos_default_count = 0
+
+ parameters = []
+
+ # Non-keyword-only parameters w/o defaults.
+ non_default_count = pos_count - pos_default_count
+ for name in positional[:non_default_count]:
+ annotation = annotations.get(name, _empty)
+ parameters.append(Parameter(name, annotation=annotation,
+ kind=_POSITIONAL_OR_KEYWORD))
+
+ # ... w/ defaults.
+ for offset, name in enumerate(positional[non_default_count:]):
+ annotation = annotations.get(name, _empty)
+ parameters.append(Parameter(name, annotation=annotation,
+ kind=_POSITIONAL_OR_KEYWORD,
+ default=defaults[offset]))
+
+ # *args
+ if func_code.co_flags & 0x04:
+ name = arg_names[pos_count + keyword_only_count]
+ annotation = annotations.get(name, _empty)
+ parameters.append(Parameter(name, annotation=annotation,
+ kind=_VAR_POSITIONAL))
+
+ # Keyword-only parameters.
+ for name in keyword_only:
+ default = _empty
+ if kwdefaults is not None:
+ default = kwdefaults.get(name, _empty)
+
+ annotation = annotations.get(name, _empty)
+ parameters.append(Parameter(name, annotation=annotation,
+ kind=_KEYWORD_ONLY,
+ default=default))
+ # **kwargs
+ if func_code.co_flags & 0x08:
+ index = pos_count + keyword_only_count
+ if func_code.co_flags & 0x04:
+ index += 1
+
+ name = arg_names[index]
+ annotation = annotations.get(name, _empty)
+ parameters.append(Parameter(name, annotation=annotation,
+ kind=_VAR_KEYWORD))
+
+ return cls(parameters,
+ return_annotation=annotations.get('return', _empty),
+ __validate_parameters__=False)
+
+ @property
+ def parameters(self):
+ try:
+ return types.MappingProxyType(self._parameters)
+ except AttributeError:
+ return OrderedDict(self._parameters.items())
+
+ @property
+ def return_annotation(self):
+ return self._return_annotation
+
+ def replace(self, parameters=_void, return_annotation=_void):
+ '''Creates a customized copy of the Signature.
+ Pass 'parameters' and/or 'return_annotation' arguments
+ to override them in the new copy.
+ '''
+
+ if parameters is _void:
+ parameters = self.parameters.values()
+
+ if return_annotation is _void:
+ return_annotation = self._return_annotation
+
+ return type(self)(parameters,
+ return_annotation=return_annotation)
+
+ def __hash__(self):
+ msg = "unhashable type: '{0}'".format(self.__class__.__name__)
+ raise TypeError(msg)
+
+ def __eq__(self, other):
+ if (not issubclass(type(other), Signature) or
+ self.return_annotation != other.return_annotation or
+ len(self.parameters) != len(other.parameters)):
+ return False
+
+ other_positions = dict((param, idx)
+ for idx, param in enumerate(other.parameters.keys()))
+
+ for idx, (param_name, param) in enumerate(self.parameters.items()):
+ if param.kind == _KEYWORD_ONLY:
+ try:
+ other_param = other.parameters[param_name]
+ except KeyError:
+ return False
+ else:
+ if param != other_param:
+ return False
+ else:
+ try:
+ other_idx = other_positions[param_name]
+ except KeyError:
+ return False
+ else:
+ if (idx != other_idx or
+ param != other.parameters[param_name]):
+ return False
+
+ return True
+
+ def __ne__(self, other):
+ return not self.__eq__(other)
+
+ def _bind(self, args, kwargs, partial=False):
+ '''Private method. Don't use directly.'''
+
+ arguments = OrderedDict()
+
+ parameters = iter(self.parameters.values())
+ parameters_ex = ()
+ arg_vals = iter(args)
+
+ if partial:
+ # Support for binding arguments to 'functools.partial' objects.
+ # See 'functools.partial' case in 'signature()' implementation
+ # for details.
+ for param_name, param in self.parameters.items():
+ if (param._partial_kwarg and param_name not in kwargs):
+ # Simulating 'functools.partial' behavior
+ kwargs[param_name] = param.default
+
+ while True:
+ # Let's iterate through the positional arguments and corresponding
+ # parameters
+ try:
+ arg_val = next(arg_vals)
+ except StopIteration:
+ # No more positional arguments
+ try:
+ param = next(parameters)
+ except StopIteration:
+ # No more parameters. That's it. Just need to check that
+ # we have no `kwargs` after this while loop
+ break
+ else:
+ if param.kind == _VAR_POSITIONAL:
+ # That's OK, just empty *args. Let's start parsing
+ # kwargs
+ break
+ elif param.name in kwargs:
+ if param.kind == _POSITIONAL_ONLY:
+ msg = '{arg!r} parameter is positional only, ' \
+ 'but was passed as a keyword'
+ msg = msg.format(arg=param.name)
+ raise TypeError(msg)
+ parameters_ex = (param,)
+ break
+ elif (param.kind == _VAR_KEYWORD or
+ param.default is not _empty):
+ # That's fine too - we have a default value for this
+ # parameter. So, lets start parsing `kwargs`, starting
+ # with the current parameter
+ parameters_ex = (param,)
+ break
+ else:
+ if partial:
+ parameters_ex = (param,)
+ break
+ else:
+ msg = '{arg!r} parameter lacking default value'
+ msg = msg.format(arg=param.name)
+ raise TypeError(msg)
+ else:
+ # We have a positional argument to process
+ try:
+ param = next(parameters)
+ except StopIteration:
+ raise TypeError('too many positional arguments')
+ else:
+ if param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY):
+ # Looks like we have no parameter for this positional
+ # argument
+ raise TypeError('too many positional arguments')
+
+ if param.kind == _VAR_POSITIONAL:
+ # We have an '*args'-like argument, let's fill it with
+ # all positional arguments we have left and move on to
+ # the next phase
+ values = [arg_val]
+ values.extend(arg_vals)
+ arguments[param.name] = tuple(values)
+ break
+
+ if param.name in kwargs:
+ raise TypeError('multiple values for argument '
+ '{arg!r}'.format(arg=param.name))
+
+ arguments[param.name] = arg_val
+
+ # Now, we iterate through the remaining parameters to process
+ # keyword arguments
+ kwargs_param = None
+ for param in itertools.chain(parameters_ex, parameters):
+ if param.kind == _POSITIONAL_ONLY:
+ # This should never happen in case of a properly built
+ # Signature object (but let's have this check here
+ # to ensure correct behaviour just in case)
+ raise TypeError('{arg!r} parameter is positional only, '
+ 'but was passed as a keyword'. \
+ format(arg=param.name))
+
+ if param.kind == _VAR_KEYWORD:
+ # Memorize that we have a '**kwargs'-like parameter
+ kwargs_param = param
+ continue
+
+ param_name = param.name
+ try:
+ arg_val = kwargs.pop(param_name)
+ except KeyError:
+ # We have no value for this parameter. It's fine though,
+ # if it has a default value, or it is an '*args'-like
+ # parameter, left alone by the processing of positional
+ # arguments.
+ if (not partial and param.kind != _VAR_POSITIONAL and
+ param.default is _empty):
+ raise TypeError('{arg!r} parameter lacking default value'. \
+ format(arg=param_name))
+
+ else:
+ arguments[param_name] = arg_val
+
+ if kwargs:
+ if kwargs_param is not None:
+ # Process our '**kwargs'-like parameter
+ arguments[kwargs_param.name] = kwargs
+ else:
+ raise TypeError('too many keyword arguments %r' % kwargs)
+
+ return self._bound_arguments_cls(self, arguments)
+
+ def bind(*args, **kwargs):
+ '''Get a BoundArguments object, that maps the passed `args`
+ and `kwargs` to the function's signature. Raises `TypeError`
+ if the passed arguments can not be bound.
+ '''
+ return args[0]._bind(args[1:], kwargs)
+
+ def bind_partial(self, *args, **kwargs):
+ '''Get a BoundArguments object, that partially maps the
+ passed `args` and `kwargs` to the function's signature.
+ Raises `TypeError` if the passed arguments can not be bound.
+ '''
+ return self._bind(args, kwargs, partial=True)
+
+ def __str__(self):
+ result = []
+ render_kw_only_separator = True
+ for idx, param in enumerate(self.parameters.values()):
+ formatted = str(param)
+
+ kind = param.kind
+ if kind == _VAR_POSITIONAL:
+ # OK, we have an '*args'-like parameter, so we won't need
+ # a '*' to separate keyword-only arguments
+ render_kw_only_separator = False
+ elif kind == _KEYWORD_ONLY and render_kw_only_separator:
+ # We have a keyword-only parameter to render and we haven't
+ # rendered an '*args'-like parameter before, so add a '*'
+ # separator to the parameters list ("foo(arg1, *, arg2)" case)
+ result.append('*')
+ # This condition should be only triggered once, so
+ # reset the flag
+ render_kw_only_separator = False
+
+ result.append(formatted)
+
+ rendered = '({0})'.format(', '.join(result))
+
+ if self.return_annotation is not _empty:
+ anno = formatannotation(self.return_annotation)
+ rendered += ' -> {0}'.format(anno)
+
+ return rendered
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs/version.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..7863915fa5f8f014c64c8abff41a138e9b3cd4d3
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/funcsigs/version.py
@@ -0,0 +1 @@
+__version__ = "1.0.2"
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/future-0.17.1.dist-info/LICENSE.txt b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/future-0.17.1.dist-info/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d41c85d1b2dcf60644dc099b1d304e35af33b50e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/future-0.17.1.dist-info/LICENSE.txt
@@ -0,0 +1,19 @@
+Copyright (c) 2013-2018 Python Charmers Pty Ltd, Australia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/idna-2.8.dist-info/LICENSE.rst b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/idna-2.8.dist-info/LICENSE.rst
new file mode 100644
index 0000000000000000000000000000000000000000..3ee64fba29e2aee855c15402e1e9fd825b95a671
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/idna-2.8.dist-info/LICENSE.rst
@@ -0,0 +1,80 @@
+License
+-------
+
+Copyright (c) 2013-2018, Kim Davies. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+#. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+#. Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided with
+ the distribution.
+
+#. Neither the name of the copyright holder nor the names of the
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+#. THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS "AS IS" AND ANY
+ EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ DAMAGE.
+
+Portions of the codec implementation and unit tests are derived from the
+Python standard library, which carries the `Python Software Foundation
+License `_:
+
+ Copyright (c) 2001-2014 Python Software Foundation; All Rights Reserved
+
+Portions of the unit tests are derived from the Unicode standard, which
+is subject to the Unicode, Inc. License Agreement:
+
+ Copyright (c) 1991-2014 Unicode, Inc. All rights reserved.
+ Distributed under the Terms of Use in
+ .
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of the Unicode data files and any associated documentation
+ (the "Data Files") or Unicode software and any associated documentation
+ (the "Software") to deal in the Data Files or Software
+ without restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, and/or sell copies of
+ the Data Files or Software, and to permit persons to whom the Data Files
+ or Software are furnished to do so, provided that
+
+ (a) this copyright and permission notice appear with all copies
+ of the Data Files or Software,
+
+ (b) this copyright and permission notice appear in associated
+ documentation, and
+
+ (c) there is clear notice in each modified Data File or in the Software
+ as well as in the documentation associated with the Data File(s) or
+ Software that the data or software has been modified.
+
+ THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
+ ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT OF THIRD PARTY RIGHTS.
+ IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
+ NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
+ DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+
+ Except as contained in this notice, the name of a copyright holder
+ shall not be used in advertising or otherwise to promote the sale,
+ use or other dealings in these Data Files or Software without prior
+ written authorization of the copyright holder.
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/idna-2.8.dist-info/METADATA b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/idna-2.8.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..30fde02b1b68876ed651d70f42d4ea8dae7d4b72
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/idna-2.8.dist-info/METADATA
@@ -0,0 +1,239 @@
+Metadata-Version: 2.1
+Name: idna
+Version: 2.8
+Summary: Internationalized Domain Names in Applications (IDNA)
+Home-page: https://github.com/kjd/idna
+Author: Kim Davies
+Author-email: kim@cynosure.com.au
+License: BSD-like
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Topic :: Internet :: Name Service (DNS)
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
+
+Internationalized Domain Names in Applications (IDNA)
+=====================================================
+
+Support for the Internationalised Domain Names in Applications
+(IDNA) protocol as specified in `RFC 5891 `_.
+This is the latest version of the protocol and is sometimes referred to as
+“IDNA 2008”.
+
+This library also provides support for Unicode Technical Standard 46,
+`Unicode IDNA Compatibility Processing `_).
+
+Basic functions are simply executed:
+
+.. code-block:: pycon
+
+ # Python 3
+ >>> import idna
+ >>> idna.encode('ドメイン.テスト')
+ b'xn--eckwd4c7c.xn--zckzah'
+ >>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
+ ドメイン.テスト
+
+ # Python 2
+ >>> import idna
+ >>> idna.encode(u'ドメイン.テスト')
+ 'xn--eckwd4c7c.xn--zckzah'
+ >>> print idna.decode('xn--eckwd4c7c.xn--zckzah')
+ ドメイン.テスト
+
+Packages
+--------
+
+The latest tagged release version is published in the PyPI repository:
+
+.. image:: https://badge.fury.io/py/idna.svg
+ :target: http://badge.fury.io/py/idna
+
+
+Installation
+------------
+
+To install this library, you can use pip:
+
+.. code-block:: bash
+
+ $ pip install idna
+
+Alternatively, you can install the package using the bundled setup script:
+
+.. code-block:: bash
+
+ $ python setup.py install
+
+This library works with Python 2.7 and Python 3.4 or later.
+
+
+Usage
+-----
+
+For typical usage, the ``encode`` and ``decode`` functions will take a domain
+name argument and perform a conversion to A-labels or U-labels respectively.
+
+.. code-block:: pycon
+
+ # Python 3
+ >>> import idna
+ >>> idna.encode('ドメイン.テスト')
+ b'xn--eckwd4c7c.xn--zckzah'
+ >>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
+ ドメイン.テスト
+
+You may use the codec encoding and decoding methods using the
+``idna.codec`` module:
+
+.. code-block:: pycon
+
+ # Python 2
+ >>> import idna.codec
+ >>> print u'домена.испытание'.encode('idna')
+ xn--80ahd1agd.xn--80akhbyknj4f
+ >>> print 'xn--80ahd1agd.xn--80akhbyknj4f'.decode('idna')
+ домена.испытание
+
+Conversions can be applied at a per-label basis using the ``ulabel`` or ``alabel``
+functions if necessary:
+
+.. code-block:: pycon
+
+ # Python 2
+ >>> idna.alabel(u'测试')
+ 'xn--0zwm56d'
+
+Compatibility Mapping (UTS #46)
++++++++++++++++++++++++++++++++
+
+As described in `RFC 5895 `_, the IDNA
+specification no longer normalizes input from different potential ways a user
+may input a domain name. This functionality, known as a “mapping”, is now
+considered by the specification to be a local user-interface issue distinct
+from IDNA conversion functionality.
+
+This library provides one such mapping, that was developed by the Unicode
+Consortium. Known as `Unicode IDNA Compatibility Processing `_ can
+also add support for custom package installers. See the above documentation
+for details.
+
+
+Caveats
+=======
+
+This project primarily supports third-party packages installed by PyPA
+tools (or other conforming packages). It does not support:
+
+- Packages in the stdlib.
+- Packages installed without metadata.
+
+Project details
+===============
+
+ * Project home: https://gitlab.com/python-devs/importlib_metadata
+ * Report bugs at: https://gitlab.com/python-devs/importlib_metadata/issues
+ * Code hosting: https://gitlab.com/python-devs/importlib_metadata.git
+ * Documentation: http://importlib_metadata.readthedocs.io/
+
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata-0.22.dist-info/RECORD b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata-0.22.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..ddd8d09fe355bbbdbb404db32287f5f0c23ff8f1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata-0.22.dist-info/RECORD
@@ -0,0 +1,33 @@
+importlib_metadata-0.22.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+importlib_metadata-0.22.dist-info/LICENSE,sha256=wNe6dAchmJ1VvVB8D9oTc-gHHadCuaSBAev36sYEM6U,571
+importlib_metadata-0.22.dist-info/METADATA,sha256=KmcBjOLsIzS4EZr5W1Dlj_YWTfS5FnIHhT2gUbLsxpY,2105
+importlib_metadata-0.22.dist-info/RECORD,,
+importlib_metadata-0.22.dist-info/WHEEL,sha256=8zNYZbwQSXoB9IfXOjPfeNwvAsALAjffgk27FqvCWbo,110
+importlib_metadata-0.22.dist-info/top_level.txt,sha256=CO3fD9yylANiXkrMo4qHLV_mqXL2sC5JFKgt1yWAT-A,19
+importlib_metadata/__init__.py,sha256=2u4AGKeIQSu46en8Kzl2FhsjMEq5OHfzJkq04kwxnUI,16662
+importlib_metadata/__init__.pyc,,
+importlib_metadata/_compat.py,sha256=PWaYFxVGb902XVUn8pwcZBSn94t2NUml00bdlpfUudg,3004
+importlib_metadata/_compat.pyc,,
+importlib_metadata/docs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+importlib_metadata/docs/__init__.pyc,,
+importlib_metadata/docs/changelog.rst,sha256=_x915PFoPVmV71C613GjAFm1wbuMqGhpnGrY9m99NzA,5928
+importlib_metadata/docs/conf.py,sha256=DM_-W8bvIar_YqWeRQUcgWT1_phXe-H2IcYgM8JIkiY,5468
+importlib_metadata/docs/conf.pyc,,
+importlib_metadata/docs/index.rst,sha256=4T97pI0Iu40cEbqJy53LZeEToStyC45zHmZO9Cwe5Vk,2044
+importlib_metadata/docs/using.rst,sha256=2S6KGhJ66t8kM3cik7K03X1AJUGX0TWr6byaHEsJjnc,9826
+importlib_metadata/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+importlib_metadata/tests/__init__.pyc,,
+importlib_metadata/tests/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+importlib_metadata/tests/data/__init__.pyc,,
+importlib_metadata/tests/data/example-21.12-py3-none-any.whl,sha256=I-kYufETid-tDYyR8f1OFJ3t5u_Io23k0cbQxJTUN4I,1455
+importlib_metadata/tests/data/example-21.12-py3.6.egg,sha256=-EeugFAijkdUO9xyQHTZkQwZoFXK0_QxICBj6R5AAJo,1497
+importlib_metadata/tests/fixtures.py,sha256=sshuoJ4ezljeouUddVg-76K1UOStKWBecovZOKOBguk,5004
+importlib_metadata/tests/fixtures.pyc,,
+importlib_metadata/tests/test_api.py,sha256=YMAGTsRENrtvpw2CSLmRndJMBeT4q_M0GSe-QsnnMZ4,5544
+importlib_metadata/tests/test_api.pyc,,
+importlib_metadata/tests/test_integration.py,sha256=kzqav9qAePjz7UR-GNna65xLwXlRcxEDYDwmuOFwpKE,686
+importlib_metadata/tests/test_integration.pyc,,
+importlib_metadata/tests/test_main.py,sha256=njWXHvOY0a9lNS4SbM7jkRJngk0EdmAm5cRR7KaFtKo,6213
+importlib_metadata/tests/test_main.pyc,,
+importlib_metadata/tests/test_zip.py,sha256=qG3IquiTFLSrUtpxEJblqiUtgEcOTfjU2yM35REk0fo,2372
+importlib_metadata/tests/test_zip.pyc,,
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata-0.22.dist-info/WHEEL b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata-0.22.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..8b701e93c23159bc1f4145f779049ce0a6a6cf77
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata-0.22.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.33.6)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata-0.22.dist-info/top_level.txt b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata-0.22.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bbb07547a19c30031d13c45cf01cba61dc434e47
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata-0.22.dist-info/top_level.txt
@@ -0,0 +1 @@
+importlib_metadata
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddd25797dbc6c0d4ea7e8d689fe380400e06a910
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata/__init__.py
@@ -0,0 +1,532 @@
+from __future__ import unicode_literals, absolute_import
+
+import io
+import os
+import re
+import abc
+import csv
+import sys
+import zipp
+import operator
+import functools
+import itertools
+import collections
+
+from ._compat import (
+ install,
+ NullFinder,
+ ConfigParser,
+ suppress,
+ map,
+ FileNotFoundError,
+ IsADirectoryError,
+ NotADirectoryError,
+ PermissionError,
+ pathlib,
+ PYPY_OPEN_BUG,
+ ModuleNotFoundError,
+ MetaPathFinder,
+ email_message_from_string,
+ ensure_is_path,
+ )
+from importlib import import_module
+from itertools import starmap
+
+
+__metaclass__ = type
+
+
+__all__ = [
+ 'Distribution',
+ 'DistributionFinder',
+ 'PackageNotFoundError',
+ 'distribution',
+ 'distributions',
+ 'entry_points',
+ 'files',
+ 'metadata',
+ 'requires',
+ 'version',
+ ]
+
+
+class PackageNotFoundError(ModuleNotFoundError):
+ """The package was not found."""
+
+
+class EntryPoint(collections.namedtuple('EntryPointBase', 'name value group')):
+ """An entry point as defined by Python packaging conventions.
+
+ See `the packaging docs on entry points
+ [\w.]+)\s*'
+ r'(:\s*(?P[\w.]+))?\s*'
+ r'(?P\[.*\])?\s*$'
+ )
+ """
+ A regular expression describing the syntax for an entry point,
+ which might look like:
+
+ - module
+ - package.module
+ - package.module:attribute
+ - package.module:object.attribute
+ - package.module:attr [extra1, extra2]
+
+ Other combinations are possible as well.
+
+ The expression is lenient about whitespace around the ':',
+ following the attr, and following any extras.
+ """
+
+ def load(self):
+ """Load the entry point from its definition. If only a module
+ is indicated by the value, return that module. Otherwise,
+ return the named object.
+ """
+ match = self.pattern.match(self.value)
+ module = import_module(match.group('module'))
+ attrs = filter(None, (match.group('attr') or '').split('.'))
+ return functools.reduce(getattr, attrs, module)
+
+ @property
+ def extras(self):
+ match = self.pattern.match(self.value)
+ return list(re.finditer(r'\w+', match.group('extras') or ''))
+
+ @classmethod
+ def _from_config(cls, config):
+ return [
+ cls(name, value, group)
+ for group in config.sections()
+ for name, value in config.items(group)
+ ]
+
+ @classmethod
+ def _from_text(cls, text):
+ config = ConfigParser(delimiters='=')
+ # case sensitive: https://stackoverflow.com/q/1611799/812183
+ config.optionxform = str
+ try:
+ config.read_string(text)
+ except AttributeError: # pragma: nocover
+ # Python 2 has no read_string
+ config.readfp(io.StringIO(text))
+ return EntryPoint._from_config(config)
+
+ def __iter__(self):
+ """
+ Supply iter so one may construct dicts of EntryPoints easily.
+ """
+ return iter((self.name, self))
+
+
+class PackagePath(pathlib.PurePosixPath):
+ """A reference to a path in a package"""
+
+ def read_text(self, encoding='utf-8'):
+ with self.locate().open(encoding=encoding) as stream:
+ return stream.read()
+
+ def read_binary(self):
+ with self.locate().open('rb') as stream:
+ return stream.read()
+
+ def locate(self):
+ """Return a path-like object for this path"""
+ return self.dist.locate_file(self)
+
+
+class FileHash:
+ def __init__(self, spec):
+ self.mode, _, self.value = spec.partition('=')
+
+ def __repr__(self):
+ return ''.format(self.mode, self.value)
+
+
+class Distribution:
+ """A Python distribution package."""
+
+ @abc.abstractmethod
+ def read_text(self, filename):
+ """Attempt to load metadata file given by the name.
+
+ :param filename: The name of the file in the distribution info.
+ :return: The text if found, otherwise None.
+ """
+
+ @abc.abstractmethod
+ def locate_file(self, path):
+ """
+ Given a path to a file in this distribution, return a path
+ to it.
+ """
+
+ @classmethod
+ def from_name(cls, name):
+ """Return the Distribution for the given package name.
+
+ :param name: The name of the distribution package to search for.
+ :return: The Distribution instance (or subclass thereof) for the named
+ package, if found.
+ :raises PackageNotFoundError: When the named package's distribution
+ metadata cannot be found.
+ """
+ for resolver in cls._discover_resolvers():
+ dists = resolver(DistributionFinder.Context(name=name))
+ dist = next(dists, None)
+ if dist is not None:
+ return dist
+ else:
+ raise PackageNotFoundError(name)
+
+ @classmethod
+ def discover(cls, **kwargs):
+ """Return an iterable of Distribution objects for all packages.
+
+ Pass a ``context`` or pass keyword arguments for constructing
+ a context.
+
+ :context: A ``DistributionFinder.Context`` object.
+ :return: Iterable of Distribution objects for all packages.
+ """
+ context = kwargs.pop('context', None)
+ if context and kwargs:
+ raise ValueError("cannot accept context and kwargs")
+ context = context or DistributionFinder.Context(**kwargs)
+ return itertools.chain.from_iterable(
+ resolver(context)
+ for resolver in cls._discover_resolvers()
+ )
+
+ @staticmethod
+ def at(path):
+ """Return a Distribution for the indicated metadata path
+
+ :param path: a string or path-like object
+ :return: a concrete Distribution instance for the path
+ """
+ return PathDistribution(ensure_is_path(path))
+
+ @staticmethod
+ def _discover_resolvers():
+ """Search the meta_path for resolvers."""
+ declared = (
+ getattr(finder, 'find_distributions', None)
+ for finder in sys.meta_path
+ )
+ return filter(None, declared)
+
+ @property
+ def metadata(self):
+ """Return the parsed metadata for this Distribution.
+
+ The returned object will have keys that name the various bits of
+ metadata. See PEP 566 for details.
+ """
+ text = (
+ self.read_text('METADATA')
+ or self.read_text('PKG-INFO')
+ # This last clause is here to support old egg-info files. Its
+ # effect is to just end up using the PathDistribution's self._path
+ # (which points to the egg-info file) attribute unchanged.
+ or self.read_text('')
+ )
+ return email_message_from_string(text)
+
+ @property
+ def version(self):
+ """Return the 'Version' metadata for the distribution package."""
+ return self.metadata['Version']
+
+ @property
+ def entry_points(self):
+ return EntryPoint._from_text(self.read_text('entry_points.txt'))
+
+ @property
+ def files(self):
+ """Files in this distribution.
+
+ :return: List of PackagePath for this distribution or None
+
+ Result is `None` if the metadata file that enumerates files
+ (i.e. RECORD for dist-info or SOURCES.txt for egg-info) is
+ missing.
+ Result may be empty if the metadata exists but is empty.
+ """
+ file_lines = self._read_files_distinfo() or self._read_files_egginfo()
+
+ def make_file(name, hash=None, size_str=None):
+ result = PackagePath(name)
+ result.hash = FileHash(hash) if hash else None
+ result.size = int(size_str) if size_str else None
+ result.dist = self
+ return result
+
+ return file_lines and list(starmap(make_file, csv.reader(file_lines)))
+
+ def _read_files_distinfo(self):
+ """
+ Read the lines of RECORD
+ """
+ text = self.read_text('RECORD')
+ return text and text.splitlines()
+
+ def _read_files_egginfo(self):
+ """
+ SOURCES.txt might contain literal commas, so wrap each line
+ in quotes.
+ """
+ text = self.read_text('SOURCES.txt')
+ return text and map('"{}"'.format, text.splitlines())
+
+ @property
+ def requires(self):
+ """Generated requirements specified for this Distribution"""
+ reqs = self._read_dist_info_reqs() or self._read_egg_info_reqs()
+ return reqs and list(reqs)
+
+ def _read_dist_info_reqs(self):
+ return self.metadata.get_all('Requires-Dist')
+
+ def _read_egg_info_reqs(self):
+ source = self.read_text('requires.txt')
+ return source and self._deps_from_requires_text(source)
+
+ @classmethod
+ def _deps_from_requires_text(cls, source):
+ section_pairs = cls._read_sections(source.splitlines())
+ sections = {
+ section: list(map(operator.itemgetter('line'), results))
+ for section, results in
+ itertools.groupby(section_pairs, operator.itemgetter('section'))
+ }
+ return cls._convert_egg_info_reqs_to_simple_reqs(sections)
+
+ @staticmethod
+ def _read_sections(lines):
+ section = None
+ for line in filter(None, lines):
+ section_match = re.match(r'\[(.*)\]$', line)
+ if section_match:
+ section = section_match.group(1)
+ continue
+ yield locals()
+
+ @staticmethod
+ def _convert_egg_info_reqs_to_simple_reqs(sections):
+ """
+ Historically, setuptools would solicit and store 'extra'
+ requirements, including those with environment markers,
+ in separate sections. More modern tools expect each
+ dependency to be defined separately, with any relevant
+ extras and environment markers attached directly to that
+ requirement. This method converts the former to the
+ latter. See _test_deps_from_requires_text for an example.
+ """
+ def make_condition(name):
+ return name and 'extra == "{name}"'.format(name=name)
+
+ def parse_condition(section):
+ section = section or ''
+ extra, sep, markers = section.partition(':')
+ if extra and markers:
+ markers = '({markers})'.format(markers=markers)
+ conditions = list(filter(None, [markers, make_condition(extra)]))
+ return '; ' + ' and '.join(conditions) if conditions else ''
+
+ for section, deps in sections.items():
+ for dep in deps:
+ yield dep + parse_condition(section)
+
+
+class DistributionFinder(MetaPathFinder):
+ """
+ A MetaPathFinder capable of discovering installed distributions.
+ """
+
+ class Context:
+
+ name = None
+ """
+ Specific name for which a distribution finder should match.
+ """
+
+ def __init__(self, **kwargs):
+ vars(self).update(kwargs)
+
+ @property
+ def path(self):
+ """
+ The path that a distribution finder should search.
+ """
+ return vars(self).get('path', sys.path)
+
+ @property
+ def pattern(self):
+ return '.*' if self.name is None else re.escape(self.name)
+
+ @abc.abstractmethod
+ def find_distributions(self, context=Context()):
+ """
+ Find distributions.
+
+ Return an iterable of all Distribution instances capable of
+ loading the metadata for packages matching the ``context``,
+ a DistributionFinder.Context instance.
+ """
+
+
+@install
+class MetadataPathFinder(NullFinder, DistributionFinder):
+ """A degenerate finder for distribution packages on the file system.
+
+ This finder supplies only a find_distributions() method for versions
+ of Python that do not have a PathFinder find_distributions().
+ """
+
+ def find_distributions(self, context=DistributionFinder.Context()):
+ """
+ Find distributions.
+
+ Return an iterable of all Distribution instances capable of
+ loading the metadata for packages matching ``context.name``
+ (or all names if ``None`` indicated) along the paths in the list
+ of directories ``context.path``.
+ """
+ found = self._search_paths(context.pattern, context.path)
+ return map(PathDistribution, found)
+
+ @classmethod
+ def _search_paths(cls, pattern, paths):
+ """Find metadata directories in paths heuristically."""
+ return itertools.chain.from_iterable(
+ cls._search_path(path, pattern)
+ for path in map(cls._switch_path, paths)
+ )
+
+ @staticmethod
+ def _switch_path(path):
+ if not PYPY_OPEN_BUG or os.path.isfile(path): # pragma: no branch
+ with suppress(Exception):
+ return zipp.Path(path)
+ return pathlib.Path(path)
+
+ @classmethod
+ def _matches_info(cls, normalized, item):
+ template = r'{pattern}(-.*)?\.(dist|egg)-info'
+ manifest = template.format(pattern=normalized)
+ return re.match(manifest, item.name, flags=re.IGNORECASE)
+
+ @classmethod
+ def _matches_legacy(cls, normalized, item):
+ template = r'{pattern}-.*\.egg[\\/]EGG-INFO'
+ manifest = template.format(pattern=normalized)
+ return re.search(manifest, str(item), flags=re.IGNORECASE)
+
+ @classmethod
+ def _search_path(cls, root, pattern):
+ if not root.is_dir():
+ return ()
+ normalized = pattern.replace('-', '_')
+ return (item for item in root.iterdir()
+ if cls._matches_info(normalized, item)
+ or cls._matches_legacy(normalized, item))
+
+
+class PathDistribution(Distribution):
+ def __init__(self, path):
+ """Construct a distribution from a path to the metadata directory.
+
+ :param path: A pathlib.Path or similar object supporting
+ .joinpath(), __div__, .parent, and .read_text().
+ """
+ self._path = path
+
+ def read_text(self, filename):
+ with suppress(FileNotFoundError, IsADirectoryError, KeyError,
+ NotADirectoryError, PermissionError):
+ return self._path.joinpath(filename).read_text(encoding='utf-8')
+ read_text.__doc__ = Distribution.read_text.__doc__
+
+ def locate_file(self, path):
+ return self._path.parent / path
+
+
+def distribution(distribution_name):
+ """Get the ``Distribution`` instance for the named package.
+
+ :param distribution_name: The name of the distribution package as a string.
+ :return: A ``Distribution`` instance (or subclass thereof).
+ """
+ return Distribution.from_name(distribution_name)
+
+
+def distributions(**kwargs):
+ """Get all ``Distribution`` instances in the current environment.
+
+ :return: An iterable of ``Distribution`` instances.
+ """
+ return Distribution.discover(**kwargs)
+
+
+def metadata(distribution_name):
+ """Get the metadata for the named package.
+
+ :param distribution_name: The name of the distribution package to query.
+ :return: An email.Message containing the parsed metadata.
+ """
+ return Distribution.from_name(distribution_name).metadata
+
+
+def version(distribution_name):
+ """Get the version string for the named package.
+
+ :param distribution_name: The name of the distribution package to query.
+ :return: The version string for the package as defined in the package's
+ "Version" metadata key.
+ """
+ return distribution(distribution_name).version
+
+
+def entry_points():
+ """Return EntryPoint objects for all installed packages.
+
+ :return: EntryPoint objects for all installed packages.
+ """
+ eps = itertools.chain.from_iterable(
+ dist.entry_points for dist in distributions())
+ by_group = operator.attrgetter('group')
+ ordered = sorted(eps, key=by_group)
+ grouped = itertools.groupby(ordered, by_group)
+ return {
+ group: tuple(eps)
+ for group, eps in grouped
+ }
+
+
+def files(distribution_name):
+ """Return a list of files for the named package.
+
+ :param distribution_name: The name of the distribution package to query.
+ :return: List of files composing the distribution.
+ """
+ return distribution(distribution_name).files
+
+
+def requires(distribution_name):
+ """
+ Return a list of requirements for the named package.
+
+ :return: An iterator of requirements, suitable for
+ packaging.requirement.Requirement.
+ """
+ return distribution(distribution_name).requires
+
+
+__version__ = version(__name__)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata/_compat.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata/_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f54864d91092a8465da74855ffad27885cc5732
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/importlib_metadata/_compat.py
@@ -0,0 +1,100 @@
+from __future__ import absolute_import
+
+import io
+import abc
+import sys
+import email
+
+
+if sys.version_info > (3,): # pragma: nocover
+ import builtins
+ from configparser import ConfigParser
+ from contextlib import suppress
+ FileNotFoundError = builtins.FileNotFoundError
+ IsADirectoryError = builtins.IsADirectoryError
+ NotADirectoryError = builtins.NotADirectoryError
+ PermissionError = builtins.PermissionError
+ map = builtins.map
+else: # pragma: nocover
+ from backports.configparser import ConfigParser
+ from itertools import imap as map # type: ignore
+ from contextlib2 import suppress # noqa
+ FileNotFoundError = IOError, OSError
+ IsADirectoryError = IOError, OSError
+ NotADirectoryError = IOError, OSError
+ PermissionError = IOError, OSError
+
+if sys.version_info > (3, 5): # pragma: nocover
+ import pathlib
+else: # pragma: nocover
+ import pathlib2 as pathlib
+
+try:
+ ModuleNotFoundError = builtins.FileNotFoundError
+except (NameError, AttributeError): # pragma: nocover
+ ModuleNotFoundError = ImportError # type: ignore
+
+
+if sys.version_info >= (3,): # pragma: nocover
+ from importlib.abc import MetaPathFinder
+else: # pragma: nocover
+ class MetaPathFinder(object):
+ __metaclass__ = abc.ABCMeta
+
+
+__metaclass__ = type
+__all__ = [
+ 'install', 'NullFinder', 'MetaPathFinder', 'ModuleNotFoundError',
+ 'pathlib', 'ConfigParser', 'map', 'suppress', 'FileNotFoundError',
+ 'NotADirectoryError', 'email_message_from_string',
+ ]
+
+
+def install(cls):
+ """Class decorator for installation on sys.meta_path."""
+ sys.meta_path.append(cls())
+ return cls
+
+
+class NullFinder:
+ """
+ A "Finder" (aka "MetaClassFinder") that never finds any modules,
+ but may find distributions.
+ """
+ @staticmethod
+ def find_spec(*args, **kwargs):
+ return None
+
+ # In Python 2, the import system requires finders
+ # to have a find_module() method, but this usage
+ # is deprecated in Python 3 in favor of find_spec().
+ # For the purposes of this finder (i.e. being present
+ # on sys.meta_path but having no other import
+ # system functionality), the two methods are identical.
+ find_module = find_spec
+
+
+def py2_message_from_string(text): # nocoverpy3
+ # Work around https://bugs.python.org/issue25545 where
+ # email.message_from_string cannot handle Unicode on Python 2.
+ io_buffer = io.StringIO(text)
+ return email.message_from_file(io_buffer)
+
+
+email_message_from_string = (
+ py2_message_from_string
+ if sys.version_info < (3,) else
+ email.message_from_string
+ )
+
+# https://bitbucket.org/pypy/pypy/issues/3021/ioopen-directory-leaks-a-file-descriptor
+PYPY_OPEN_BUG = getattr(sys, 'pypy_version_info', (9, 9, 9))[:3] <= (7, 1, 1)
+
+
+def ensure_is_path(ob):
+ """Construct a Path from ob even if it's already one.
+ Specialized for Python 3.4.
+ """
+ if (3,) < sys.version_info < (3, 5):
+ ob = str(ob) # pragma: nocover
+ return pathlib.Path(ob)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libfuturize/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libfuturize/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cb1cbcd6343fc4bc4d69954e412ea508984be2e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libfuturize/__init__.py
@@ -0,0 +1 @@
+# empty to make this a package
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libfuturize/fixer_util.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libfuturize/fixer_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..48e4689db96917b39586f1f939142741dd46203d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libfuturize/fixer_util.py
@@ -0,0 +1,520 @@
+"""
+Utility functions from 2to3, 3to2 and python-modernize (and some home-grown
+ones).
+
+Licences:
+2to3: PSF License v2
+3to2: Apache Software License (from 3to2/setup.py)
+python-modernize licence: BSD (from python-modernize/LICENSE)
+"""
+
+from lib2to3.fixer_util import (FromImport, Newline, is_import,
+ find_root, does_tree_import, Comma)
+from lib2to3.pytree import Leaf, Node
+from lib2to3.pygram import python_symbols as syms, python_grammar
+from lib2to3.pygram import token
+from lib2to3.fixer_util import (Node, Call, Name, syms, Comma, Number)
+import re
+
+
+def canonical_fix_name(fix, avail_fixes):
+ """
+ Examples:
+ >>> canonical_fix_name('fix_wrap_text_literals')
+ 'libfuturize.fixes.fix_wrap_text_literals'
+ >>> canonical_fix_name('wrap_text_literals')
+ 'libfuturize.fixes.fix_wrap_text_literals'
+ >>> canonical_fix_name('wrap_te')
+ ValueError("unknown fixer name")
+ >>> canonical_fix_name('wrap')
+ ValueError("ambiguous fixer name")
+ """
+ if ".fix_" in fix:
+ return fix
+ else:
+ if fix.startswith('fix_'):
+ fix = fix[4:]
+ # Infer the full module name for the fixer.
+ # First ensure that no names clash (e.g.
+ # lib2to3.fixes.fix_blah and libfuturize.fixes.fix_blah):
+ found = [f for f in avail_fixes
+ if f.endswith('fix_{0}'.format(fix))]
+ if len(found) > 1:
+ raise ValueError("Ambiguous fixer name. Choose a fully qualified "
+ "module name instead from these:\n" +
+ "\n".join(" " + myf for myf in found))
+ elif len(found) == 0:
+ raise ValueError("Unknown fixer. Use --list-fixes or -l for a list.")
+ return found[0]
+
+
+
+## These functions are from 3to2 by Joe Amenta:
+
+def Star(prefix=None):
+ return Leaf(token.STAR, u'*', prefix=prefix)
+
+def DoubleStar(prefix=None):
+ return Leaf(token.DOUBLESTAR, u'**', prefix=prefix)
+
+def Minus(prefix=None):
+ return Leaf(token.MINUS, u'-', prefix=prefix)
+
+def commatize(leafs):
+ """
+ Accepts/turns: (Name, Name, ..., Name, Name)
+ Returns/into: (Name, Comma, Name, Comma, ..., Name, Comma, Name)
+ """
+ new_leafs = []
+ for leaf in leafs:
+ new_leafs.append(leaf)
+ new_leafs.append(Comma())
+ del new_leafs[-1]
+ return new_leafs
+
+def indentation(node):
+ """
+ Returns the indentation for this node
+ Iff a node is in a suite, then it has indentation.
+ """
+ while node.parent is not None and node.parent.type != syms.suite:
+ node = node.parent
+ if node.parent is None:
+ return u""
+ # The first three children of a suite are NEWLINE, INDENT, (some other node)
+ # INDENT.value contains the indentation for this suite
+ # anything after (some other node) has the indentation as its prefix.
+ if node.type == token.INDENT:
+ return node.value
+ elif node.prev_sibling is not None and node.prev_sibling.type == token.INDENT:
+ return node.prev_sibling.value
+ elif node.prev_sibling is None:
+ return u""
+ else:
+ return node.prefix
+
+def indentation_step(node):
+ """
+ Dirty little trick to get the difference between each indentation level
+ Implemented by finding the shortest indentation string
+ (technically, the "least" of all of the indentation strings, but
+ tabs and spaces mixed won't get this far, so those are synonymous.)
+ """
+ r = find_root(node)
+ # Collect all indentations into one set.
+ all_indents = set(i.value for i in r.pre_order() if i.type == token.INDENT)
+ if not all_indents:
+ # nothing is indented anywhere, so we get to pick what we want
+ return u" " # four spaces is a popular convention
+ else:
+ return min(all_indents)
+
+def suitify(parent):
+ """
+ Turn the stuff after the first colon in parent's children
+ into a suite, if it wasn't already
+ """
+ for node in parent.children:
+ if node.type == syms.suite:
+ # already in the prefered format, do nothing
+ return
+
+ # One-liners have no suite node, we have to fake one up
+ for i, node in enumerate(parent.children):
+ if node.type == token.COLON:
+ break
+ else:
+ raise ValueError(u"No class suite and no ':'!")
+ # Move everything into a suite node
+ suite = Node(syms.suite, [Newline(), Leaf(token.INDENT, indentation(node) + indentation_step(node))])
+ one_node = parent.children[i+1]
+ one_node.remove()
+ one_node.prefix = u''
+ suite.append_child(one_node)
+ parent.append_child(suite)
+
+def NameImport(package, as_name=None, prefix=None):
+ """
+ Accepts a package (Name node), name to import it as (string), and
+ optional prefix and returns a node:
+ import [as ]
+ """
+ if prefix is None:
+ prefix = u""
+ children = [Name(u"import", prefix=prefix), package]
+ if as_name is not None:
+ children.extend([Name(u"as", prefix=u" "),
+ Name(as_name, prefix=u" ")])
+ return Node(syms.import_name, children)
+
+_compound_stmts = (syms.if_stmt, syms.while_stmt, syms.for_stmt, syms.try_stmt, syms.with_stmt)
+_import_stmts = (syms.import_name, syms.import_from)
+
+def import_binding_scope(node):
+ """
+ Generator yields all nodes for which a node (an import_stmt) has scope
+ The purpose of this is for a call to _find() on each of them
+ """
+ # import_name / import_from are small_stmts
+ assert node.type in _import_stmts
+ test = node.next_sibling
+ # A small_stmt can only be followed by a SEMI or a NEWLINE.
+ while test.type == token.SEMI:
+ nxt = test.next_sibling
+ # A SEMI can only be followed by a small_stmt or a NEWLINE
+ if nxt.type == token.NEWLINE:
+ break
+ else:
+ yield nxt
+ # A small_stmt can only be followed by either a SEMI or a NEWLINE
+ test = nxt.next_sibling
+ # Covered all subsequent small_stmts after the import_stmt
+ # Now to cover all subsequent stmts after the parent simple_stmt
+ parent = node.parent
+ assert parent.type == syms.simple_stmt
+ test = parent.next_sibling
+ while test is not None:
+ # Yes, this will yield NEWLINE and DEDENT. Deal with it.
+ yield test
+ test = test.next_sibling
+
+ context = parent.parent
+ # Recursively yield nodes following imports inside of a if/while/for/try/with statement
+ if context.type in _compound_stmts:
+ # import is in a one-liner
+ c = context
+ while c.next_sibling is not None:
+ yield c.next_sibling
+ c = c.next_sibling
+ context = context.parent
+
+ # Can't chain one-liners on one line, so that takes care of that.
+
+ p = context.parent
+ if p is None:
+ return
+
+ # in a multi-line suite
+
+ while p.type in _compound_stmts:
+
+ if context.type == syms.suite:
+ yield context
+
+ context = context.next_sibling
+
+ if context is None:
+ context = p.parent
+ p = context.parent
+ if p is None:
+ break
+
+def ImportAsName(name, as_name, prefix=None):
+ new_name = Name(name)
+ new_as = Name(u"as", prefix=u" ")
+ new_as_name = Name(as_name, prefix=u" ")
+ new_node = Node(syms.import_as_name, [new_name, new_as, new_as_name])
+ if prefix is not None:
+ new_node.prefix = prefix
+ return new_node
+
+
+def is_docstring(node):
+ """
+ Returns True if the node appears to be a docstring
+ """
+ return (node.type == syms.simple_stmt and
+ len(node.children) > 0 and node.children[0].type == token.STRING)
+
+
+def future_import(feature, node):
+ """
+ This seems to work
+ """
+ root = find_root(node)
+
+ if does_tree_import(u"__future__", feature, node):
+ return
+
+ # Look for a shebang or encoding line
+ shebang_encoding_idx = None
+
+ for idx, node in enumerate(root.children):
+ # Is it a shebang or encoding line?
+ if is_shebang_comment(node) or is_encoding_comment(node):
+ shebang_encoding_idx = idx
+ if is_docstring(node):
+ # skip over docstring
+ continue
+ names = check_future_import(node)
+ if not names:
+ # not a future statement; need to insert before this
+ break
+ if feature in names:
+ # already imported
+ return
+
+ import_ = FromImport(u'__future__', [Leaf(token.NAME, feature, prefix=" ")])
+ if shebang_encoding_idx == 0 and idx == 0:
+ # If this __future__ import would go on the first line,
+ # detach the shebang / encoding prefix from the current first line.
+ # and attach it to our new __future__ import node.
+ import_.prefix = root.children[0].prefix
+ root.children[0].prefix = u''
+ # End the __future__ import line with a newline and add a blank line
+ # afterwards:
+ children = [import_ , Newline()]
+ root.insert_child(idx, Node(syms.simple_stmt, children))
+
+
+def future_import2(feature, node):
+ """
+ An alternative to future_import() which might not work ...
+ """
+ root = find_root(node)
+
+ if does_tree_import(u"__future__", feature, node):
+ return
+
+ insert_pos = 0
+ for idx, node in enumerate(root.children):
+ if node.type == syms.simple_stmt and node.children and \
+ node.children[0].type == token.STRING:
+ insert_pos = idx + 1
+ break
+
+ for thing_after in root.children[insert_pos:]:
+ if thing_after.type == token.NEWLINE:
+ insert_pos += 1
+ continue
+
+ prefix = thing_after.prefix
+ thing_after.prefix = u""
+ break
+ else:
+ prefix = u""
+
+ import_ = FromImport(u"__future__", [Leaf(token.NAME, feature, prefix=u" ")])
+
+ children = [import_, Newline()]
+ root.insert_child(insert_pos, Node(syms.simple_stmt, children, prefix=prefix))
+
+def parse_args(arglist, scheme):
+ u"""
+ Parse a list of arguments into a dict
+ """
+ arglist = [i for i in arglist if i.type != token.COMMA]
+
+ ret_mapping = dict([(k, None) for k in scheme])
+
+ for i, arg in enumerate(arglist):
+ if arg.type == syms.argument and arg.children[1].type == token.EQUAL:
+ # argument < NAME '=' any >
+ slot = arg.children[0].value
+ ret_mapping[slot] = arg.children[2]
+ else:
+ slot = scheme[i]
+ ret_mapping[slot] = arg
+
+ return ret_mapping
+
+
+# def is_import_from(node):
+# """Returns true if the node is a statement "from ... import ..."
+# """
+# return node.type == syms.import_from
+
+
+def is_import_stmt(node):
+ return (node.type == syms.simple_stmt and node.children and
+ is_import(node.children[0]))
+
+
+def touch_import_top(package, name_to_import, node):
+ """Works like `does_tree_import` but adds an import statement at the
+ top if it was not imported (but below any __future__ imports) and below any
+ comments such as shebang lines).
+
+ Based on lib2to3.fixer_util.touch_import()
+
+ Calling this multiple times adds the imports in reverse order.
+
+ Also adds "standard_library.install_aliases()" after "from future import
+ standard_library". This should probably be factored into another function.
+ """
+
+ root = find_root(node)
+
+ if does_tree_import(package, name_to_import, root):
+ return
+
+ # Ideally, we would look for whether futurize --all-imports has been run,
+ # as indicated by the presence of ``from builtins import (ascii, ...,
+ # zip)`` -- and, if it has, we wouldn't import the name again.
+
+ # Look for __future__ imports and insert below them
+ found = False
+ for name in ['absolute_import', 'division', 'print_function',
+ 'unicode_literals']:
+ if does_tree_import('__future__', name, root):
+ found = True
+ break
+ if found:
+ # At least one __future__ import. We want to loop until we've seen them
+ # all.
+ start, end = None, None
+ for idx, node in enumerate(root.children):
+ if check_future_import(node):
+ start = idx
+ # Start looping
+ idx2 = start
+ while node:
+ node = node.next_sibling
+ idx2 += 1
+ if not check_future_import(node):
+ end = idx2
+ break
+ break
+ assert start is not None
+ assert end is not None
+ insert_pos = end
+ else:
+ # No __future__ imports.
+ # We look for a docstring and insert the new node below that. If no docstring
+ # exists, just insert the node at the top.
+ for idx, node in enumerate(root.children):
+ if node.type != syms.simple_stmt:
+ break
+ if not is_docstring(node):
+ # This is the usual case.
+ break
+ insert_pos = idx
+
+ if package is None:
+ import_ = Node(syms.import_name, [
+ Leaf(token.NAME, u"import"),
+ Leaf(token.NAME, name_to_import, prefix=u" ")
+ ])
+ else:
+ import_ = FromImport(package, [Leaf(token.NAME, name_to_import, prefix=u" ")])
+ if name_to_import == u'standard_library':
+ # Add:
+ # standard_library.install_aliases()
+ # after:
+ # from future import standard_library
+ install_hooks = Node(syms.simple_stmt,
+ [Node(syms.power,
+ [Leaf(token.NAME, u'standard_library'),
+ Node(syms.trailer, [Leaf(token.DOT, u'.'),
+ Leaf(token.NAME, u'install_aliases')]),
+ Node(syms.trailer, [Leaf(token.LPAR, u'('),
+ Leaf(token.RPAR, u')')])
+ ])
+ ]
+ )
+ children_hooks = [install_hooks, Newline()]
+ else:
+ children_hooks = []
+
+ # FromImport(package, [Leaf(token.NAME, name_to_import, prefix=u" ")])
+
+ children_import = [import_, Newline()]
+ old_prefix = root.children[insert_pos].prefix
+ root.children[insert_pos].prefix = u''
+ root.insert_child(insert_pos, Node(syms.simple_stmt, children_import, prefix=old_prefix))
+ if len(children_hooks) > 0:
+ root.insert_child(insert_pos + 1, Node(syms.simple_stmt, children_hooks))
+
+
+## The following functions are from python-modernize by Armin Ronacher:
+# (a little edited).
+
+def check_future_import(node):
+ """If this is a future import, return set of symbols that are imported,
+ else return None."""
+ # node should be the import statement here
+ savenode = node
+ if not (node.type == syms.simple_stmt and node.children):
+ return set()
+ node = node.children[0]
+ # now node is the import_from node
+ if not (node.type == syms.import_from and
+ # node.type == token.NAME and # seems to break it
+ hasattr(node.children[1], 'value') and
+ node.children[1].value == u'__future__'):
+ return set()
+ if node.children[3].type == token.LPAR:
+ node = node.children[4]
+ else:
+ node = node.children[3]
+ # now node is the import_as_name[s]
+ # print(python_grammar.number2symbol[node.type]) # breaks sometimes
+ if node.type == syms.import_as_names:
+ result = set()
+ for n in node.children:
+ if n.type == token.NAME:
+ result.add(n.value)
+ elif n.type == syms.import_as_name:
+ n = n.children[0]
+ assert n.type == token.NAME
+ result.add(n.value)
+ return result
+ elif node.type == syms.import_as_name:
+ node = node.children[0]
+ assert node.type == token.NAME
+ return set([node.value])
+ elif node.type == token.NAME:
+ return set([node.value])
+ else:
+ # TODO: handle brackets like this:
+ # from __future__ import (absolute_import, division)
+ assert False, "strange import: %s" % savenode
+
+
+SHEBANG_REGEX = r'^#!.*python'
+ENCODING_REGEX = r"^#.*coding[:=]\s*([-\w.]+)"
+
+
+def is_shebang_comment(node):
+ """
+ Comments are prefixes for Leaf nodes. Returns whether the given node has a
+ prefix that looks like a shebang line or an encoding line:
+
+ #!/usr/bin/env python
+ #!/usr/bin/python3
+ """
+ return bool(re.match(SHEBANG_REGEX, node.prefix))
+
+
+def is_encoding_comment(node):
+ """
+ Comments are prefixes for Leaf nodes. Returns whether the given node has a
+ prefix that looks like an encoding line:
+
+ # coding: utf-8
+ # encoding: utf-8
+ # -*- coding: -*-
+ # vim: set fileencoding= :
+ """
+ return bool(re.match(ENCODING_REGEX, node.prefix))
+
+
+def wrap_in_fn_call(fn_name, args, prefix=None):
+ """
+ Example:
+ >>> wrap_in_fn_call("oldstr", (arg,))
+ oldstr(arg)
+
+ >>> wrap_in_fn_call("olddiv", (arg1, arg2))
+ olddiv(arg1, arg2)
+
+ >>> wrap_in_fn_call("olddiv", [arg1, comma, arg2, comma, arg3])
+ olddiv(arg1, arg2, arg3)
+ """
+ assert len(args) > 0
+ if len(args) == 2:
+ expr1, expr2 = args
+ newargs = [expr1, Comma(), expr2]
+ else:
+ newargs = args
+ return Call(Name(fn_name), newargs, prefix=prefix)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libfuturize/main.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libfuturize/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..634c2f25e68b5d94f5b7f5110931709697fa4a21
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libfuturize/main.py
@@ -0,0 +1,322 @@
+"""
+futurize: automatic conversion to clean 2/3 code using ``python-future``
+======================================================================
+
+Like Armin Ronacher's modernize.py, ``futurize`` attempts to produce clean
+standard Python 3 code that runs on both Py2 and Py3.
+
+One pass
+--------
+
+Use it like this on Python 2 code:
+
+ $ futurize --verbose mypython2script.py
+
+This will attempt to port the code to standard Py3 code that also
+provides Py2 compatibility with the help of the right imports from
+``future``.
+
+To write changes to the files, use the -w flag.
+
+Two stages
+----------
+
+The ``futurize`` script can also be called in two separate stages. First:
+
+ $ futurize --stage1 mypython2script.py
+
+This produces more modern Python 2 code that is not yet compatible with Python
+3. The tests should still run and the diff should be uncontroversial to apply to
+most Python projects that are willing to drop support for Python 2.5 and lower.
+
+After this, the recommended approach is to explicitly mark all strings that must
+be byte-strings with a b'' prefix and all text (unicode) strings with a u''
+prefix, and then invoke the second stage of Python 2 to 2/3 conversion with::
+
+ $ futurize --stage2 mypython2script.py
+
+Stage 2 adds a dependency on ``future``. It converts most remaining Python
+2-specific code to Python 3 code and adds appropriate imports from ``future``
+to restore Py2 support.
+
+The command above leaves all unadorned string literals as native strings
+(byte-strings on Py2, unicode strings on Py3). If instead you would like all
+unadorned string literals to be promoted to unicode, you can also pass this
+flag:
+
+ $ futurize --stage2 --unicode-literals mypython2script.py
+
+This adds the declaration ``from __future__ import unicode_literals`` to the
+top of each file, which implicitly declares all unadorned string literals to be
+unicode strings (``unicode`` on Py2).
+
+All imports
+-----------
+
+The --all-imports option forces adding all ``__future__`` imports,
+``builtins`` imports, and standard library aliases, even if they don't
+seem necessary for the current state of each module. (This can simplify
+testing, and can reduce the need to think about Py2 compatibility when editing
+the code further.)
+
+"""
+
+from __future__ import (absolute_import, print_function, unicode_literals)
+import future.utils
+from future import __version__
+
+import sys
+import logging
+import optparse
+import os
+
+from lib2to3.main import warn, StdoutRefactoringTool
+from lib2to3 import refactor
+
+from libfuturize.fixes import (lib2to3_fix_names_stage1,
+ lib2to3_fix_names_stage2,
+ libfuturize_fix_names_stage1,
+ libfuturize_fix_names_stage2)
+
+fixer_pkg = 'libfuturize.fixes'
+
+
+def main(args=None):
+ """Main program.
+
+ Args:
+ fixer_pkg: the name of a package where the fixers are located.
+ args: optional; a list of command line arguments. If omitted,
+ sys.argv[1:] is used.
+
+ Returns a suggested exit status (0, 1, 2).
+ """
+
+ # Set up option parser
+ parser = optparse.OptionParser(usage="futurize [options] file|dir ...")
+ parser.add_option("-V", "--version", action="store_true",
+ help="Report the version number of futurize")
+ parser.add_option("-a", "--all-imports", action="store_true",
+ help="Add all __future__ and future imports to each module")
+ parser.add_option("-1", "--stage1", action="store_true",
+ help="Modernize Python 2 code only; no compatibility with Python 3 (or dependency on ``future``)")
+ parser.add_option("-2", "--stage2", action="store_true",
+ help="Take modernized (stage1) code and add a dependency on ``future`` to provide Py3 compatibility.")
+ parser.add_option("-0", "--both-stages", action="store_true",
+ help="Apply both stages 1 and 2")
+ parser.add_option("-u", "--unicode-literals", action="store_true",
+ help="Add ``from __future__ import unicode_literals`` to implicitly convert all unadorned string literals '' into unicode strings")
+ parser.add_option("-f", "--fix", action="append", default=[],
+ help="Each FIX specifies a transformation; default: all.\nEither use '-f division -f metaclass' etc. or use the fully-qualified module name: '-f lib2to3.fixes.fix_types -f libfuturize.fixes.fix_unicode_keep_u'")
+ parser.add_option("-j", "--processes", action="store", default=1,
+ type="int", help="Run 2to3 concurrently")
+ parser.add_option("-x", "--nofix", action="append", default=[],
+ help="Prevent a fixer from being run.")
+ parser.add_option("-l", "--list-fixes", action="store_true",
+ help="List available transformations")
+ parser.add_option("-p", "--print-function", action="store_true",
+ help="Modify the grammar so that print() is a function")
+ parser.add_option("-v", "--verbose", action="store_true",
+ help="More verbose logging")
+ parser.add_option("--no-diffs", action="store_true",
+ help="Don't show diffs of the refactoring")
+ parser.add_option("-w", "--write", action="store_true",
+ help="Write back modified files")
+ parser.add_option("-n", "--nobackups", action="store_true", default=False,
+ help="Don't write backups for modified files.")
+ parser.add_option("-o", "--output-dir", action="store", type="str",
+ default="", help="Put output files in this directory "
+ "instead of overwriting the input files. Requires -n. "
+ "For Python >= 2.7 only.")
+ parser.add_option("-W", "--write-unchanged-files", action="store_true",
+ help="Also write files even if no changes were required"
+ " (useful with --output-dir); implies -w.")
+ parser.add_option("--add-suffix", action="store", type="str", default="",
+ help="Append this string to all output filenames."
+ " Requires -n if non-empty. For Python >= 2.7 only."
+ "ex: --add-suffix='3' will generate .py3 files.")
+
+ # Parse command line arguments
+ flags = {}
+ refactor_stdin = False
+ options, args = parser.parse_args(args)
+
+ if options.write_unchanged_files:
+ flags["write_unchanged_files"] = True
+ if not options.write:
+ warn("--write-unchanged-files/-W implies -w.")
+ options.write = True
+ # If we allowed these, the original files would be renamed to backup names
+ # but not replaced.
+ if options.output_dir and not options.nobackups:
+ parser.error("Can't use --output-dir/-o without -n.")
+ if options.add_suffix and not options.nobackups:
+ parser.error("Can't use --add-suffix without -n.")
+
+ if not options.write and options.no_diffs:
+ warn("not writing files and not printing diffs; that's not very useful")
+ if not options.write and options.nobackups:
+ parser.error("Can't use -n without -w")
+ if "-" in args:
+ refactor_stdin = True
+ if options.write:
+ print("Can't write to stdin.", file=sys.stderr)
+ return 2
+ # Is this ever necessary?
+ if options.print_function:
+ flags["print_function"] = True
+
+ # Set up logging handler
+ level = logging.DEBUG if options.verbose else logging.INFO
+ logging.basicConfig(format='%(name)s: %(message)s', level=level)
+ logger = logging.getLogger('libfuturize.main')
+
+ if options.stage1 or options.stage2:
+ assert options.both_stages is None
+ options.both_stages = False
+ else:
+ options.both_stages = True
+
+ avail_fixes = set()
+
+ if options.stage1 or options.both_stages:
+ avail_fixes.update(lib2to3_fix_names_stage1)
+ avail_fixes.update(libfuturize_fix_names_stage1)
+ if options.stage2 or options.both_stages:
+ avail_fixes.update(lib2to3_fix_names_stage2)
+ avail_fixes.update(libfuturize_fix_names_stage2)
+
+ if options.unicode_literals:
+ avail_fixes.add('libfuturize.fixes.fix_unicode_literals_import')
+
+ if options.version:
+ print(__version__)
+ return 0
+ if options.list_fixes:
+ print("Available transformations for the -f/--fix option:")
+ # for fixname in sorted(refactor.get_all_fix_names(fixer_pkg)):
+ for fixname in sorted(avail_fixes):
+ print(fixname)
+ if not args:
+ return 0
+ if not args:
+ print("At least one file or directory argument required.",
+ file=sys.stderr)
+ print("Use --help to show usage.", file=sys.stderr)
+ return 2
+
+ unwanted_fixes = set()
+ for fix in options.nofix:
+ if ".fix_" in fix:
+ unwanted_fixes.add(fix)
+ else:
+ # Infer the full module name for the fixer.
+ # First ensure that no names clash (e.g.
+ # lib2to3.fixes.fix_blah and libfuturize.fixes.fix_blah):
+ found = [f for f in avail_fixes
+ if f.endswith('fix_{0}'.format(fix))]
+ if len(found) > 1:
+ print("Ambiguous fixer name. Choose a fully qualified "
+ "module name instead from these:\n" +
+ "\n".join(" " + myf for myf in found),
+ file=sys.stderr)
+ return 2
+ elif len(found) == 0:
+ print("Unknown fixer. Use --list-fixes or -l for a list.",
+ file=sys.stderr)
+ return 2
+ unwanted_fixes.add(found[0])
+
+ extra_fixes = set()
+ if options.all_imports:
+ if options.stage1:
+ prefix = 'libfuturize.fixes.'
+ extra_fixes.add(prefix +
+ 'fix_add__future__imports_except_unicode_literals')
+ else:
+ # In case the user hasn't run stage1 for some reason:
+ prefix = 'libpasteurize.fixes.'
+ extra_fixes.add(prefix + 'fix_add_all__future__imports')
+ extra_fixes.add(prefix + 'fix_add_future_standard_library_import')
+ extra_fixes.add(prefix + 'fix_add_all_future_builtins')
+ explicit = set()
+ if options.fix:
+ all_present = False
+ for fix in options.fix:
+ if fix == 'all':
+ all_present = True
+ else:
+ if ".fix_" in fix:
+ explicit.add(fix)
+ else:
+ # Infer the full module name for the fixer.
+ # First ensure that no names clash (e.g.
+ # lib2to3.fixes.fix_blah and libfuturize.fixes.fix_blah):
+ found = [f for f in avail_fixes
+ if f.endswith('fix_{0}'.format(fix))]
+ if len(found) > 1:
+ print("Ambiguous fixer name. Choose a fully qualified "
+ "module name instead from these:\n" +
+ "\n".join(" " + myf for myf in found),
+ file=sys.stderr)
+ return 2
+ elif len(found) == 0:
+ print("Unknown fixer. Use --list-fixes or -l for a list.",
+ file=sys.stderr)
+ return 2
+ explicit.add(found[0])
+ if len(explicit & unwanted_fixes) > 0:
+ print("Conflicting usage: the following fixers have been "
+ "simultaneously requested and disallowed:\n" +
+ "\n".join(" " + myf for myf in (explicit & unwanted_fixes)),
+ file=sys.stderr)
+ return 2
+ requested = avail_fixes.union(explicit) if all_present else explicit
+ else:
+ requested = avail_fixes.union(explicit)
+ fixer_names = (requested | extra_fixes) - unwanted_fixes
+
+ input_base_dir = os.path.commonprefix(args)
+ if (input_base_dir and not input_base_dir.endswith(os.sep)
+ and not os.path.isdir(input_base_dir)):
+ # One or more similar names were passed, their directory is the base.
+ # os.path.commonprefix() is ignorant of path elements, this corrects
+ # for that weird API.
+ input_base_dir = os.path.dirname(input_base_dir)
+ if options.output_dir:
+ input_base_dir = input_base_dir.rstrip(os.sep)
+ logger.info('Output in %r will mirror the input directory %r layout.',
+ options.output_dir, input_base_dir)
+
+ # Initialize the refactoring tool
+ if future.utils.PY26:
+ extra_kwargs = {}
+ else:
+ extra_kwargs = {
+ 'append_suffix': options.add_suffix,
+ 'output_dir': options.output_dir,
+ 'input_base_dir': input_base_dir,
+ }
+
+ rt = StdoutRefactoringTool(
+ sorted(fixer_names), flags, sorted(explicit),
+ options.nobackups, not options.no_diffs,
+ **extra_kwargs)
+
+ # Refactor all files and directories passed as arguments
+ if not rt.errors:
+ if refactor_stdin:
+ rt.refactor_stdin()
+ else:
+ try:
+ rt.refactor(args, options.write, None,
+ options.processes)
+ except refactor.MultiprocessingUnsupported:
+ assert options.processes > 1
+ print("Sorry, -j isn't " \
+ "supported on this platform.", file=sys.stderr)
+ return 1
+ rt.summarize()
+
+ # Return error status (0 if rt.errors is zero)
+ return int(bool(rt.errors))
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libpasteurize/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libpasteurize/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cb1cbcd6343fc4bc4d69954e412ea508984be2e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libpasteurize/__init__.py
@@ -0,0 +1 @@
+# empty to make this a package
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libpasteurize/main.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libpasteurize/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..4179174b566596a19163931419219215c9bd4781
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/libpasteurize/main.py
@@ -0,0 +1,204 @@
+"""
+pasteurize: automatic conversion of Python 3 code to clean 2/3 code
+===================================================================
+
+``pasteurize`` attempts to convert existing Python 3 code into source-compatible
+Python 2 and 3 code.
+
+Use it like this on Python 3 code:
+
+ $ pasteurize --verbose mypython3script.py
+
+This removes any Py3-only syntax (e.g. new metaclasses) and adds these
+import lines:
+
+ from __future__ import absolute_import
+ from __future__ import division
+ from __future__ import print_function
+ from __future__ import unicode_literals
+ from future import standard_library
+ standard_library.install_hooks()
+ from builtins import *
+
+To write changes to the files, use the -w flag.
+
+It also adds any other wrappers needed for Py2/3 compatibility.
+
+Note that separate stages are not available (or needed) when converting from
+Python 3 with ``pasteurize`` as they are when converting from Python 2 with
+``futurize``.
+
+The --all-imports option forces adding all ``__future__`` imports,
+``builtins`` imports, and standard library aliases, even if they don't
+seem necessary for the current state of each module. (This can simplify
+testing, and can reduce the need to think about Py2 compatibility when editing
+the code further.)
+
+"""
+
+from __future__ import (absolute_import, print_function, unicode_literals)
+
+import sys
+import logging
+import optparse
+from lib2to3.main import main, warn, StdoutRefactoringTool
+from lib2to3 import refactor
+
+from future import __version__
+from libpasteurize.fixes import fix_names
+
+
+def main(args=None):
+ """Main program.
+
+ Returns a suggested exit status (0, 1, 2).
+ """
+ # Set up option parser
+ parser = optparse.OptionParser(usage="pasteurize [options] file|dir ...")
+ parser.add_option("-V", "--version", action="store_true",
+ help="Report the version number of pasteurize")
+ parser.add_option("-a", "--all-imports", action="store_true",
+ help="Adds all __future__ and future imports to each module")
+ parser.add_option("-f", "--fix", action="append", default=[],
+ help="Each FIX specifies a transformation; default: all")
+ parser.add_option("-j", "--processes", action="store", default=1,
+ type="int", help="Run 2to3 concurrently")
+ parser.add_option("-x", "--nofix", action="append", default=[],
+ help="Prevent a fixer from being run.")
+ parser.add_option("-l", "--list-fixes", action="store_true",
+ help="List available transformations")
+ # parser.add_option("-p", "--print-function", action="store_true",
+ # help="Modify the grammar so that print() is a function")
+ parser.add_option("-v", "--verbose", action="store_true",
+ help="More verbose logging")
+ parser.add_option("--no-diffs", action="store_true",
+ help="Don't show diffs of the refactoring")
+ parser.add_option("-w", "--write", action="store_true",
+ help="Write back modified files")
+ parser.add_option("-n", "--nobackups", action="store_true", default=False,
+ help="Don't write backups for modified files.")
+
+ # Parse command line arguments
+ refactor_stdin = False
+ flags = {}
+ options, args = parser.parse_args(args)
+ fixer_pkg = 'libpasteurize.fixes'
+ avail_fixes = fix_names
+ flags["print_function"] = True
+
+ if not options.write and options.no_diffs:
+ warn("not writing files and not printing diffs; that's not very useful")
+ if not options.write and options.nobackups:
+ parser.error("Can't use -n without -w")
+ if options.version:
+ print(__version__)
+ return 0
+ if options.list_fixes:
+ print("Available transformations for the -f/--fix option:")
+ for fixname in sorted(avail_fixes):
+ print(fixname)
+ if not args:
+ return 0
+ if not args:
+ print("At least one file or directory argument required.",
+ file=sys.stderr)
+ print("Use --help to show usage.", file=sys.stderr)
+ return 2
+ if "-" in args:
+ refactor_stdin = True
+ if options.write:
+ print("Can't write to stdin.", file=sys.stderr)
+ return 2
+
+ # Set up logging handler
+ level = logging.DEBUG if options.verbose else logging.INFO
+ logging.basicConfig(format='%(name)s: %(message)s', level=level)
+
+ unwanted_fixes = set()
+ for fix in options.nofix:
+ if ".fix_" in fix:
+ unwanted_fixes.add(fix)
+ else:
+ # Infer the full module name for the fixer.
+ # First ensure that no names clash (e.g.
+ # lib2to3.fixes.fix_blah and libfuturize.fixes.fix_blah):
+ found = [f for f in avail_fixes
+ if f.endswith('fix_{0}'.format(fix))]
+ if len(found) > 1:
+ print("Ambiguous fixer name. Choose a fully qualified "
+ "module name instead from these:\n" +
+ "\n".join(" " + myf for myf in found),
+ file=sys.stderr)
+ return 2
+ elif len(found) == 0:
+ print("Unknown fixer. Use --list-fixes or -l for a list.",
+ file=sys.stderr)
+ return 2
+ unwanted_fixes.add(found[0])
+
+ extra_fixes = set()
+ if options.all_imports:
+ prefix = 'libpasteurize.fixes.'
+ extra_fixes.add(prefix + 'fix_add_all__future__imports')
+ extra_fixes.add(prefix + 'fix_add_future_standard_library_import')
+ extra_fixes.add(prefix + 'fix_add_all_future_builtins')
+
+ explicit = set()
+ if options.fix:
+ all_present = False
+ for fix in options.fix:
+ if fix == 'all':
+ all_present = True
+ else:
+ if ".fix_" in fix:
+ explicit.add(fix)
+ else:
+ # Infer the full module name for the fixer.
+ # First ensure that no names clash (e.g.
+ # lib2to3.fixes.fix_blah and libpasteurize.fixes.fix_blah):
+ found = [f for f in avail_fixes
+ if f.endswith('fix_{0}'.format(fix))]
+ if len(found) > 1:
+ print("Ambiguous fixer name. Choose a fully qualified "
+ "module name instead from these:\n" +
+ "\n".join(" " + myf for myf in found),
+ file=sys.stderr)
+ return 2
+ elif len(found) == 0:
+ print("Unknown fixer. Use --list-fixes or -l for a list.",
+ file=sys.stderr)
+ return 2
+ explicit.add(found[0])
+ if len(explicit & unwanted_fixes) > 0:
+ print("Conflicting usage: the following fixers have been "
+ "simultaneously requested and disallowed:\n" +
+ "\n".join(" " + myf for myf in (explicit & unwanted_fixes)),
+ file=sys.stderr)
+ return 2
+ requested = avail_fixes.union(explicit) if all_present else explicit
+ else:
+ requested = avail_fixes.union(explicit)
+
+ fixer_names = requested | extra_fixes - unwanted_fixes
+
+ # Initialize the refactoring tool
+ rt = StdoutRefactoringTool(sorted(fixer_names), flags, set(),
+ options.nobackups, not options.no_diffs)
+
+ # Refactor all files and directories passed as arguments
+ if not rt.errors:
+ if refactor_stdin:
+ rt.refactor_stdin()
+ else:
+ try:
+ rt.refactor(args, options.write, None,
+ options.processes)
+ except refactor.MultiprocessingUnsupported:
+ assert options.processes > 1
+ print("Sorry, -j isn't " \
+ "supported on this platform.", file=sys.stderr)
+ return 1
+ rt.summarize()
+
+ # Return error status (0 if rt.errors is zero)
+ return int(bool(rt.errors))
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/INSTALLER b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/LICENSE b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..0a523bece3e50519653c4d7a38399baa487fefa1
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2012 Erik Rose
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/METADATA b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..e712d08090eacb51aa608136e4e2b322b7c413ee
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/METADATA
@@ -0,0 +1,460 @@
+Metadata-Version: 2.1
+Name: more-itertools
+Version: 5.0.0
+Summary: More routines for operating on iterables, beyond itertools
+Home-page: https://github.com/erikrose/more-itertools
+Author: Erik Rose
+Author-email: erikrose@grinchcentral.com
+License: MIT
+Keywords: itertools,iterator,iteration,filter,peek,peekable,collate,chunk,chunked
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: six (<2.0.0,>=1.0.0)
+
+==============
+More Itertools
+==============
+
+.. image:: https://coveralls.io/repos/github/erikrose/more-itertools/badge.svg?branch=master
+ :target: https://coveralls.io/github/erikrose/more-itertools?branch=master
+
+Python's ``itertools`` library is a gem - you can compose elegant solutions
+for a variety of problems with the functions it provides. In ``more-itertools``
+we collect additional building blocks, recipes, and routines for working with
+Python iterables.
+
+----
+
++------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Grouping | `chunked `_, |
+| | `sliced `_, |
+| | `distribute `_, |
+| | `divide `_, |
+| | `split_at `_, |
+| | `split_before `_, |
+| | `split_after `_, |
+| | `bucket `_, |
+| | `grouper `_, |
+| | `partition `_ |
++------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Lookahead and lookback | `spy `_, |
+| | `peekable `_, |
+| | `seekable `_ |
++------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Windowing | `windowed `_, |
+| | `stagger `_, |
+| | `pairwise `_ |
++------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Augmenting | `count_cycle `_, |
+| | `intersperse `_, |
+| | `padded `_, |
+| | `adjacent `_, |
+| | `groupby_transform `_, |
+| | `padnone `_, |
+| | `ncycles `_ |
++------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Combining | `collapse `_, |
+| | `sort_together `_, |
+| | `interleave `_, |
+| | `interleave_longest `_, |
+| | `collate `_, |
+| | `zip_offset `_, |
+| | `dotproduct `_, |
+| | `flatten `_, |
+| | `roundrobin `_, |
+| | `prepend `_ |
++------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Summarizing | `ilen `_, |
+| | `first `_, |
+| | `last `_, |
+| | `one `_, |
+| | `unique_to_each `_, |
+| | `locate `_, |
+| | `rlocate `_, |
+| | `consecutive_groups `_, |
+| | `exactly_n `_, |
+| | `run_length `_, |
+| | `map_reduce `_, |
+| | `all_equal `_, |
+| | `first_true `_, |
+| | `nth `_, |
+| | `quantify `_ |
++------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Selecting | `islice_extended `_, |
+| | `strip `_, |
+| | `lstrip `_, |
+| | `rstrip `_, |
+| | `take `_, |
+| | `tail `_, |
+| | `unique_everseen `_, |
+| | `unique_justseen `_ |
++------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Combinatorics | `distinct_permutations `_, |
+| | `circular_shifts `_, |
+| | `powerset `_, |
+| | `random_product `_, |
+| | `random_permutation `_, |
+| | `random_combination `_, |
+| | `random_combination_with_replacement `_, |
+| | `nth_combination `_ |
++------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Wrapping | `always_iterable `_, |
+| | `consumer `_, |
+| | `with_iter `_, |
+| | `iter_except `_ |
++------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Others | `replace `_, |
+| | `numeric_range `_, |
+| | `always_reversible `_, |
+| | `side_effect `_, |
+| | `iterate `_, |
+| | `difference `_, |
+| | `make_decorator `_, |
+| | `SequenceView `_, |
+| | `consume `_, |
+| | `accumulate `_, |
+| | `tabulate `_, |
+| | `repeatfunc `_ |
++------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
+
+Getting started
+===============
+
+To get started, install the library with `pip `_
+are included in the top-level package:
+
+.. code-block:: python
+
+ >>> from more_itertools import flatten
+ >>> iterable = [(0, 1), (2, 3)]
+ >>> list(flatten(iterable))
+ [0, 1, 2, 3]
+
+Several new recipes are available as well:
+
+.. code-block:: python
+
+ >>> from more_itertools import chunked
+ >>> iterable = [0, 1, 2, 3, 4, 5, 6, 7, 8]
+ >>> list(chunked(iterable, 3))
+ [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
+
+ >>> from more_itertools import spy
+ >>> iterable = (x * x for x in range(1, 6))
+ >>> head, iterable = spy(iterable, n=3)
+ >>> list(head)
+ [1, 4, 9]
+ >>> list(iterable)
+ [1, 4, 9, 16, 25]
+
+
+
+For the full listing of functions, see the `API documentation `_.
+
+Development
+===========
+
+``more-itertools`` is maintained by `@erikrose `_
+and `@bbayles `_, with help from `many others `_.
+If you have a problem or suggestion, please file a bug or pull request in this
+repository. Thanks for contributing!
+
+
+Version History
+===============
+
+
+
+5.0.0
+-----
+
+* New itertools:
+ * split_into (thanks to rovyko)
+ * unzip (thanks to bmintz)
+ * substrings (thanks to pylang)
+
+* Changes to existing itertools:
+ * ilen was optimized a bit (thanks to MSeifert04, achampion, and bmintz)
+ * first_true now returns ``None`` by default. This is the reason for the major version bump - see below. (thanks to sk and OJFord)
+
+* Other changes:
+ * Some code for old Python versions was removed (thanks to hugovk)
+ * Some documentation mistakes were corrected (thanks to belm0 and hugovk)
+ * Tests now run properly on 32-bit versions of Python (thanks to Millak)
+ * Newer versions of CPython and PyPy are now tested against
+
+The major version update is due to the change in the default return value of
+first_true. It's now ``None``.
+
+.. code-block:: python
+
+ >>> from more_itertools import first_true
+ >>> iterable = [0, '', False, [], ()] # All these are False
+ >>> answer = first_true(iterable)
+ >>> print(answer)
+ None
+
+4.3.0
+-----
+
+* New itertools:
+ * last (thanks to tmshn)
+ * replace (thanks to pylang)
+ * rlocate (thanks to jferard and pylang)
+
+* Improvements to existing itertools:
+ * locate can now search for multiple items
+
+* Other changes:
+ * The docs now include a nice table of tools (thanks MSeifert04)
+
+4.2.0
+-----
+
+* New itertools:
+ * map_reduce (thanks to pylang)
+ * prepend (from the `Python 3.7 docs `_)
+
+* Improvements to existing itertools:
+ * bucket now complies with PEP 479 (thanks to irmen)
+
+* Other changes:
+ * Python 3.7 is now supported (thanks to irmen)
+ * Python 3.3 is no longer supported
+ * The test suite no longer requires third-party modules to run
+ * The API docs now include links to source code
+
+4.1.0
+-----
+
+* New itertools:
+ * split_at (thanks to michael-celani)
+ * circular_shifts (thanks to hiqua)
+ * make_decorator - see the blog post `Yo, I heard you like decorators `_
+ for a tour (thanks to pylang)
+ * always_reversible (thanks to michael-celani)
+ * nth_combination (from the `Python 3.7 docs `_)
+
+* Improvements to existing itertools:
+ * seekable now has an ``elements`` method to return cached items.
+ * The performance tradeoffs between roundrobin and
+ interleave_longest are now documented (thanks michael-celani,
+ pylang, and MSeifert04)
+
+4.0.1
+-----
+
+* No code changes - this release fixes how the docs display on PyPI.
+
+4.0.0
+-----
+
+* New itertools:
+ * consecutive_groups (Based on the example in the `Python 2.4 docs `_)
+ * seekable (If you're looking for how to "reset" an iterator,
+ you're in luck!)
+ * exactly_n (thanks to michael-celani)
+ * run_length.encode and run_length.decode
+ * difference
+
+* Improvements to existing itertools:
+ * The number of items between filler elements in intersperse can
+ now be specified (thanks to pylang)
+ * distinct_permutations and peekable got some minor
+ adjustments (thanks to MSeifert04)
+ * always_iterable now returns an iterator object. It also now
+ allows different types to be considered iterable (thanks to jaraco)
+ * bucket can now limit the keys it stores in memory
+ * one now allows for custom exceptions (thanks to kalekundert)
+
+* Other changes:
+ * A few typos were fixed (thanks to EdwardBetts)
+ * All tests can now be run with ``python setup.py test``
+
+The major version update is due to the change in the return value of always_iterable.
+It now always returns iterator objects:
+
+.. code-block:: python
+
+ >>> from more_itertools import always_iterable
+ # Non-iterable objects are wrapped with iter(tuple(obj))
+ >>> always_iterable(12345)
+
+ >>> list(always_iterable(12345))
+ [12345]
+ # Iterable objects are wrapped with iter()
+ >>> always_iterable([1, 2, 3, 4, 5])
+
+
+3.2.0
+-----
+
+* New itertools:
+ * lstrip, rstrip, and strip
+ (thanks to MSeifert04 and pylang)
+ * islice_extended
+* Improvements to existing itertools:
+ * Some bugs with slicing peekable-wrapped iterables were fixed
+
+3.1.0
+-----
+
+* New itertools:
+ * numeric_range (Thanks to BebeSparkelSparkel and MSeifert04)
+ * count_cycle (Thanks to BebeSparkelSparkel)
+ * locate (Thanks to pylang and MSeifert04)
+* Improvements to existing itertools:
+ * A few itertools are now slightly faster due to some function
+ optimizations. (Thanks to MSeifert04)
+* The docs have been substantially revised with installation notes,
+ categories for library functions, links, and more. (Thanks to pylang)
+
+
+3.0.0
+-----
+
+* Removed itertools:
+ * ``context`` has been removed due to a design flaw - see below for
+ replacement options. (thanks to NeilGirdhar)
+* Improvements to existing itertools:
+ * ``side_effect`` now supports ``before`` and ``after`` keyword
+ arguments. (Thanks to yardsale8)
+* PyPy and PyPy3 are now supported.
+
+The major version change is due to the removal of the ``context`` function.
+Replace it with standard ``with`` statement context management:
+
+.. code-block:: python
+
+ # Don't use context() anymore
+ file_obj = StringIO()
+ consume(print(x, file=f) for f in context(file_obj) for x in u'123')
+
+ # Use a with statement instead
+ file_obj = StringIO()
+ with file_obj as f:
+ consume(print(x, file=f) for x in u'123')
+
+2.6.0
+-----
+
+* New itertools:
+ * ``adjacent`` and ``groupby_transform`` (Thanks to diazona)
+ * ``always_iterable`` (Thanks to jaraco)
+ * (Removed in 3.0.0) ``context`` (Thanks to yardsale8)
+ * ``divide`` (Thanks to mozbhearsum)
+* Improvements to existing itertools:
+ * ``ilen`` is now slightly faster. (Thanks to wbolster)
+ * ``peekable`` can now prepend items to an iterable. (Thanks to diazona)
+
+2.5.0
+-----
+
+* New itertools:
+ * ``distribute`` (Thanks to mozbhearsum and coady)
+ * ``sort_together`` (Thanks to clintval)
+ * ``stagger`` and ``zip_offset`` (Thanks to joshbode)
+ * ``padded``
+* Improvements to existing itertools:
+ * ``peekable`` now handles negative indexes and slices with negative
+ components properly.
+ * ``intersperse`` is now slightly faster. (Thanks to pylang)
+ * ``windowed`` now accepts a ``step`` keyword argument.
+ (Thanks to pylang)
+* Python 3.6 is now supported.
+
+2.4.1
+-----
+
+* Move docs 100% to readthedocs.io.
+
+2.4
+-----
+
+* New itertools:
+ * ``accumulate``, ``all_equal``, ``first_true``, ``partition``, and
+ ``tail`` from the itertools documentation.
+ * ``bucket`` (Thanks to Rosuav and cvrebert)
+ * ``collapse`` (Thanks to abarnet)
+ * ``interleave`` and ``interleave_longest`` (Thanks to abarnet)
+ * ``side_effect`` (Thanks to nvie)
+ * ``sliced`` (Thanks to j4mie and coady)
+ * ``split_before`` and ``split_after`` (Thanks to astronouth7303)
+ * ``spy`` (Thanks to themiurgo and mathieulongtin)
+* Improvements to existing itertools:
+ * ``chunked`` is now simpler and more friendly to garbage collection.
+ (Contributed by coady, with thanks to piskvorky)
+ * ``collate`` now delegates to ``heapq.merge`` when possible.
+ (Thanks to kmike and julianpistorius)
+ * ``peekable``-wrapped iterables are now indexable and sliceable.
+ Iterating through ``peekable``-wrapped iterables is also faster.
+ * ``one`` and ``unique_to_each`` have been simplified.
+ (Thanks to coady)
+
+
+2.3
+-----
+
+* Added ``one`` from ``jaraco.util.itertools``. (Thanks, jaraco!)
+* Added ``distinct_permutations`` and ``unique_to_each``. (Contributed by
+ bbayles)
+* Added ``windowed``. (Contributed by bbayles, with thanks to buchanae,
+ jaraco, and abarnert)
+* Simplified the implementation of ``chunked``. (Thanks, nvie!)
+* Python 3.5 is now supported. Python 2.6 is no longer supported.
+* Python 3 is now supported directly; there is no 2to3 step.
+
+2.2
+-----
+
+* Added ``iterate`` and ``with_iter``. (Thanks, abarnert!)
+
+2.1
+-----
+
+* Added (tested!) implementations of the recipes from the itertools
+ documentation. (Thanks, Chris Lonnen!)
+* Added ``ilen``. (Thanks for the inspiration, Matt Basta!)
+
+2.0
+-----
+
+* ``chunked`` now returns lists rather than tuples. After all, they're
+ homogeneous. This slightly backward-incompatible change is the reason for
+ the major version bump.
+* Added ``@consumer``.
+* Improved test machinery.
+
+1.1
+-----
+
+* Added ``first`` function.
+* Added Python 3 support.
+* Added a default arg to ``peekable.peek()``.
+* Noted how to easily test whether a peekable iterator is exhausted.
+* Rewrote documentation.
+
+1.0
+-----
+
+* Initial release, with ``collate``, ``peekable``, and ``chunked``. Could
+ really use better docs.
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/RECORD b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..8ae430e84f94d489fa0d29c6b8ca3c3da6fd647e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/RECORD
@@ -0,0 +1,18 @@
+more_itertools-5.0.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+more_itertools-5.0.0.dist-info/LICENSE,sha256=CfHIyelBrz5YTVlkHqm4fYPAyw_QB-te85Gn4mQ8GkY,1053
+more_itertools-5.0.0.dist-info/METADATA,sha256=Dz79ot_c24uV1gLioytYqcOKVQnLEZNshn58n6Cdw7c,33824
+more_itertools-5.0.0.dist-info/RECORD,,
+more_itertools-5.0.0.dist-info/WHEEL,sha256=ZvfnntGaZglpRLAKVkx18HrxfMwCXrA0b-ARJVnnMrw,92
+more_itertools-5.0.0.dist-info/top_level.txt,sha256=fAuqRXu9LPhxdB9ujJowcFOu1rZ8wzSpOW9_jlKis6M,15
+more_itertools/__init__.py,sha256=S-n6S9N3UplqU3p-7AV-1Znl6yJwuXsJtqrlEq9tOUw,87
+more_itertools/__init__.pyc,,
+more_itertools/more.py,sha256=0jauZmIafxcPyqi2nE9Es5SWxuOtQgGi81ZxDdAkxJc,74126
+more_itertools/more.pyc,,
+more_itertools/recipes.py,sha256=fRtikenQ80JePTOwaagYJUdOsOOKMKIqv62b0-gDM4c,15474
+more_itertools/recipes.pyc,,
+more_itertools/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+more_itertools/tests/__init__.pyc,,
+more_itertools/tests/test_more.py,sha256=Me7hn-TtltxRSPc3kyd3bRTS3sUV4yABk5fGUUlwWTQ,79615
+more_itertools/tests/test_more.pyc,,
+more_itertools/tests/test_recipes.py,sha256=0BR8K3DCvutX0uJ40EQx8E53mUnhfXnGG4OnN_6Z2Qo,19830
+more_itertools/tests/test_recipes.pyc,,
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/WHEEL b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..e1b1f7bd13d41c54e9a0f6fd3caace0b14c46d13
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.32.3)
+Root-Is-Purelib: true
+Tag: py2-none-any
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/top_level.txt b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a5035befb3b2eff88c51a6d4d62142ecb10aba8b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools-5.0.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+more_itertools
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bba462c3dbfc1ee5fdc9cec4d277e4c787f62d96
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools/__init__.py
@@ -0,0 +1,2 @@
+from more_itertools.more import * # noqa
+from more_itertools.recipes import * # noqa
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools/more.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools/more.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd32a26130423f1cdc64f9da787d514f3ca8ce6d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools/more.py
@@ -0,0 +1,2333 @@
+from __future__ import print_function
+
+from collections import Counter, defaultdict, deque
+from functools import partial, wraps
+from heapq import merge
+from itertools import (
+ chain,
+ compress,
+ count,
+ cycle,
+ dropwhile,
+ groupby,
+ islice,
+ repeat,
+ starmap,
+ takewhile,
+ tee
+)
+from operator import itemgetter, lt, gt, sub
+from sys import maxsize, version_info
+try:
+ from collections.abc import Sequence
+except ImportError:
+ from collections import Sequence
+
+from six import binary_type, string_types, text_type
+from six.moves import filter, map, range, zip, zip_longest
+
+from .recipes import consume, flatten, take
+
+__all__ = [
+ 'adjacent',
+ 'always_iterable',
+ 'always_reversible',
+ 'bucket',
+ 'chunked',
+ 'circular_shifts',
+ 'collapse',
+ 'collate',
+ 'consecutive_groups',
+ 'consumer',
+ 'count_cycle',
+ 'difference',
+ 'distinct_permutations',
+ 'distribute',
+ 'divide',
+ 'exactly_n',
+ 'first',
+ 'groupby_transform',
+ 'ilen',
+ 'interleave_longest',
+ 'interleave',
+ 'intersperse',
+ 'islice_extended',
+ 'iterate',
+ 'last',
+ 'locate',
+ 'lstrip',
+ 'make_decorator',
+ 'map_reduce',
+ 'numeric_range',
+ 'one',
+ 'padded',
+ 'peekable',
+ 'replace',
+ 'rlocate',
+ 'rstrip',
+ 'run_length',
+ 'seekable',
+ 'SequenceView',
+ 'side_effect',
+ 'sliced',
+ 'sort_together',
+ 'split_at',
+ 'split_after',
+ 'split_before',
+ 'split_into',
+ 'spy',
+ 'stagger',
+ 'strip',
+ 'substrings',
+ 'unique_to_each',
+ 'unzip',
+ 'windowed',
+ 'with_iter',
+ 'zip_offset',
+]
+
+_marker = object()
+
+
+def chunked(iterable, n):
+ """Break *iterable* into lists of length *n*:
+
+ >>> list(chunked([1, 2, 3, 4, 5, 6], 3))
+ [[1, 2, 3], [4, 5, 6]]
+
+ If the length of *iterable* is not evenly divisible by *n*, the last
+ returned list will be shorter:
+
+ >>> list(chunked([1, 2, 3, 4, 5, 6, 7, 8], 3))
+ [[1, 2, 3], [4, 5, 6], [7, 8]]
+
+ To use a fill-in value instead, see the :func:`grouper` recipe.
+
+ :func:`chunked` is useful for splitting up a computation on a large number
+ of keys into batches, to be pickled and sent off to worker processes. One
+ example is operations on rows in MySQL, which does not implement
+ server-side cursors properly and would otherwise load the entire dataset
+ into RAM on the client.
+
+ """
+ return iter(partial(take, n, iter(iterable)), [])
+
+
+def first(iterable, default=_marker):
+ """Return the first item of *iterable*, or *default* if *iterable* is
+ empty.
+
+ >>> first([0, 1, 2, 3])
+ 0
+ >>> first([], 'some default')
+ 'some default'
+
+ If *default* is not provided and there are no items in the iterable,
+ raise ``ValueError``.
+
+ :func:`first` is useful when you have a generator of expensive-to-retrieve
+ values and want any arbitrary one. It is marginally shorter than
+ ``next(iter(iterable), default)``.
+
+ """
+ try:
+ return next(iter(iterable))
+ except StopIteration:
+ # I'm on the edge about raising ValueError instead of StopIteration. At
+ # the moment, ValueError wins, because the caller could conceivably
+ # want to do something different with flow control when I raise the
+ # exception, and it's weird to explicitly catch StopIteration.
+ if default is _marker:
+ raise ValueError('first() was called on an empty iterable, and no '
+ 'default value was provided.')
+ return default
+
+
+def last(iterable, default=_marker):
+ """Return the last item of *iterable*, or *default* if *iterable* is
+ empty.
+
+ >>> last([0, 1, 2, 3])
+ 3
+ >>> last([], 'some default')
+ 'some default'
+
+ If *default* is not provided and there are no items in the iterable,
+ raise ``ValueError``.
+ """
+ try:
+ try:
+ # Try to access the last item directly
+ return iterable[-1]
+ except (TypeError, AttributeError, KeyError):
+ # If not slice-able, iterate entirely using length-1 deque
+ return deque(iterable, maxlen=1)[0]
+ except IndexError: # If the iterable was empty
+ if default is _marker:
+ raise ValueError('last() was called on an empty iterable, and no '
+ 'default value was provided.')
+ return default
+
+
+class peekable(object):
+ """Wrap an iterator to allow lookahead and prepending elements.
+
+ Call :meth:`peek` on the result to get the value that will be returned
+ by :func:`next`. This won't advance the iterator:
+
+ >>> p = peekable(['a', 'b'])
+ >>> p.peek()
+ 'a'
+ >>> next(p)
+ 'a'
+
+ Pass :meth:`peek` a default value to return that instead of raising
+ ``StopIteration`` when the iterator is exhausted.
+
+ >>> p = peekable([])
+ >>> p.peek('hi')
+ 'hi'
+
+ peekables also offer a :meth:`prepend` method, which "inserts" items
+ at the head of the iterable:
+
+ >>> p = peekable([1, 2, 3])
+ >>> p.prepend(10, 11, 12)
+ >>> next(p)
+ 10
+ >>> p.peek()
+ 11
+ >>> list(p)
+ [11, 12, 1, 2, 3]
+
+ peekables can be indexed. Index 0 is the item that will be returned by
+ :func:`next`, index 1 is the item after that, and so on:
+ The values up to the given index will be cached.
+
+ >>> p = peekable(['a', 'b', 'c', 'd'])
+ >>> p[0]
+ 'a'
+ >>> p[1]
+ 'b'
+ >>> next(p)
+ 'a'
+
+ Negative indexes are supported, but be aware that they will cache the
+ remaining items in the source iterator, which may require significant
+ storage.
+
+ To check whether a peekable is exhausted, check its truth value:
+
+ >>> p = peekable(['a', 'b'])
+ >>> if p: # peekable has items
+ ... list(p)
+ ['a', 'b']
+ >>> if not p: # peekable is exhaused
+ ... list(p)
+ []
+
+ """
+ def __init__(self, iterable):
+ self._it = iter(iterable)
+ self._cache = deque()
+
+ def __iter__(self):
+ return self
+
+ def __bool__(self):
+ try:
+ self.peek()
+ except StopIteration:
+ return False
+ return True
+
+ def __nonzero__(self):
+ # For Python 2 compatibility
+ return self.__bool__()
+
+ def peek(self, default=_marker):
+ """Return the item that will be next returned from ``next()``.
+
+ Return ``default`` if there are no items left. If ``default`` is not
+ provided, raise ``StopIteration``.
+
+ """
+ if not self._cache:
+ try:
+ self._cache.append(next(self._it))
+ except StopIteration:
+ if default is _marker:
+ raise
+ return default
+ return self._cache[0]
+
+ def prepend(self, *items):
+ """Stack up items to be the next ones returned from ``next()`` or
+ ``self.peek()``. The items will be returned in
+ first in, first out order::
+
+ >>> p = peekable([1, 2, 3])
+ >>> p.prepend(10, 11, 12)
+ >>> next(p)
+ 10
+ >>> list(p)
+ [11, 12, 1, 2, 3]
+
+ It is possible, by prepending items, to "resurrect" a peekable that
+ previously raised ``StopIteration``.
+
+ >>> p = peekable([])
+ >>> next(p)
+ Traceback (most recent call last):
+ ...
+ StopIteration
+ >>> p.prepend(1)
+ >>> next(p)
+ 1
+ >>> next(p)
+ Traceback (most recent call last):
+ ...
+ StopIteration
+
+ """
+ self._cache.extendleft(reversed(items))
+
+ def __next__(self):
+ if self._cache:
+ return self._cache.popleft()
+
+ return next(self._it)
+
+ next = __next__ # For Python 2 compatibility
+
+ def _get_slice(self, index):
+ # Normalize the slice's arguments
+ step = 1 if (index.step is None) else index.step
+ if step > 0:
+ start = 0 if (index.start is None) else index.start
+ stop = maxsize if (index.stop is None) else index.stop
+ elif step < 0:
+ start = -1 if (index.start is None) else index.start
+ stop = (-maxsize - 1) if (index.stop is None) else index.stop
+ else:
+ raise ValueError('slice step cannot be zero')
+
+ # If either the start or stop index is negative, we'll need to cache
+ # the rest of the iterable in order to slice from the right side.
+ if (start < 0) or (stop < 0):
+ self._cache.extend(self._it)
+ # Otherwise we'll need to find the rightmost index and cache to that
+ # point.
+ else:
+ n = min(max(start, stop) + 1, maxsize)
+ cache_len = len(self._cache)
+ if n >= cache_len:
+ self._cache.extend(islice(self._it, n - cache_len))
+
+ return list(self._cache)[index]
+
+ def __getitem__(self, index):
+ if isinstance(index, slice):
+ return self._get_slice(index)
+
+ cache_len = len(self._cache)
+ if index < 0:
+ self._cache.extend(self._it)
+ elif index >= cache_len:
+ self._cache.extend(islice(self._it, index + 1 - cache_len))
+
+ return self._cache[index]
+
+
+def _collate(*iterables, **kwargs):
+ """Helper for ``collate()``, called when the user is using the ``reverse``
+ or ``key`` keyword arguments on Python versions below 3.5.
+
+ """
+ key = kwargs.pop('key', lambda a: a)
+ reverse = kwargs.pop('reverse', False)
+
+ min_or_max = partial(max if reverse else min, key=itemgetter(0))
+ peekables = [peekable(it) for it in iterables]
+ peekables = [p for p in peekables if p] # Kill empties.
+ while peekables:
+ _, p = min_or_max((key(p.peek()), p) for p in peekables)
+ yield next(p)
+ peekables = [x for x in peekables if x]
+
+
+def collate(*iterables, **kwargs):
+ """Return a sorted merge of the items from each of several already-sorted
+ *iterables*.
+
+ >>> list(collate('ACDZ', 'AZ', 'JKL'))
+ ['A', 'A', 'C', 'D', 'J', 'K', 'L', 'Z', 'Z']
+
+ Works lazily, keeping only the next value from each iterable in memory. Use
+ :func:`collate` to, for example, perform a n-way mergesort of items that
+ don't fit in memory.
+
+ If a *key* function is specified, the iterables will be sorted according
+ to its result:
+
+ >>> key = lambda s: int(s) # Sort by numeric value, not by string
+ >>> list(collate(['1', '10'], ['2', '11'], key=key))
+ ['1', '2', '10', '11']
+
+
+ If the *iterables* are sorted in descending order, set *reverse* to
+ ``True``:
+
+ >>> list(collate([5, 3, 1], [4, 2, 0], reverse=True))
+ [5, 4, 3, 2, 1, 0]
+
+ If the elements of the passed-in iterables are out of order, you might get
+ unexpected results.
+
+ On Python 2.7, this function delegates to :func:`heapq.merge` if neither
+ of the keyword arguments are specified. On Python 3.5+, this function
+ is an alias for :func:`heapq.merge`.
+
+ """
+ if not kwargs:
+ return merge(*iterables)
+
+ return _collate(*iterables, **kwargs)
+
+
+# If using Python version 3.5 or greater, heapq.merge() will be faster than
+# collate - use that instead.
+if version_info >= (3, 5, 0):
+ _collate_docstring = collate.__doc__
+ collate = partial(merge)
+ collate.__doc__ = _collate_docstring
+
+
+def consumer(func):
+ """Decorator that automatically advances a PEP-342-style "reverse iterator"
+ to its first yield point so you don't have to call ``next()`` on it
+ manually.
+
+ >>> @consumer
+ ... def tally():
+ ... i = 0
+ ... while True:
+ ... print('Thing number %s is %s.' % (i, (yield)))
+ ... i += 1
+ ...
+ >>> t = tally()
+ >>> t.send('red')
+ Thing number 0 is red.
+ >>> t.send('fish')
+ Thing number 1 is fish.
+
+ Without the decorator, you would have to call ``next(t)`` before
+ ``t.send()`` could be used.
+
+ """
+ @wraps(func)
+ def wrapper(*args, **kwargs):
+ gen = func(*args, **kwargs)
+ next(gen)
+ return gen
+ return wrapper
+
+
+def ilen(iterable):
+ """Return the number of items in *iterable*.
+
+ >>> ilen(x for x in range(1000000) if x % 3 == 0)
+ 333334
+
+ This consumes the iterable, so handle with care.
+
+ """
+ # This approach was selected because benchmarks showed it's likely the
+ # fastest of the known implementations at the time of writing.
+ # See GitHub tracker: #236, #230.
+ counter = count()
+ deque(zip(iterable, counter), maxlen=0)
+ return next(counter)
+
+
+def iterate(func, start):
+ """Return ``start``, ``func(start)``, ``func(func(start))``, ...
+
+ >>> from itertools import islice
+ >>> list(islice(iterate(lambda x: 2*x, 1), 10))
+ [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
+
+ """
+ while True:
+ yield start
+ start = func(start)
+
+
+def with_iter(context_manager):
+ """Wrap an iterable in a ``with`` statement, so it closes once exhausted.
+
+ For example, this will close the file when the iterator is exhausted::
+
+ upper_lines = (line.upper() for line in with_iter(open('foo')))
+
+ Any context manager which returns an iterable is a candidate for
+ ``with_iter``.
+
+ """
+ with context_manager as iterable:
+ for item in iterable:
+ yield item
+
+
+def one(iterable, too_short=None, too_long=None):
+ """Return the first item from *iterable*, which is expected to contain only
+ that item. Raise an exception if *iterable* is empty or has more than one
+ item.
+
+ :func:`one` is useful for ensuring that an iterable contains only one item.
+ For example, it can be used to retrieve the result of a database query
+ that is expected to return a single row.
+
+ If *iterable* is empty, ``ValueError`` will be raised. You may specify a
+ different exception with the *too_short* keyword:
+
+ >>> it = []
+ >>> one(it) # doctest: +IGNORE_EXCEPTION_DETAIL
+ Traceback (most recent call last):
+ ...
+ ValueError: too many items in iterable (expected 1)'
+ >>> too_short = IndexError('too few items')
+ >>> one(it, too_short=too_short) # doctest: +IGNORE_EXCEPTION_DETAIL
+ Traceback (most recent call last):
+ ...
+ IndexError: too few items
+
+ Similarly, if *iterable* contains more than one item, ``ValueError`` will
+ be raised. You may specify a different exception with the *too_long*
+ keyword:
+
+ >>> it = ['too', 'many']
+ >>> one(it) # doctest: +IGNORE_EXCEPTION_DETAIL
+ Traceback (most recent call last):
+ ...
+ ValueError: too many items in iterable (expected 1)'
+ >>> too_long = RuntimeError
+ >>> one(it, too_long=too_long) # doctest: +IGNORE_EXCEPTION_DETAIL
+ Traceback (most recent call last):
+ ...
+ RuntimeError
+
+ Note that :func:`one` attempts to advance *iterable* twice to ensure there
+ is only one item. If there is more than one, both items will be discarded.
+ See :func:`spy` or :func:`peekable` to check iterable contents less
+ destructively.
+
+ """
+ it = iter(iterable)
+
+ try:
+ value = next(it)
+ except StopIteration:
+ raise too_short or ValueError('too few items in iterable (expected 1)')
+
+ try:
+ next(it)
+ except StopIteration:
+ pass
+ else:
+ raise too_long or ValueError('too many items in iterable (expected 1)')
+
+ return value
+
+
+def distinct_permutations(iterable):
+ """Yield successive distinct permutations of the elements in *iterable*.
+
+ >>> sorted(distinct_permutations([1, 0, 1]))
+ [(0, 1, 1), (1, 0, 1), (1, 1, 0)]
+
+ Equivalent to ``set(permutations(iterable))``, except duplicates are not
+ generated and thrown away. For larger input sequences this is much more
+ efficient.
+
+ Duplicate permutations arise when there are duplicated elements in the
+ input iterable. The number of items returned is
+ `n! / (x_1! * x_2! * ... * x_n!)`, where `n` is the total number of
+ items input, and each `x_i` is the count of a distinct item in the input
+ sequence.
+
+ """
+ def perm_unique_helper(item_counts, perm, i):
+ """Internal helper function
+
+ :arg item_counts: Stores the unique items in ``iterable`` and how many
+ times they are repeated
+ :arg perm: The permutation that is being built for output
+ :arg i: The index of the permutation being modified
+
+ The output permutations are built up recursively; the distinct items
+ are placed until their repetitions are exhausted.
+ """
+ if i < 0:
+ yield tuple(perm)
+ else:
+ for item in item_counts:
+ if item_counts[item] <= 0:
+ continue
+ perm[i] = item
+ item_counts[item] -= 1
+ for x in perm_unique_helper(item_counts, perm, i - 1):
+ yield x
+ item_counts[item] += 1
+
+ item_counts = Counter(iterable)
+ length = sum(item_counts.values())
+
+ return perm_unique_helper(item_counts, [None] * length, length - 1)
+
+
+def intersperse(e, iterable, n=1):
+ """Intersperse filler element *e* among the items in *iterable*, leaving
+ *n* items between each filler element.
+
+ >>> list(intersperse('!', [1, 2, 3, 4, 5]))
+ [1, '!', 2, '!', 3, '!', 4, '!', 5]
+
+ >>> list(intersperse(None, [1, 2, 3, 4, 5], n=2))
+ [1, 2, None, 3, 4, None, 5]
+
+ """
+ if n == 0:
+ raise ValueError('n must be > 0')
+ elif n == 1:
+ # interleave(repeat(e), iterable) -> e, x_0, e, e, x_1, e, x_2...
+ # islice(..., 1, None) -> x_0, e, e, x_1, e, x_2...
+ return islice(interleave(repeat(e), iterable), 1, None)
+ else:
+ # interleave(filler, chunks) -> [e], [x_0, x_1], [e], [x_2, x_3]...
+ # islice(..., 1, None) -> [x_0, x_1], [e], [x_2, x_3]...
+ # flatten(...) -> x_0, x_1, e, x_2, x_3...
+ filler = repeat([e])
+ chunks = chunked(iterable, n)
+ return flatten(islice(interleave(filler, chunks), 1, None))
+
+
+def unique_to_each(*iterables):
+ """Return the elements from each of the input iterables that aren't in the
+ other input iterables.
+
+ For example, suppose you have a set of packages, each with a set of
+ dependencies::
+
+ {'pkg_1': {'A', 'B'}, 'pkg_2': {'B', 'C'}, 'pkg_3': {'B', 'D'}}
+
+ If you remove one package, which dependencies can also be removed?
+
+ If ``pkg_1`` is removed, then ``A`` is no longer necessary - it is not
+ associated with ``pkg_2`` or ``pkg_3``. Similarly, ``C`` is only needed for
+ ``pkg_2``, and ``D`` is only needed for ``pkg_3``::
+
+ >>> unique_to_each({'A', 'B'}, {'B', 'C'}, {'B', 'D'})
+ [['A'], ['C'], ['D']]
+
+ If there are duplicates in one input iterable that aren't in the others
+ they will be duplicated in the output. Input order is preserved::
+
+ >>> unique_to_each("mississippi", "missouri")
+ [['p', 'p'], ['o', 'u', 'r']]
+
+ It is assumed that the elements of each iterable are hashable.
+
+ """
+ pool = [list(it) for it in iterables]
+ counts = Counter(chain.from_iterable(map(set, pool)))
+ uniques = {element for element in counts if counts[element] == 1}
+ return [list(filter(uniques.__contains__, it)) for it in pool]
+
+
+def windowed(seq, n, fillvalue=None, step=1):
+ """Return a sliding window of width *n* over the given iterable.
+
+ >>> all_windows = windowed([1, 2, 3, 4, 5], 3)
+ >>> list(all_windows)
+ [(1, 2, 3), (2, 3, 4), (3, 4, 5)]
+
+ When the window is larger than the iterable, *fillvalue* is used in place
+ of missing values::
+
+ >>> list(windowed([1, 2, 3], 4))
+ [(1, 2, 3, None)]
+
+ Each window will advance in increments of *step*:
+
+ >>> list(windowed([1, 2, 3, 4, 5, 6], 3, fillvalue='!', step=2))
+ [(1, 2, 3), (3, 4, 5), (5, 6, '!')]
+
+ """
+ if n < 0:
+ raise ValueError('n must be >= 0')
+ if n == 0:
+ yield tuple()
+ return
+ if step < 1:
+ raise ValueError('step must be >= 1')
+
+ it = iter(seq)
+ window = deque([], n)
+ append = window.append
+
+ # Initial deque fill
+ for _ in range(n):
+ append(next(it, fillvalue))
+ yield tuple(window)
+
+ # Appending new items to the right causes old items to fall off the left
+ i = 0
+ for item in it:
+ append(item)
+ i = (i + 1) % step
+ if i % step == 0:
+ yield tuple(window)
+
+ # If there are items from the iterable in the window, pad with the given
+ # value and emit them.
+ if (i % step) and (step - i < n):
+ for _ in range(step - i):
+ append(fillvalue)
+ yield tuple(window)
+
+
+def substrings(iterable, join_func=None):
+ """Yield all of the substrings of *iterable*.
+
+ >>> [''.join(s) for s in substrings('more')]
+ ['m', 'o', 'r', 'e', 'mo', 'or', 're', 'mor', 'ore', 'more']
+
+ Note that non-string iterables can also be subdivided.
+
+ >>> list(substrings([0, 1, 2]))
+ [(0,), (1,), (2,), (0, 1), (1, 2), (0, 1, 2)]
+
+ """
+ # The length-1 substrings
+ seq = []
+ for item in iter(iterable):
+ seq.append(item)
+ yield (item,)
+ seq = tuple(seq)
+ item_count = len(seq)
+
+ # And the rest
+ for n in range(2, item_count + 1):
+ for i in range(item_count - n + 1):
+ yield seq[i:i + n]
+
+
+class bucket(object):
+ """Wrap *iterable* and return an object that buckets it iterable into
+ child iterables based on a *key* function.
+
+ >>> iterable = ['a1', 'b1', 'c1', 'a2', 'b2', 'c2', 'b3']
+ >>> s = bucket(iterable, key=lambda x: x[0])
+ >>> a_iterable = s['a']
+ >>> next(a_iterable)
+ 'a1'
+ >>> next(a_iterable)
+ 'a2'
+ >>> list(s['b'])
+ ['b1', 'b2', 'b3']
+
+ The original iterable will be advanced and its items will be cached until
+ they are used by the child iterables. This may require significant storage.
+
+ By default, attempting to select a bucket to which no items belong will
+ exhaust the iterable and cache all values.
+ If you specify a *validator* function, selected buckets will instead be
+ checked against it.
+
+ >>> from itertools import count
+ >>> it = count(1, 2) # Infinite sequence of odd numbers
+ >>> key = lambda x: x % 10 # Bucket by last digit
+ >>> validator = lambda x: x in {1, 3, 5, 7, 9} # Odd digits only
+ >>> s = bucket(it, key=key, validator=validator)
+ >>> 2 in s
+ False
+ >>> list(s[2])
+ []
+
+ """
+ def __init__(self, iterable, key, validator=None):
+ self._it = iter(iterable)
+ self._key = key
+ self._cache = defaultdict(deque)
+ self._validator = validator or (lambda x: True)
+
+ def __contains__(self, value):
+ if not self._validator(value):
+ return False
+
+ try:
+ item = next(self[value])
+ except StopIteration:
+ return False
+ else:
+ self._cache[value].appendleft(item)
+
+ return True
+
+ def _get_values(self, value):
+ """
+ Helper to yield items from the parent iterator that match *value*.
+ Items that don't match are stored in the local cache as they
+ are encountered.
+ """
+ while True:
+ # If we've cached some items that match the target value, emit
+ # the first one and evict it from the cache.
+ if self._cache[value]:
+ yield self._cache[value].popleft()
+ # Otherwise we need to advance the parent iterator to search for
+ # a matching item, caching the rest.
+ else:
+ while True:
+ try:
+ item = next(self._it)
+ except StopIteration:
+ return
+ item_value = self._key(item)
+ if item_value == value:
+ yield item
+ break
+ elif self._validator(item_value):
+ self._cache[item_value].append(item)
+
+ def __getitem__(self, value):
+ if not self._validator(value):
+ return iter(())
+
+ return self._get_values(value)
+
+
+def spy(iterable, n=1):
+ """Return a 2-tuple with a list containing the first *n* elements of
+ *iterable*, and an iterator with the same items as *iterable*.
+ This allows you to "look ahead" at the items in the iterable without
+ advancing it.
+
+ There is one item in the list by default:
+
+ >>> iterable = 'abcdefg'
+ >>> head, iterable = spy(iterable)
+ >>> head
+ ['a']
+ >>> list(iterable)
+ ['a', 'b', 'c', 'd', 'e', 'f', 'g']
+
+ You may use unpacking to retrieve items instead of lists:
+
+ >>> (head,), iterable = spy('abcdefg')
+ >>> head
+ 'a'
+ >>> (first, second), iterable = spy('abcdefg', 2)
+ >>> first
+ 'a'
+ >>> second
+ 'b'
+
+ The number of items requested can be larger than the number of items in
+ the iterable:
+
+ >>> iterable = [1, 2, 3, 4, 5]
+ >>> head, iterable = spy(iterable, 10)
+ >>> head
+ [1, 2, 3, 4, 5]
+ >>> list(iterable)
+ [1, 2, 3, 4, 5]
+
+ """
+ it = iter(iterable)
+ head = take(n, it)
+
+ return head, chain(head, it)
+
+
+def interleave(*iterables):
+ """Return a new iterable yielding from each iterable in turn,
+ until the shortest is exhausted.
+
+ >>> list(interleave([1, 2, 3], [4, 5], [6, 7, 8]))
+ [1, 4, 6, 2, 5, 7]
+
+ For a version that doesn't terminate after the shortest iterable is
+ exhausted, see :func:`interleave_longest`.
+
+ """
+ return chain.from_iterable(zip(*iterables))
+
+
+def interleave_longest(*iterables):
+ """Return a new iterable yielding from each iterable in turn,
+ skipping any that are exhausted.
+
+ >>> list(interleave_longest([1, 2, 3], [4, 5], [6, 7, 8]))
+ [1, 4, 6, 2, 5, 7, 3, 8]
+
+ This function produces the same output as :func:`roundrobin`, but may
+ perform better for some inputs (in particular when the number of iterables
+ is large).
+
+ """
+ i = chain.from_iterable(zip_longest(*iterables, fillvalue=_marker))
+ return (x for x in i if x is not _marker)
+
+
+def collapse(iterable, base_type=None, levels=None):
+ """Flatten an iterable with multiple levels of nesting (e.g., a list of
+ lists of tuples) into non-iterable types.
+
+ >>> iterable = [(1, 2), ([3, 4], [[5], [6]])]
+ >>> list(collapse(iterable))
+ [1, 2, 3, 4, 5, 6]
+
+ String types are not considered iterable and will not be collapsed.
+ To avoid collapsing other types, specify *base_type*:
+
+ >>> iterable = ['ab', ('cd', 'ef'), ['gh', 'ij']]
+ >>> list(collapse(iterable, base_type=tuple))
+ ['ab', ('cd', 'ef'), 'gh', 'ij']
+
+ Specify *levels* to stop flattening after a certain level:
+
+ >>> iterable = [('a', ['b']), ('c', ['d'])]
+ >>> list(collapse(iterable)) # Fully flattened
+ ['a', 'b', 'c', 'd']
+ >>> list(collapse(iterable, levels=1)) # Only one level flattened
+ ['a', ['b'], 'c', ['d']]
+
+ """
+ def walk(node, level):
+ if (
+ ((levels is not None) and (level > levels)) or
+ isinstance(node, string_types) or
+ ((base_type is not None) and isinstance(node, base_type))
+ ):
+ yield node
+ return
+
+ try:
+ tree = iter(node)
+ except TypeError:
+ yield node
+ return
+ else:
+ for child in tree:
+ for x in walk(child, level + 1):
+ yield x
+
+ for x in walk(iterable, 0):
+ yield x
+
+
+def side_effect(func, iterable, chunk_size=None, before=None, after=None):
+ """Invoke *func* on each item in *iterable* (or on each *chunk_size* group
+ of items) before yielding the item.
+
+ `func` must be a function that takes a single argument. Its return value
+ will be discarded.
+
+ *before* and *after* are optional functions that take no arguments. They
+ will be executed before iteration starts and after it ends, respectively.
+
+ `side_effect` can be used for logging, updating progress bars, or anything
+ that is not functionally "pure."
+
+ Emitting a status message:
+
+ >>> from more_itertools import consume
+ >>> func = lambda item: print('Received {}'.format(item))
+ >>> consume(side_effect(func, range(2)))
+ Received 0
+ Received 1
+
+ Operating on chunks of items:
+
+ >>> pair_sums = []
+ >>> func = lambda chunk: pair_sums.append(sum(chunk))
+ >>> list(side_effect(func, [0, 1, 2, 3, 4, 5], 2))
+ [0, 1, 2, 3, 4, 5]
+ >>> list(pair_sums)
+ [1, 5, 9]
+
+ Writing to a file-like object:
+
+ >>> from io import StringIO
+ >>> from more_itertools import consume
+ >>> f = StringIO()
+ >>> func = lambda x: print(x, file=f)
+ >>> before = lambda: print(u'HEADER', file=f)
+ >>> after = f.close
+ >>> it = [u'a', u'b', u'c']
+ >>> consume(side_effect(func, it, before=before, after=after))
+ >>> f.closed
+ True
+
+ """
+ try:
+ if before is not None:
+ before()
+
+ if chunk_size is None:
+ for item in iterable:
+ func(item)
+ yield item
+ else:
+ for chunk in chunked(iterable, chunk_size):
+ func(chunk)
+ for item in chunk:
+ yield item
+ finally:
+ if after is not None:
+ after()
+
+
+def sliced(seq, n):
+ """Yield slices of length *n* from the sequence *seq*.
+
+ >>> list(sliced((1, 2, 3, 4, 5, 6), 3))
+ [(1, 2, 3), (4, 5, 6)]
+
+ If the length of the sequence is not divisible by the requested slice
+ length, the last slice will be shorter.
+
+ >>> list(sliced((1, 2, 3, 4, 5, 6, 7, 8), 3))
+ [(1, 2, 3), (4, 5, 6), (7, 8)]
+
+ This function will only work for iterables that support slicing.
+ For non-sliceable iterables, see :func:`chunked`.
+
+ """
+ return takewhile(bool, (seq[i: i + n] for i in count(0, n)))
+
+
+def split_at(iterable, pred):
+ """Yield lists of items from *iterable*, where each list is delimited by
+ an item where callable *pred* returns ``True``. The lists do not include
+ the delimiting items.
+
+ >>> list(split_at('abcdcba', lambda x: x == 'b'))
+ [['a'], ['c', 'd', 'c'], ['a']]
+
+ >>> list(split_at(range(10), lambda n: n % 2 == 1))
+ [[0], [2], [4], [6], [8], []]
+ """
+ buf = []
+ for item in iterable:
+ if pred(item):
+ yield buf
+ buf = []
+ else:
+ buf.append(item)
+ yield buf
+
+
+def split_before(iterable, pred):
+ """Yield lists of items from *iterable*, where each list starts with an
+ item where callable *pred* returns ``True``:
+
+ >>> list(split_before('OneTwo', lambda s: s.isupper()))
+ [['O', 'n', 'e'], ['T', 'w', 'o']]
+
+ >>> list(split_before(range(10), lambda n: n % 3 == 0))
+ [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]
+
+ """
+ buf = []
+ for item in iterable:
+ if pred(item) and buf:
+ yield buf
+ buf = []
+ buf.append(item)
+ yield buf
+
+
+def split_after(iterable, pred):
+ """Yield lists of items from *iterable*, where each list ends with an
+ item where callable *pred* returns ``True``:
+
+ >>> list(split_after('one1two2', lambda s: s.isdigit()))
+ [['o', 'n', 'e', '1'], ['t', 'w', 'o', '2']]
+
+ >>> list(split_after(range(10), lambda n: n % 3 == 0))
+ [[0], [1, 2, 3], [4, 5, 6], [7, 8, 9]]
+
+ """
+ buf = []
+ for item in iterable:
+ buf.append(item)
+ if pred(item) and buf:
+ yield buf
+ buf = []
+ if buf:
+ yield buf
+
+
+def split_into(iterable, sizes):
+ """Yield a list of sequential items from *iterable* of length 'n' for each
+ integer 'n' in *sizes*.
+
+ >>> list(split_into([1,2,3,4,5,6], [1,2,3]))
+ [[1], [2, 3], [4, 5, 6]]
+
+ If the sum of *sizes* is smaller than the length of *iterable*, then the
+ remaining items of *iterable* will not be returned.
+
+ >>> list(split_into([1,2,3,4,5,6], [2,3]))
+ [[1, 2], [3, 4, 5]]
+
+ If the sum of *sizes* is larger than the length of *iterable*, fewer items
+ will be returned in the iteration that overruns *iterable* and further
+ lists will be empty:
+
+ >>> list(split_into([1,2,3,4], [1,2,3,4]))
+ [[1], [2, 3], [4], []]
+
+ When a ``None`` object is encountered in *sizes*, the returned list will
+ contain items up to the end of *iterable* the same way that itertools.slice
+ does:
+
+ >>> list(split_into([1,2,3,4,5,6,7,8,9,0], [2,3,None]))
+ [[1, 2], [3, 4, 5], [6, 7, 8, 9, 0]]
+
+ :func:`split_into` can be useful for grouping a series of items where the
+ sizes of the groups are not uniform. An example would be where in a row
+ from a table, multiple columns represent elements of the same feature
+ (e.g. a point represented by x,y,z) but, the format is not the same for
+ all columns.
+ """
+ # convert the iterable argument into an iterator so its contents can
+ # be consumed by islice in case it is a generator
+ it = iter(iterable)
+
+ for size in sizes:
+ if size is None:
+ yield list(it)
+ return
+ else:
+ yield list(islice(it, size))
+
+
+def padded(iterable, fillvalue=None, n=None, next_multiple=False):
+ """Yield the elements from *iterable*, followed by *fillvalue*, such that
+ at least *n* items are emitted.
+
+ >>> list(padded([1, 2, 3], '?', 5))
+ [1, 2, 3, '?', '?']
+
+ If *next_multiple* is ``True``, *fillvalue* will be emitted until the
+ number of items emitted is a multiple of *n*::
+
+ >>> list(padded([1, 2, 3, 4], n=3, next_multiple=True))
+ [1, 2, 3, 4, None, None]
+
+ If *n* is ``None``, *fillvalue* will be emitted indefinitely.
+
+ """
+ it = iter(iterable)
+ if n is None:
+ for item in chain(it, repeat(fillvalue)):
+ yield item
+ elif n < 1:
+ raise ValueError('n must be at least 1')
+ else:
+ item_count = 0
+ for item in it:
+ yield item
+ item_count += 1
+
+ remaining = (n - item_count) % n if next_multiple else n - item_count
+ for _ in range(remaining):
+ yield fillvalue
+
+
+def distribute(n, iterable):
+ """Distribute the items from *iterable* among *n* smaller iterables.
+
+ >>> group_1, group_2 = distribute(2, [1, 2, 3, 4, 5, 6])
+ >>> list(group_1)
+ [1, 3, 5]
+ >>> list(group_2)
+ [2, 4, 6]
+
+ If the length of *iterable* is not evenly divisible by *n*, then the
+ length of the returned iterables will not be identical:
+
+ >>> children = distribute(3, [1, 2, 3, 4, 5, 6, 7])
+ >>> [list(c) for c in children]
+ [[1, 4, 7], [2, 5], [3, 6]]
+
+ If the length of *iterable* is smaller than *n*, then the last returned
+ iterables will be empty:
+
+ >>> children = distribute(5, [1, 2, 3])
+ >>> [list(c) for c in children]
+ [[1], [2], [3], [], []]
+
+ This function uses :func:`itertools.tee` and may require significant
+ storage. If you need the order items in the smaller iterables to match the
+ original iterable, see :func:`divide`.
+
+ """
+ if n < 1:
+ raise ValueError('n must be at least 1')
+
+ children = tee(iterable, n)
+ return [islice(it, index, None, n) for index, it in enumerate(children)]
+
+
+def stagger(iterable, offsets=(-1, 0, 1), longest=False, fillvalue=None):
+ """Yield tuples whose elements are offset from *iterable*.
+ The amount by which the `i`-th item in each tuple is offset is given by
+ the `i`-th item in *offsets*.
+
+ >>> list(stagger([0, 1, 2, 3]))
+ [(None, 0, 1), (0, 1, 2), (1, 2, 3)]
+ >>> list(stagger(range(8), offsets=(0, 2, 4)))
+ [(0, 2, 4), (1, 3, 5), (2, 4, 6), (3, 5, 7)]
+
+ By default, the sequence will end when the final element of a tuple is the
+ last item in the iterable. To continue until the first element of a tuple
+ is the last item in the iterable, set *longest* to ``True``::
+
+ >>> list(stagger([0, 1, 2, 3], longest=True))
+ [(None, 0, 1), (0, 1, 2), (1, 2, 3), (2, 3, None), (3, None, None)]
+
+ By default, ``None`` will be used to replace offsets beyond the end of the
+ sequence. Specify *fillvalue* to use some other value.
+
+ """
+ children = tee(iterable, len(offsets))
+
+ return zip_offset(
+ *children, offsets=offsets, longest=longest, fillvalue=fillvalue
+ )
+
+
+def zip_offset(*iterables, **kwargs):
+ """``zip`` the input *iterables* together, but offset the `i`-th iterable
+ by the `i`-th item in *offsets*.
+
+ >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1)))
+ [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e')]
+
+ This can be used as a lightweight alternative to SciPy or pandas to analyze
+ data sets in which some series have a lead or lag relationship.
+
+ By default, the sequence will end when the shortest iterable is exhausted.
+ To continue until the longest iterable is exhausted, set *longest* to
+ ``True``.
+
+ >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1), longest=True))
+ [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e'), (None, 'f')]
+
+ By default, ``None`` will be used to replace offsets beyond the end of the
+ sequence. Specify *fillvalue* to use some other value.
+
+ """
+ offsets = kwargs['offsets']
+ longest = kwargs.get('longest', False)
+ fillvalue = kwargs.get('fillvalue', None)
+
+ if len(iterables) != len(offsets):
+ raise ValueError("Number of iterables and offsets didn't match")
+
+ staggered = []
+ for it, n in zip(iterables, offsets):
+ if n < 0:
+ staggered.append(chain(repeat(fillvalue, -n), it))
+ elif n > 0:
+ staggered.append(islice(it, n, None))
+ else:
+ staggered.append(it)
+
+ if longest:
+ return zip_longest(*staggered, fillvalue=fillvalue)
+
+ return zip(*staggered)
+
+
+def sort_together(iterables, key_list=(0,), reverse=False):
+ """Return the input iterables sorted together, with *key_list* as the
+ priority for sorting. All iterables are trimmed to the length of the
+ shortest one.
+
+ This can be used like the sorting function in a spreadsheet. If each
+ iterable represents a column of data, the key list determines which
+ columns are used for sorting.
+
+ By default, all iterables are sorted using the ``0``-th iterable::
+
+ >>> iterables = [(4, 3, 2, 1), ('a', 'b', 'c', 'd')]
+ >>> sort_together(iterables)
+ [(1, 2, 3, 4), ('d', 'c', 'b', 'a')]
+
+ Set a different key list to sort according to another iterable.
+ Specifying multiple keys dictates how ties are broken::
+
+ >>> iterables = [(3, 1, 2), (0, 1, 0), ('c', 'b', 'a')]
+ >>> sort_together(iterables, key_list=(1, 2))
+ [(2, 3, 1), (0, 0, 1), ('a', 'c', 'b')]
+
+ Set *reverse* to ``True`` to sort in descending order.
+
+ >>> sort_together([(1, 2, 3), ('c', 'b', 'a')], reverse=True)
+ [(3, 2, 1), ('a', 'b', 'c')]
+
+ """
+ return list(zip(*sorted(zip(*iterables),
+ key=itemgetter(*key_list),
+ reverse=reverse)))
+
+
+def unzip(iterable):
+ """The inverse of :func:`zip`, this function disaggregates the elements
+ of the zipped *iterable*.
+
+ The ``i``-th iterable contains the ``i``-th element from each element
+ of the zipped iterable. The first element is used to to determine the
+ length of the remaining elements.
+
+ >>> iterable = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
+ >>> letters, numbers = unzip(iterable)
+ >>> list(letters)
+ ['a', 'b', 'c', 'd']
+ >>> list(numbers)
+ [1, 2, 3, 4]
+
+ This is similar to using ``zip(*iterable)``, but it avoids reading
+ *iterable* into memory. Note, however, that this function uses
+ :func:`itertools.tee` and thus may require significant storage.
+
+ """
+ head, iterable = spy(iter(iterable))
+ if not head:
+ # empty iterable, e.g. zip([], [], [])
+ return ()
+ # spy returns a one-length iterable as head
+ head = head[0]
+ iterables = tee(iterable, len(head))
+
+ def itemgetter(i):
+ def getter(obj):
+ try:
+ return obj[i]
+ except IndexError:
+ # basically if we have an iterable like
+ # iter([(1, 2, 3), (4, 5), (6,)])
+ # the second unzipped iterable would fail at the third tuple
+ # since it would try to access tup[1]
+ # same with the third unzipped iterable and the second tuple
+ # to support these "improperly zipped" iterables,
+ # we create a custom itemgetter
+ # which just stops the unzipped iterables
+ # at first length mismatch
+ raise StopIteration
+ return getter
+
+ return tuple(map(itemgetter(i), it) for i, it in enumerate(iterables))
+
+
+def divide(n, iterable):
+ """Divide the elements from *iterable* into *n* parts, maintaining
+ order.
+
+ >>> group_1, group_2 = divide(2, [1, 2, 3, 4, 5, 6])
+ >>> list(group_1)
+ [1, 2, 3]
+ >>> list(group_2)
+ [4, 5, 6]
+
+ If the length of *iterable* is not evenly divisible by *n*, then the
+ length of the returned iterables will not be identical:
+
+ >>> children = divide(3, [1, 2, 3, 4, 5, 6, 7])
+ >>> [list(c) for c in children]
+ [[1, 2, 3], [4, 5], [6, 7]]
+
+ If the length of the iterable is smaller than n, then the last returned
+ iterables will be empty:
+
+ >>> children = divide(5, [1, 2, 3])
+ >>> [list(c) for c in children]
+ [[1], [2], [3], [], []]
+
+ This function will exhaust the iterable before returning and may require
+ significant storage. If order is not important, see :func:`distribute`,
+ which does not first pull the iterable into memory.
+
+ """
+ if n < 1:
+ raise ValueError('n must be at least 1')
+
+ seq = tuple(iterable)
+ q, r = divmod(len(seq), n)
+
+ ret = []
+ for i in range(n):
+ start = (i * q) + (i if i < r else r)
+ stop = ((i + 1) * q) + (i + 1 if i + 1 < r else r)
+ ret.append(iter(seq[start:stop]))
+
+ return ret
+
+
+def always_iterable(obj, base_type=(text_type, binary_type)):
+ """If *obj* is iterable, return an iterator over its items::
+
+ >>> obj = (1, 2, 3)
+ >>> list(always_iterable(obj))
+ [1, 2, 3]
+
+ If *obj* is not iterable, return a one-item iterable containing *obj*::
+
+ >>> obj = 1
+ >>> list(always_iterable(obj))
+ [1]
+
+ If *obj* is ``None``, return an empty iterable:
+
+ >>> obj = None
+ >>> list(always_iterable(None))
+ []
+
+ By default, binary and text strings are not considered iterable::
+
+ >>> obj = 'foo'
+ >>> list(always_iterable(obj))
+ ['foo']
+
+ If *base_type* is set, objects for which ``isinstance(obj, base_type)``
+ returns ``True`` won't be considered iterable.
+
+ >>> obj = {'a': 1}
+ >>> list(always_iterable(obj)) # Iterate over the dict's keys
+ ['a']
+ >>> list(always_iterable(obj, base_type=dict)) # Treat dicts as a unit
+ [{'a': 1}]
+
+ Set *base_type* to ``None`` to avoid any special handling and treat objects
+ Python considers iterable as iterable:
+
+ >>> obj = 'foo'
+ >>> list(always_iterable(obj, base_type=None))
+ ['f', 'o', 'o']
+ """
+ if obj is None:
+ return iter(())
+
+ if (base_type is not None) and isinstance(obj, base_type):
+ return iter((obj,))
+
+ try:
+ return iter(obj)
+ except TypeError:
+ return iter((obj,))
+
+
+def adjacent(predicate, iterable, distance=1):
+ """Return an iterable over `(bool, item)` tuples where the `item` is
+ drawn from *iterable* and the `bool` indicates whether
+ that item satisfies the *predicate* or is adjacent to an item that does.
+
+ For example, to find whether items are adjacent to a ``3``::
+
+ >>> list(adjacent(lambda x: x == 3, range(6)))
+ [(False, 0), (False, 1), (True, 2), (True, 3), (True, 4), (False, 5)]
+
+ Set *distance* to change what counts as adjacent. For example, to find
+ whether items are two places away from a ``3``:
+
+ >>> list(adjacent(lambda x: x == 3, range(6), distance=2))
+ [(False, 0), (True, 1), (True, 2), (True, 3), (True, 4), (True, 5)]
+
+ This is useful for contextualizing the results of a search function.
+ For example, a code comparison tool might want to identify lines that
+ have changed, but also surrounding lines to give the viewer of the diff
+ context.
+
+ The predicate function will only be called once for each item in the
+ iterable.
+
+ See also :func:`groupby_transform`, which can be used with this function
+ to group ranges of items with the same `bool` value.
+
+ """
+ # Allow distance=0 mainly for testing that it reproduces results with map()
+ if distance < 0:
+ raise ValueError('distance must be at least 0')
+
+ i1, i2 = tee(iterable)
+ padding = [False] * distance
+ selected = chain(padding, map(predicate, i1), padding)
+ adjacent_to_selected = map(any, windowed(selected, 2 * distance + 1))
+ return zip(adjacent_to_selected, i2)
+
+
+def groupby_transform(iterable, keyfunc=None, valuefunc=None):
+ """An extension of :func:`itertools.groupby` that transforms the values of
+ *iterable* after grouping them.
+ *keyfunc* is a function used to compute a grouping key for each item.
+ *valuefunc* is a function for transforming the items after grouping.
+
+ >>> iterable = 'AaaABbBCcA'
+ >>> keyfunc = lambda x: x.upper()
+ >>> valuefunc = lambda x: x.lower()
+ >>> grouper = groupby_transform(iterable, keyfunc, valuefunc)
+ >>> [(k, ''.join(g)) for k, g in grouper]
+ [('A', 'aaaa'), ('B', 'bbb'), ('C', 'cc'), ('A', 'a')]
+
+ *keyfunc* and *valuefunc* default to identity functions if they are not
+ specified.
+
+ :func:`groupby_transform` is useful when grouping elements of an iterable
+ using a separate iterable as the key. To do this, :func:`zip` the iterables
+ and pass a *keyfunc* that extracts the first element and a *valuefunc*
+ that extracts the second element::
+
+ >>> from operator import itemgetter
+ >>> keys = [0, 0, 1, 1, 1, 2, 2, 2, 3]
+ >>> values = 'abcdefghi'
+ >>> iterable = zip(keys, values)
+ >>> grouper = groupby_transform(iterable, itemgetter(0), itemgetter(1))
+ >>> [(k, ''.join(g)) for k, g in grouper]
+ [(0, 'ab'), (1, 'cde'), (2, 'fgh'), (3, 'i')]
+
+ Note that the order of items in the iterable is significant.
+ Only adjacent items are grouped together, so if you don't want any
+ duplicate groups, you should sort the iterable by the key function.
+
+ """
+ valuefunc = (lambda x: x) if valuefunc is None else valuefunc
+ return ((k, map(valuefunc, g)) for k, g in groupby(iterable, keyfunc))
+
+
+def numeric_range(*args):
+ """An extension of the built-in ``range()`` function whose arguments can
+ be any orderable numeric type.
+
+ With only *stop* specified, *start* defaults to ``0`` and *step*
+ defaults to ``1``. The output items will match the type of *stop*:
+
+ >>> list(numeric_range(3.5))
+ [0.0, 1.0, 2.0, 3.0]
+
+ With only *start* and *stop* specified, *step* defaults to ``1``. The
+ output items will match the type of *start*:
+
+ >>> from decimal import Decimal
+ >>> start = Decimal('2.1')
+ >>> stop = Decimal('5.1')
+ >>> list(numeric_range(start, stop))
+ [Decimal('2.1'), Decimal('3.1'), Decimal('4.1')]
+
+ With *start*, *stop*, and *step* specified the output items will match
+ the type of ``start + step``:
+
+ >>> from fractions import Fraction
+ >>> start = Fraction(1, 2) # Start at 1/2
+ >>> stop = Fraction(5, 2) # End at 5/2
+ >>> step = Fraction(1, 2) # Count by 1/2
+ >>> list(numeric_range(start, stop, step))
+ [Fraction(1, 2), Fraction(1, 1), Fraction(3, 2), Fraction(2, 1)]
+
+ If *step* is zero, ``ValueError`` is raised. Negative steps are supported:
+
+ >>> list(numeric_range(3, -1, -1.0))
+ [3.0, 2.0, 1.0, 0.0]
+
+ Be aware of the limitations of floating point numbers; the representation
+ of the yielded numbers may be surprising.
+
+ """
+ argc = len(args)
+ if argc == 1:
+ stop, = args
+ start = type(stop)(0)
+ step = 1
+ elif argc == 2:
+ start, stop = args
+ step = 1
+ elif argc == 3:
+ start, stop, step = args
+ else:
+ err_msg = 'numeric_range takes at most 3 arguments, got {}'
+ raise TypeError(err_msg.format(argc))
+
+ values = (start + (step * n) for n in count())
+ if step > 0:
+ return takewhile(partial(gt, stop), values)
+ elif step < 0:
+ return takewhile(partial(lt, stop), values)
+ else:
+ raise ValueError('numeric_range arg 3 must not be zero')
+
+
+def count_cycle(iterable, n=None):
+ """Cycle through the items from *iterable* up to *n* times, yielding
+ the number of completed cycles along with each item. If *n* is omitted the
+ process repeats indefinitely.
+
+ >>> list(count_cycle('AB', 3))
+ [(0, 'A'), (0, 'B'), (1, 'A'), (1, 'B'), (2, 'A'), (2, 'B')]
+
+ """
+ iterable = tuple(iterable)
+ if not iterable:
+ return iter(())
+ counter = count() if n is None else range(n)
+ return ((i, item) for i in counter for item in iterable)
+
+
+def locate(iterable, pred=bool, window_size=None):
+ """Yield the index of each item in *iterable* for which *pred* returns
+ ``True``.
+
+ *pred* defaults to :func:`bool`, which will select truthy items:
+
+ >>> list(locate([0, 1, 1, 0, 1, 0, 0]))
+ [1, 2, 4]
+
+ Set *pred* to a custom function to, e.g., find the indexes for a particular
+ item.
+
+ >>> list(locate(['a', 'b', 'c', 'b'], lambda x: x == 'b'))
+ [1, 3]
+
+ If *window_size* is given, then the *pred* function will be called with
+ that many items. This enables searching for sub-sequences:
+
+ >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
+ >>> pred = lambda *args: args == (1, 2, 3)
+ >>> list(locate(iterable, pred=pred, window_size=3))
+ [1, 5, 9]
+
+ Use with :func:`seekable` to find indexes and then retrieve the associated
+ items:
+
+ >>> from itertools import count
+ >>> from more_itertools import seekable
+ >>> source = (3 * n + 1 if (n % 2) else n // 2 for n in count())
+ >>> it = seekable(source)
+ >>> pred = lambda x: x > 100
+ >>> indexes = locate(it, pred=pred)
+ >>> i = next(indexes)
+ >>> it.seek(i)
+ >>> next(it)
+ 106
+
+ """
+ if window_size is None:
+ return compress(count(), map(pred, iterable))
+
+ if window_size < 1:
+ raise ValueError('window size must be at least 1')
+
+ it = windowed(iterable, window_size, fillvalue=_marker)
+ return compress(count(), starmap(pred, it))
+
+
+def lstrip(iterable, pred):
+ """Yield the items from *iterable*, but strip any from the beginning
+ for which *pred* returns ``True``.
+
+ For example, to remove a set of items from the start of an iterable:
+
+ >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
+ >>> pred = lambda x: x in {None, False, ''}
+ >>> list(lstrip(iterable, pred))
+ [1, 2, None, 3, False, None]
+
+ This function is analogous to to :func:`str.lstrip`, and is essentially
+ an wrapper for :func:`itertools.dropwhile`.
+
+ """
+ return dropwhile(pred, iterable)
+
+
+def rstrip(iterable, pred):
+ """Yield the items from *iterable*, but strip any from the end
+ for which *pred* returns ``True``.
+
+ For example, to remove a set of items from the end of an iterable:
+
+ >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
+ >>> pred = lambda x: x in {None, False, ''}
+ >>> list(rstrip(iterable, pred))
+ [None, False, None, 1, 2, None, 3]
+
+ This function is analogous to :func:`str.rstrip`.
+
+ """
+ cache = []
+ cache_append = cache.append
+ for x in iterable:
+ if pred(x):
+ cache_append(x)
+ else:
+ for y in cache:
+ yield y
+ del cache[:]
+ yield x
+
+
+def strip(iterable, pred):
+ """Yield the items from *iterable*, but strip any from the
+ beginning and end for which *pred* returns ``True``.
+
+ For example, to remove a set of items from both ends of an iterable:
+
+ >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
+ >>> pred = lambda x: x in {None, False, ''}
+ >>> list(strip(iterable, pred))
+ [1, 2, None, 3]
+
+ This function is analogous to :func:`str.strip`.
+
+ """
+ return rstrip(lstrip(iterable, pred), pred)
+
+
+def islice_extended(iterable, *args):
+ """An extension of :func:`itertools.islice` that supports negative values
+ for *stop*, *start*, and *step*.
+
+ >>> iterable = iter('abcdefgh')
+ >>> list(islice_extended(iterable, -4, -1))
+ ['e', 'f', 'g']
+
+ Slices with negative values require some caching of *iterable*, but this
+ function takes care to minimize the amount of memory required.
+
+ For example, you can use a negative step with an infinite iterator:
+
+ >>> from itertools import count
+ >>> list(islice_extended(count(), 110, 99, -2))
+ [110, 108, 106, 104, 102, 100]
+
+ """
+ s = slice(*args)
+ start = s.start
+ stop = s.stop
+ if s.step == 0:
+ raise ValueError('step argument must be a non-zero integer or None.')
+ step = s.step or 1
+
+ it = iter(iterable)
+
+ if step > 0:
+ start = 0 if (start is None) else start
+
+ if (start < 0):
+ # Consume all but the last -start items
+ cache = deque(enumerate(it, 1), maxlen=-start)
+ len_iter = cache[-1][0] if cache else 0
+
+ # Adjust start to be positive
+ i = max(len_iter + start, 0)
+
+ # Adjust stop to be positive
+ if stop is None:
+ j = len_iter
+ elif stop >= 0:
+ j = min(stop, len_iter)
+ else:
+ j = max(len_iter + stop, 0)
+
+ # Slice the cache
+ n = j - i
+ if n <= 0:
+ return
+
+ for index, item in islice(cache, 0, n, step):
+ yield item
+ elif (stop is not None) and (stop < 0):
+ # Advance to the start position
+ next(islice(it, start, start), None)
+
+ # When stop is negative, we have to carry -stop items while
+ # iterating
+ cache = deque(islice(it, -stop), maxlen=-stop)
+
+ for index, item in enumerate(it):
+ cached_item = cache.popleft()
+ if index % step == 0:
+ yield cached_item
+ cache.append(item)
+ else:
+ # When both start and stop are positive we have the normal case
+ for item in islice(it, start, stop, step):
+ yield item
+ else:
+ start = -1 if (start is None) else start
+
+ if (stop is not None) and (stop < 0):
+ # Consume all but the last items
+ n = -stop - 1
+ cache = deque(enumerate(it, 1), maxlen=n)
+ len_iter = cache[-1][0] if cache else 0
+
+ # If start and stop are both negative they are comparable and
+ # we can just slice. Otherwise we can adjust start to be negative
+ # and then slice.
+ if start < 0:
+ i, j = start, stop
+ else:
+ i, j = min(start - len_iter, -1), None
+
+ for index, item in list(cache)[i:j:step]:
+ yield item
+ else:
+ # Advance to the stop position
+ if stop is not None:
+ m = stop + 1
+ next(islice(it, m, m), None)
+
+ # stop is positive, so if start is negative they are not comparable
+ # and we need the rest of the items.
+ if start < 0:
+ i = start
+ n = None
+ # stop is None and start is positive, so we just need items up to
+ # the start index.
+ elif stop is None:
+ i = None
+ n = start + 1
+ # Both stop and start are positive, so they are comparable.
+ else:
+ i = None
+ n = start - stop
+ if n <= 0:
+ return
+
+ cache = list(islice(it, n))
+
+ for item in cache[i::step]:
+ yield item
+
+
+def always_reversible(iterable):
+ """An extension of :func:`reversed` that supports all iterables, not
+ just those which implement the ``Reversible`` or ``Sequence`` protocols.
+
+ >>> print(*always_reversible(x for x in range(3)))
+ 2 1 0
+
+ If the iterable is already reversible, this function returns the
+ result of :func:`reversed()`. If the iterable is not reversible,
+ this function will cache the remaining items in the iterable and
+ yield them in reverse order, which may require significant storage.
+ """
+ try:
+ return reversed(iterable)
+ except TypeError:
+ return reversed(list(iterable))
+
+
+def consecutive_groups(iterable, ordering=lambda x: x):
+ """Yield groups of consecutive items using :func:`itertools.groupby`.
+ The *ordering* function determines whether two items are adjacent by
+ returning their position.
+
+ By default, the ordering function is the identity function. This is
+ suitable for finding runs of numbers:
+
+ >>> iterable = [1, 10, 11, 12, 20, 30, 31, 32, 33, 40]
+ >>> for group in consecutive_groups(iterable):
+ ... print(list(group))
+ [1]
+ [10, 11, 12]
+ [20]
+ [30, 31, 32, 33]
+ [40]
+
+ For finding runs of adjacent letters, try using the :meth:`index` method
+ of a string of letters:
+
+ >>> from string import ascii_lowercase
+ >>> iterable = 'abcdfgilmnop'
+ >>> ordering = ascii_lowercase.index
+ >>> for group in consecutive_groups(iterable, ordering):
+ ... print(list(group))
+ ['a', 'b', 'c', 'd']
+ ['f', 'g']
+ ['i']
+ ['l', 'm', 'n', 'o', 'p']
+
+ """
+ for k, g in groupby(
+ enumerate(iterable), key=lambda x: x[0] - ordering(x[1])
+ ):
+ yield map(itemgetter(1), g)
+
+
+def difference(iterable, func=sub):
+ """By default, compute the first difference of *iterable* using
+ :func:`operator.sub`.
+
+ >>> iterable = [0, 1, 3, 6, 10]
+ >>> list(difference(iterable))
+ [0, 1, 2, 3, 4]
+
+ This is the opposite of :func:`accumulate`'s default behavior:
+
+ >>> from more_itertools import accumulate
+ >>> iterable = [0, 1, 2, 3, 4]
+ >>> list(accumulate(iterable))
+ [0, 1, 3, 6, 10]
+ >>> list(difference(accumulate(iterable)))
+ [0, 1, 2, 3, 4]
+
+ By default *func* is :func:`operator.sub`, but other functions can be
+ specified. They will be applied as follows::
+
+ A, B, C, D, ... --> A, func(B, A), func(C, B), func(D, C), ...
+
+ For example, to do progressive division:
+
+ >>> iterable = [1, 2, 6, 24, 120] # Factorial sequence
+ >>> func = lambda x, y: x // y
+ >>> list(difference(iterable, func))
+ [1, 2, 3, 4, 5]
+
+ """
+ a, b = tee(iterable)
+ try:
+ item = next(b)
+ except StopIteration:
+ return iter([])
+ return chain([item], map(lambda x: func(x[1], x[0]), zip(a, b)))
+
+
+class SequenceView(Sequence):
+ """Return a read-only view of the sequence object *target*.
+
+ :class:`SequenceView` objects are analogous to Python's built-in
+ "dictionary view" types. They provide a dynamic view of a sequence's items,
+ meaning that when the sequence updates, so does the view.
+
+ >>> seq = ['0', '1', '2']
+ >>> view = SequenceView(seq)
+ >>> view
+ SequenceView(['0', '1', '2'])
+ >>> seq.append('3')
+ >>> view
+ SequenceView(['0', '1', '2', '3'])
+
+ Sequence views support indexing, slicing, and length queries. They act
+ like the underlying sequence, except they don't allow assignment:
+
+ >>> view[1]
+ '1'
+ >>> view[1:-1]
+ ['1', '2']
+ >>> len(view)
+ 4
+
+ Sequence views are useful as an alternative to copying, as they don't
+ require (much) extra storage.
+
+ """
+ def __init__(self, target):
+ if not isinstance(target, Sequence):
+ raise TypeError
+ self._target = target
+
+ def __getitem__(self, index):
+ return self._target[index]
+
+ def __len__(self):
+ return len(self._target)
+
+ def __repr__(self):
+ return '{}({})'.format(self.__class__.__name__, repr(self._target))
+
+
+class seekable(object):
+ """Wrap an iterator to allow for seeking backward and forward. This
+ progressively caches the items in the source iterable so they can be
+ re-visited.
+
+ Call :meth:`seek` with an index to seek to that position in the source
+ iterable.
+
+ To "reset" an iterator, seek to ``0``:
+
+ >>> from itertools import count
+ >>> it = seekable((str(n) for n in count()))
+ >>> next(it), next(it), next(it)
+ ('0', '1', '2')
+ >>> it.seek(0)
+ >>> next(it), next(it), next(it)
+ ('0', '1', '2')
+ >>> next(it)
+ '3'
+
+ You can also seek forward:
+
+ >>> it = seekable((str(n) for n in range(20)))
+ >>> it.seek(10)
+ >>> next(it)
+ '10'
+ >>> it.seek(20) # Seeking past the end of the source isn't a problem
+ >>> list(it)
+ []
+ >>> it.seek(0) # Resetting works even after hitting the end
+ >>> next(it), next(it), next(it)
+ ('0', '1', '2')
+
+ The cache grows as the source iterable progresses, so beware of wrapping
+ very large or infinite iterables.
+
+ You may view the contents of the cache with the :meth:`elements` method.
+ That returns a :class:`SequenceView`, a view that updates automatically:
+
+ >>> it = seekable((str(n) for n in range(10)))
+ >>> next(it), next(it), next(it)
+ ('0', '1', '2')
+ >>> elements = it.elements()
+ >>> elements
+ SequenceView(['0', '1', '2'])
+ >>> next(it)
+ '3'
+ >>> elements
+ SequenceView(['0', '1', '2', '3'])
+
+ """
+
+ def __init__(self, iterable):
+ self._source = iter(iterable)
+ self._cache = []
+ self._index = None
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ if self._index is not None:
+ try:
+ item = self._cache[self._index]
+ except IndexError:
+ self._index = None
+ else:
+ self._index += 1
+ return item
+
+ item = next(self._source)
+ self._cache.append(item)
+ return item
+
+ next = __next__
+
+ def elements(self):
+ return SequenceView(self._cache)
+
+ def seek(self, index):
+ self._index = index
+ remainder = index - len(self._cache)
+ if remainder > 0:
+ consume(self, remainder)
+
+
+class run_length(object):
+ """
+ :func:`run_length.encode` compresses an iterable with run-length encoding.
+ It yields groups of repeated items with the count of how many times they
+ were repeated:
+
+ >>> uncompressed = 'abbcccdddd'
+ >>> list(run_length.encode(uncompressed))
+ [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
+
+ :func:`run_length.decode` decompresses an iterable that was previously
+ compressed with run-length encoding. It yields the items of the
+ decompressed iterable:
+
+ >>> compressed = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
+ >>> list(run_length.decode(compressed))
+ ['a', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'd']
+
+ """
+
+ @staticmethod
+ def encode(iterable):
+ return ((k, ilen(g)) for k, g in groupby(iterable))
+
+ @staticmethod
+ def decode(iterable):
+ return chain.from_iterable(repeat(k, n) for k, n in iterable)
+
+
+def exactly_n(iterable, n, predicate=bool):
+ """Return ``True`` if exactly ``n`` items in the iterable are ``True``
+ according to the *predicate* function.
+
+ >>> exactly_n([True, True, False], 2)
+ True
+ >>> exactly_n([True, True, False], 1)
+ False
+ >>> exactly_n([0, 1, 2, 3, 4, 5], 3, lambda x: x < 3)
+ True
+
+ The iterable will be advanced until ``n + 1`` truthy items are encountered,
+ so avoid calling it on infinite iterables.
+
+ """
+ return len(take(n + 1, filter(predicate, iterable))) == n
+
+
+def circular_shifts(iterable):
+ """Return a list of circular shifts of *iterable*.
+
+ >>> circular_shifts(range(4))
+ [(0, 1, 2, 3), (1, 2, 3, 0), (2, 3, 0, 1), (3, 0, 1, 2)]
+ """
+ lst = list(iterable)
+ return take(len(lst), windowed(cycle(lst), len(lst)))
+
+
+def make_decorator(wrapping_func, result_index=0):
+ """Return a decorator version of *wrapping_func*, which is a function that
+ modifies an iterable. *result_index* is the position in that function's
+ signature where the iterable goes.
+
+ This lets you use itertools on the "production end," i.e. at function
+ definition. This can augment what the function returns without changing the
+ function's code.
+
+ For example, to produce a decorator version of :func:`chunked`:
+
+ >>> from more_itertools import chunked
+ >>> chunker = make_decorator(chunked, result_index=0)
+ >>> @chunker(3)
+ ... def iter_range(n):
+ ... return iter(range(n))
+ ...
+ >>> list(iter_range(9))
+ [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
+
+ To only allow truthy items to be returned:
+
+ >>> truth_serum = make_decorator(filter, result_index=1)
+ >>> @truth_serum(bool)
+ ... def boolean_test():
+ ... return [0, 1, '', ' ', False, True]
+ ...
+ >>> list(boolean_test())
+ [1, ' ', True]
+
+ The :func:`peekable` and :func:`seekable` wrappers make for practical
+ decorators:
+
+ >>> from more_itertools import peekable
+ >>> peekable_function = make_decorator(peekable)
+ >>> @peekable_function()
+ ... def str_range(*args):
+ ... return (str(x) for x in range(*args))
+ ...
+ >>> it = str_range(1, 20, 2)
+ >>> next(it), next(it), next(it)
+ ('1', '3', '5')
+ >>> it.peek()
+ '7'
+ >>> next(it)
+ '7'
+
+ """
+ # See https://sites.google.com/site/bbayles/index/decorator_factory for
+ # notes on how this works.
+ def decorator(*wrapping_args, **wrapping_kwargs):
+ def outer_wrapper(f):
+ def inner_wrapper(*args, **kwargs):
+ result = f(*args, **kwargs)
+ wrapping_args_ = list(wrapping_args)
+ wrapping_args_.insert(result_index, result)
+ return wrapping_func(*wrapping_args_, **wrapping_kwargs)
+
+ return inner_wrapper
+
+ return outer_wrapper
+
+ return decorator
+
+
+def map_reduce(iterable, keyfunc, valuefunc=None, reducefunc=None):
+ """Return a dictionary that maps the items in *iterable* to categories
+ defined by *keyfunc*, transforms them with *valuefunc*, and
+ then summarizes them by category with *reducefunc*.
+
+ *valuefunc* defaults to the identity function if it is unspecified.
+ If *reducefunc* is unspecified, no summarization takes place:
+
+ >>> keyfunc = lambda x: x.upper()
+ >>> result = map_reduce('abbccc', keyfunc)
+ >>> sorted(result.items())
+ [('A', ['a']), ('B', ['b', 'b']), ('C', ['c', 'c', 'c'])]
+
+ Specifying *valuefunc* transforms the categorized items:
+
+ >>> keyfunc = lambda x: x.upper()
+ >>> valuefunc = lambda x: 1
+ >>> result = map_reduce('abbccc', keyfunc, valuefunc)
+ >>> sorted(result.items())
+ [('A', [1]), ('B', [1, 1]), ('C', [1, 1, 1])]
+
+ Specifying *reducefunc* summarizes the categorized items:
+
+ >>> keyfunc = lambda x: x.upper()
+ >>> valuefunc = lambda x: 1
+ >>> reducefunc = sum
+ >>> result = map_reduce('abbccc', keyfunc, valuefunc, reducefunc)
+ >>> sorted(result.items())
+ [('A', 1), ('B', 2), ('C', 3)]
+
+ You may want to filter the input iterable before applying the map/reduce
+ procedure:
+
+ >>> all_items = range(30)
+ >>> items = [x for x in all_items if 10 <= x <= 20] # Filter
+ >>> keyfunc = lambda x: x % 2 # Evens map to 0; odds to 1
+ >>> categories = map_reduce(items, keyfunc=keyfunc)
+ >>> sorted(categories.items())
+ [(0, [10, 12, 14, 16, 18, 20]), (1, [11, 13, 15, 17, 19])]
+ >>> summaries = map_reduce(items, keyfunc=keyfunc, reducefunc=sum)
+ >>> sorted(summaries.items())
+ [(0, 90), (1, 75)]
+
+ Note that all items in the iterable are gathered into a list before the
+ summarization step, which may require significant storage.
+
+ The returned object is a :obj:`collections.defaultdict` with the
+ ``default_factory`` set to ``None``, such that it behaves like a normal
+ dictionary.
+
+ """
+ valuefunc = (lambda x: x) if (valuefunc is None) else valuefunc
+
+ ret = defaultdict(list)
+ for item in iterable:
+ key = keyfunc(item)
+ value = valuefunc(item)
+ ret[key].append(value)
+
+ if reducefunc is not None:
+ for key, value_list in ret.items():
+ ret[key] = reducefunc(value_list)
+
+ ret.default_factory = None
+ return ret
+
+
+def rlocate(iterable, pred=bool, window_size=None):
+ """Yield the index of each item in *iterable* for which *pred* returns
+ ``True``, starting from the right and moving left.
+
+ *pred* defaults to :func:`bool`, which will select truthy items:
+
+ >>> list(rlocate([0, 1, 1, 0, 1, 0, 0])) # Truthy at 1, 2, and 4
+ [4, 2, 1]
+
+ Set *pred* to a custom function to, e.g., find the indexes for a particular
+ item:
+
+ >>> iterable = iter('abcb')
+ >>> pred = lambda x: x == 'b'
+ >>> list(rlocate(iterable, pred))
+ [3, 1]
+
+ If *window_size* is given, then the *pred* function will be called with
+ that many items. This enables searching for sub-sequences:
+
+ >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
+ >>> pred = lambda *args: args == (1, 2, 3)
+ >>> list(rlocate(iterable, pred=pred, window_size=3))
+ [9, 5, 1]
+
+ Beware, this function won't return anything for infinite iterables.
+ If *iterable* is reversible, ``rlocate`` will reverse it and search from
+ the right. Otherwise, it will search from the left and return the results
+ in reverse order.
+
+ See :func:`locate` to for other example applications.
+
+ """
+ if window_size is None:
+ try:
+ len_iter = len(iterable)
+ return (
+ len_iter - i - 1 for i in locate(reversed(iterable), pred)
+ )
+ except TypeError:
+ pass
+
+ return reversed(list(locate(iterable, pred, window_size)))
+
+
+def replace(iterable, pred, substitutes, count=None, window_size=1):
+ """Yield the items from *iterable*, replacing the items for which *pred*
+ returns ``True`` with the items from the iterable *substitutes*.
+
+ >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1]
+ >>> pred = lambda x: x == 0
+ >>> substitutes = (2, 3)
+ >>> list(replace(iterable, pred, substitutes))
+ [1, 1, 2, 3, 1, 1, 2, 3, 1, 1]
+
+ If *count* is given, the number of replacements will be limited:
+
+ >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1, 0]
+ >>> pred = lambda x: x == 0
+ >>> substitutes = [None]
+ >>> list(replace(iterable, pred, substitutes, count=2))
+ [1, 1, None, 1, 1, None, 1, 1, 0]
+
+ Use *window_size* to control the number of items passed as arguments to
+ *pred*. This allows for locating and replacing subsequences.
+
+ >>> iterable = [0, 1, 2, 5, 0, 1, 2, 5]
+ >>> window_size = 3
+ >>> pred = lambda *args: args == (0, 1, 2) # 3 items passed to pred
+ >>> substitutes = [3, 4] # Splice in these items
+ >>> list(replace(iterable, pred, substitutes, window_size=window_size))
+ [3, 4, 5, 3, 4, 5]
+
+ """
+ if window_size < 1:
+ raise ValueError('window_size must be at least 1')
+
+ # Save the substitutes iterable, since it's used more than once
+ substitutes = tuple(substitutes)
+
+ # Add padding such that the number of windows matches the length of the
+ # iterable
+ it = chain(iterable, [_marker] * (window_size - 1))
+ windows = windowed(it, window_size)
+
+ n = 0
+ for w in windows:
+ # If the current window matches our predicate (and we haven't hit
+ # our maximum number of replacements), splice in the substitutes
+ # and then consume the following windows that overlap with this one.
+ # For example, if the iterable is (0, 1, 2, 3, 4...)
+ # and the window size is 2, we have (0, 1), (1, 2), (2, 3)...
+ # If the predicate matches on (0, 1), we need to zap (0, 1) and (1, 2)
+ if pred(*w):
+ if (count is None) or (n < count):
+ n += 1
+ for s in substitutes:
+ yield s
+ consume(windows, window_size - 1)
+ continue
+
+ # If there was no match (or we've reached the replacement limit),
+ # yield the first item from the window.
+ if w and (w[0] is not _marker):
+ yield w[0]
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools/recipes.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools/recipes.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b455d4eb80e4de16205a24a6e23388773b04aac
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/more_itertools/recipes.py
@@ -0,0 +1,577 @@
+"""Imported from the recipes section of the itertools documentation.
+
+All functions taken from the recipes section of the itertools library docs
+[1]_.
+Some backward-compatible usability improvements have been made.
+
+.. [1] http://docs.python.org/library/itertools.html#recipes
+
+"""
+from collections import deque
+from itertools import (
+ chain, combinations, count, cycle, groupby, islice, repeat, starmap, tee
+)
+import operator
+from random import randrange, sample, choice
+
+from six import PY2
+from six.moves import filter, filterfalse, map, range, zip, zip_longest
+
+__all__ = [
+ 'accumulate',
+ 'all_equal',
+ 'consume',
+ 'dotproduct',
+ 'first_true',
+ 'flatten',
+ 'grouper',
+ 'iter_except',
+ 'ncycles',
+ 'nth',
+ 'nth_combination',
+ 'padnone',
+ 'pairwise',
+ 'partition',
+ 'powerset',
+ 'prepend',
+ 'quantify',
+ 'random_combination_with_replacement',
+ 'random_combination',
+ 'random_permutation',
+ 'random_product',
+ 'repeatfunc',
+ 'roundrobin',
+ 'tabulate',
+ 'tail',
+ 'take',
+ 'unique_everseen',
+ 'unique_justseen',
+]
+
+
+def accumulate(iterable, func=operator.add):
+ """
+ Return an iterator whose items are the accumulated results of a function
+ (specified by the optional *func* argument) that takes two arguments.
+ By default, returns accumulated sums with :func:`operator.add`.
+
+ >>> list(accumulate([1, 2, 3, 4, 5])) # Running sum
+ [1, 3, 6, 10, 15]
+ >>> list(accumulate([1, 2, 3], func=operator.mul)) # Running product
+ [1, 2, 6]
+ >>> list(accumulate([0, 1, -1, 2, 3, 2], func=max)) # Running maximum
+ [0, 1, 1, 2, 3, 3]
+
+ This function is available in the ``itertools`` module for Python 3.2 and
+ greater.
+
+ """
+ it = iter(iterable)
+ try:
+ total = next(it)
+ except StopIteration:
+ return
+ else:
+ yield total
+
+ for element in it:
+ total = func(total, element)
+ yield total
+
+
+def take(n, iterable):
+ """Return first *n* items of the iterable as a list.
+
+ >>> take(3, range(10))
+ [0, 1, 2]
+ >>> take(5, range(3))
+ [0, 1, 2]
+
+ Effectively a short replacement for ``next`` based iterator consumption
+ when you want more than one item, but less than the whole iterator.
+
+ """
+ return list(islice(iterable, n))
+
+
+def tabulate(function, start=0):
+ """Return an iterator over the results of ``func(start)``,
+ ``func(start + 1)``, ``func(start + 2)``...
+
+ *func* should be a function that accepts one integer argument.
+
+ If *start* is not specified it defaults to 0. It will be incremented each
+ time the iterator is advanced.
+
+ >>> square = lambda x: x ** 2
+ >>> iterator = tabulate(square, -3)
+ >>> take(4, iterator)
+ [9, 4, 1, 0]
+
+ """
+ return map(function, count(start))
+
+
+def tail(n, iterable):
+ """Return an iterator over the last *n* items of *iterable*.
+
+ >>> t = tail(3, 'ABCDEFG')
+ >>> list(t)
+ ['E', 'F', 'G']
+
+ """
+ return iter(deque(iterable, maxlen=n))
+
+
+def consume(iterator, n=None):
+ """Advance *iterable* by *n* steps. If *n* is ``None``, consume it
+ entirely.
+
+ Efficiently exhausts an iterator without returning values. Defaults to
+ consuming the whole iterator, but an optional second argument may be
+ provided to limit consumption.
+
+ >>> i = (x for x in range(10))
+ >>> next(i)
+ 0
+ >>> consume(i, 3)
+ >>> next(i)
+ 4
+ >>> consume(i)
+ >>> next(i)
+ Traceback (most recent call last):
+ File "", line 1, in
+ StopIteration
+
+ If the iterator has fewer items remaining than the provided limit, the
+ whole iterator will be consumed.
+
+ >>> i = (x for x in range(3))
+ >>> consume(i, 5)
+ >>> next(i)
+ Traceback (most recent call last):
+ File "", line 1, in
+ StopIteration
+
+ """
+ # Use functions that consume iterators at C speed.
+ if n is None:
+ # feed the entire iterator into a zero-length deque
+ deque(iterator, maxlen=0)
+ else:
+ # advance to the empty slice starting at position n
+ next(islice(iterator, n, n), None)
+
+
+def nth(iterable, n, default=None):
+ """Returns the nth item or a default value.
+
+ >>> l = range(10)
+ >>> nth(l, 3)
+ 3
+ >>> nth(l, 20, "zebra")
+ 'zebra'
+
+ """
+ return next(islice(iterable, n, None), default)
+
+
+def all_equal(iterable):
+ """
+ Returns ``True`` if all the elements are equal to each other.
+
+ >>> all_equal('aaaa')
+ True
+ >>> all_equal('aaab')
+ False
+
+ """
+ g = groupby(iterable)
+ return next(g, True) and not next(g, False)
+
+
+def quantify(iterable, pred=bool):
+ """Return the how many times the predicate is true.
+
+ >>> quantify([True, False, True])
+ 2
+
+ """
+ return sum(map(pred, iterable))
+
+
+def padnone(iterable):
+ """Returns the sequence of elements and then returns ``None`` indefinitely.
+
+ >>> take(5, padnone(range(3)))
+ [0, 1, 2, None, None]
+
+ Useful for emulating the behavior of the built-in :func:`map` function.
+
+ See also :func:`padded`.
+
+ """
+ return chain(iterable, repeat(None))
+
+
+def ncycles(iterable, n):
+ """Returns the sequence elements *n* times
+
+ >>> list(ncycles(["a", "b"], 3))
+ ['a', 'b', 'a', 'b', 'a', 'b']
+
+ """
+ return chain.from_iterable(repeat(tuple(iterable), n))
+
+
+def dotproduct(vec1, vec2):
+ """Returns the dot product of the two iterables.
+
+ >>> dotproduct([10, 10], [20, 20])
+ 400
+
+ """
+ return sum(map(operator.mul, vec1, vec2))
+
+
+def flatten(listOfLists):
+ """Return an iterator flattening one level of nesting in a list of lists.
+
+ >>> list(flatten([[0, 1], [2, 3]]))
+ [0, 1, 2, 3]
+
+ See also :func:`collapse`, which can flatten multiple levels of nesting.
+
+ """
+ return chain.from_iterable(listOfLists)
+
+
+def repeatfunc(func, times=None, *args):
+ """Call *func* with *args* repeatedly, returning an iterable over the
+ results.
+
+ If *times* is specified, the iterable will terminate after that many
+ repetitions:
+
+ >>> from operator import add
+ >>> times = 4
+ >>> args = 3, 5
+ >>> list(repeatfunc(add, times, *args))
+ [8, 8, 8, 8]
+
+ If *times* is ``None`` the iterable will not terminate:
+
+ >>> from random import randrange
+ >>> times = None
+ >>> args = 1, 11
+ >>> take(6, repeatfunc(randrange, times, *args)) # doctest:+SKIP
+ [2, 4, 8, 1, 8, 4]
+
+ """
+ if times is None:
+ return starmap(func, repeat(args))
+ return starmap(func, repeat(args, times))
+
+
+def pairwise(iterable):
+ """Returns an iterator of paired items, overlapping, from the original
+
+ >>> take(4, pairwise(count()))
+ [(0, 1), (1, 2), (2, 3), (3, 4)]
+
+ """
+ a, b = tee(iterable)
+ next(b, None)
+ return zip(a, b)
+
+
+def grouper(n, iterable, fillvalue=None):
+ """Collect data into fixed-length chunks or blocks.
+
+ >>> list(grouper(3, 'ABCDEFG', 'x'))
+ [('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')]
+
+ """
+ args = [iter(iterable)] * n
+ return zip_longest(fillvalue=fillvalue, *args)
+
+
+def roundrobin(*iterables):
+ """Yields an item from each iterable, alternating between them.
+
+ >>> list(roundrobin('ABC', 'D', 'EF'))
+ ['A', 'D', 'E', 'B', 'F', 'C']
+
+ This function produces the same output as :func:`interleave_longest`, but
+ may perform better for some inputs (in particular when the number of
+ iterables is small).
+
+ """
+ # Recipe credited to George Sakkis
+ pending = len(iterables)
+ if PY2:
+ nexts = cycle(iter(it).next for it in iterables)
+ else:
+ nexts = cycle(iter(it).__next__ for it in iterables)
+ while pending:
+ try:
+ for next in nexts:
+ yield next()
+ except StopIteration:
+ pending -= 1
+ nexts = cycle(islice(nexts, pending))
+
+
+def partition(pred, iterable):
+ """
+ Returns a 2-tuple of iterables derived from the input iterable.
+ The first yields the items that have ``pred(item) == False``.
+ The second yields the items that have ``pred(item) == True``.
+
+ >>> is_odd = lambda x: x % 2 != 0
+ >>> iterable = range(10)
+ >>> even_items, odd_items = partition(is_odd, iterable)
+ >>> list(even_items), list(odd_items)
+ ([0, 2, 4, 6, 8], [1, 3, 5, 7, 9])
+
+ """
+ # partition(is_odd, range(10)) --> 0 2 4 6 8 and 1 3 5 7 9
+ t1, t2 = tee(iterable)
+ return filterfalse(pred, t1), filter(pred, t2)
+
+
+def powerset(iterable):
+ """Yields all possible subsets of the iterable.
+
+ >>> list(powerset([1, 2, 3]))
+ [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
+
+ :func:`powerset` will operate on iterables that aren't :class:`set`
+ instances, so repeated elements in the input will produce repeated elements
+ in the output. Use :func:`unique_everseen` on the input to avoid generating
+ duplicates:
+
+ >>> seq = [1, 1, 0]
+ >>> list(powerset(seq))
+ [(), (1,), (1,), (0,), (1, 1), (1, 0), (1, 0), (1, 1, 0)]
+ >>> from more_itertools import unique_everseen
+ >>> list(powerset(unique_everseen(seq)))
+ [(), (1,), (0,), (1, 0)]
+
+ """
+ s = list(iterable)
+ return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1))
+
+
+def unique_everseen(iterable, key=None):
+ """
+ Yield unique elements, preserving order.
+
+ >>> list(unique_everseen('AAAABBBCCDAABBB'))
+ ['A', 'B', 'C', 'D']
+ >>> list(unique_everseen('ABBCcAD', str.lower))
+ ['A', 'B', 'C', 'D']
+
+ Sequences with a mix of hashable and unhashable items can be used.
+ The function will be slower (i.e., `O(n^2)`) for unhashable items.
+
+ """
+ seenset = set()
+ seenset_add = seenset.add
+ seenlist = []
+ seenlist_add = seenlist.append
+ if key is None:
+ for element in iterable:
+ try:
+ if element not in seenset:
+ seenset_add(element)
+ yield element
+ except TypeError:
+ if element not in seenlist:
+ seenlist_add(element)
+ yield element
+ else:
+ for element in iterable:
+ k = key(element)
+ try:
+ if k not in seenset:
+ seenset_add(k)
+ yield element
+ except TypeError:
+ if k not in seenlist:
+ seenlist_add(k)
+ yield element
+
+
+def unique_justseen(iterable, key=None):
+ """Yields elements in order, ignoring serial duplicates
+
+ >>> list(unique_justseen('AAAABBBCCDAABBB'))
+ ['A', 'B', 'C', 'D', 'A', 'B']
+ >>> list(unique_justseen('ABBCcAD', str.lower))
+ ['A', 'B', 'C', 'A', 'D']
+
+ """
+ return map(next, map(operator.itemgetter(1), groupby(iterable, key)))
+
+
+def iter_except(func, exception, first=None):
+ """Yields results from a function repeatedly until an exception is raised.
+
+ Converts a call-until-exception interface to an iterator interface.
+ Like ``iter(func, sentinel)``, but uses an exception instead of a sentinel
+ to end the loop.
+
+ >>> l = [0, 1, 2]
+ >>> list(iter_except(l.pop, IndexError))
+ [2, 1, 0]
+
+ """
+ try:
+ if first is not None:
+ yield first()
+ while 1:
+ yield func()
+ except exception:
+ pass
+
+
+def first_true(iterable, default=None, pred=None):
+ """
+ Returns the first true value in the iterable.
+
+ If no true value is found, returns *default*
+
+ If *pred* is not None, returns the first item for which
+ ``pred(item) == True`` .
+
+ >>> first_true(range(10))
+ 1
+ >>> first_true(range(10), pred=lambda x: x > 5)
+ 6
+ >>> first_true(range(10), default='missing', pred=lambda x: x > 9)
+ 'missing'
+
+ """
+ return next(filter(pred, iterable), default)
+
+
+def random_product(*args, **kwds):
+ """Draw an item at random from each of the input iterables.
+
+ >>> random_product('abc', range(4), 'XYZ') # doctest:+SKIP
+ ('c', 3, 'Z')
+
+ If *repeat* is provided as a keyword argument, that many items will be
+ drawn from each iterable.
+
+ >>> random_product('abcd', range(4), repeat=2) # doctest:+SKIP
+ ('a', 2, 'd', 3)
+
+ This equivalent to taking a random selection from
+ ``itertools.product(*args, **kwarg)``.
+
+ """
+ pools = [tuple(pool) for pool in args] * kwds.get('repeat', 1)
+ return tuple(choice(pool) for pool in pools)
+
+
+def random_permutation(iterable, r=None):
+ """Return a random *r* length permutation of the elements in *iterable*.
+
+ If *r* is not specified or is ``None``, then *r* defaults to the length of
+ *iterable*.
+
+ >>> random_permutation(range(5)) # doctest:+SKIP
+ (3, 4, 0, 1, 2)
+
+ This equivalent to taking a random selection from
+ ``itertools.permutations(iterable, r)``.
+
+ """
+ pool = tuple(iterable)
+ r = len(pool) if r is None else r
+ return tuple(sample(pool, r))
+
+
+def random_combination(iterable, r):
+ """Return a random *r* length subsequence of the elements in *iterable*.
+
+ >>> random_combination(range(5), 3) # doctest:+SKIP
+ (2, 3, 4)
+
+ This equivalent to taking a random selection from
+ ``itertools.combinations(iterable, r)``.
+
+ """
+ pool = tuple(iterable)
+ n = len(pool)
+ indices = sorted(sample(range(n), r))
+ return tuple(pool[i] for i in indices)
+
+
+def random_combination_with_replacement(iterable, r):
+ """Return a random *r* length subsequence of elements in *iterable*,
+ allowing individual elements to be repeated.
+
+ >>> random_combination_with_replacement(range(3), 5) # doctest:+SKIP
+ (0, 0, 1, 2, 2)
+
+ This equivalent to taking a random selection from
+ ``itertools.combinations_with_replacement(iterable, r)``.
+
+ """
+ pool = tuple(iterable)
+ n = len(pool)
+ indices = sorted(randrange(n) for i in range(r))
+ return tuple(pool[i] for i in indices)
+
+
+def nth_combination(iterable, r, index):
+ """Equivalent to ``list(combinations(iterable, r))[index]``.
+
+ The subsequences of *iterable* that are of length *r* can be ordered
+ lexicographically. :func:`nth_combination` computes the subsequence at
+ sort position *index* directly, without computing the previous
+ subsequences.
+
+ """
+ pool = tuple(iterable)
+ n = len(pool)
+ if (r < 0) or (r > n):
+ raise ValueError
+
+ c = 1
+ k = min(r, n - r)
+ for i in range(1, k + 1):
+ c = c * (n - k + i) // i
+
+ if index < 0:
+ index += c
+
+ if (index < 0) or (index >= c):
+ raise IndexError
+
+ result = []
+ while r:
+ c, n, r = c * r // n, n - 1, r - 1
+ while index >= c:
+ index -= c
+ c, n = c * (n - r) // n, n - 1
+ result.append(pool[-1 - n])
+
+ return tuple(result)
+
+
+def prepend(value, iterator):
+ """Yield *value*, followed by the elements in *iterator*.
+
+ >>> value = '0'
+ >>> iterator = ['1', '2', '3']
+ >>> list(prepend(value, iterator))
+ ['0', '1', '2', '3']
+
+ To prepend multiple values, see :func:`itertools.chain`.
+
+ """
+ return chain([value], iterator)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/msgpack/exceptions.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/msgpack/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..97668814f2767c3c642132d312b76a9ded1bca2e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/msgpack/exceptions.py
@@ -0,0 +1,41 @@
+class UnpackException(Exception):
+ """Deprecated. Use Exception instead to catch all exception during unpacking."""
+
+
+class BufferFull(UnpackException):
+ pass
+
+
+class OutOfData(UnpackException):
+ pass
+
+
+class UnpackValueError(UnpackException, ValueError):
+ """Deprecated. Use ValueError instead."""
+
+
+class ExtraData(UnpackValueError):
+ def __init__(self, unpacked, extra):
+ self.unpacked = unpacked
+ self.extra = extra
+
+ def __str__(self):
+ return "unpack(b) received extra data."
+
+
+class PackException(Exception):
+ """Deprecated. Use Exception instead to catch all exception during packing."""
+
+
+class PackValueError(PackException, ValueError):
+ """PackValueError is raised when type of input data is supported but it's value is unsupported.
+
+ Deprecated. Use ValueError instead.
+ """
+
+
+class PackOverflowError(PackValueError, OverflowError):
+ """PackOverflowError is raised when integer value is out of range of msgpack support [-2**31, 2**32).
+
+ Deprecated. Use ValueError instead.
+ """
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/msgpack/fallback.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/msgpack/fallback.py
new file mode 100644
index 0000000000000000000000000000000000000000..c0e5fd663f91a89123e393d06b3dc8a6473aca44
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/msgpack/fallback.py
@@ -0,0 +1,971 @@
+"""Fallback pure Python implementation of msgpack"""
+
+import sys
+import struct
+import warnings
+
+if sys.version_info[0] == 3:
+ PY3 = True
+ int_types = int
+ Unicode = str
+ xrange = range
+ def dict_iteritems(d):
+ return d.items()
+else:
+ PY3 = False
+ int_types = (int, long)
+ Unicode = unicode
+ def dict_iteritems(d):
+ return d.iteritems()
+
+
+if hasattr(sys, 'pypy_version_info'):
+ # cStringIO is slow on PyPy, StringIO is faster. However: PyPy's own
+ # StringBuilder is fastest.
+ from __pypy__ import newlist_hint
+ try:
+ from __pypy__.builders import BytesBuilder as StringBuilder
+ except ImportError:
+ from __pypy__.builders import StringBuilder
+ USING_STRINGBUILDER = True
+ class StringIO(object):
+ def __init__(self, s=b''):
+ if s:
+ self.builder = StringBuilder(len(s))
+ self.builder.append(s)
+ else:
+ self.builder = StringBuilder()
+ def write(self, s):
+ if isinstance(s, memoryview):
+ s = s.tobytes()
+ elif isinstance(s, bytearray):
+ s = bytes(s)
+ self.builder.append(s)
+ def getvalue(self):
+ return self.builder.build()
+else:
+ USING_STRINGBUILDER = False
+ from io import BytesIO as StringIO
+ newlist_hint = lambda size: []
+
+
+from msgpack.exceptions import (
+ BufferFull,
+ OutOfData,
+ UnpackValueError,
+ PackValueError,
+ PackOverflowError,
+ ExtraData)
+
+from msgpack import ExtType
+
+
+EX_SKIP = 0
+EX_CONSTRUCT = 1
+EX_READ_ARRAY_HEADER = 2
+EX_READ_MAP_HEADER = 3
+
+TYPE_IMMEDIATE = 0
+TYPE_ARRAY = 1
+TYPE_MAP = 2
+TYPE_RAW = 3
+TYPE_BIN = 4
+TYPE_EXT = 5
+
+DEFAULT_RECURSE_LIMIT = 511
+
+
+def _check_type_strict(obj, t, type=type, tuple=tuple):
+ if type(t) is tuple:
+ return type(obj) in t
+ else:
+ return type(obj) is t
+
+
+def _get_data_from_buffer(obj):
+ try:
+ view = memoryview(obj)
+ except TypeError:
+ # try to use legacy buffer protocol if 2.7, otherwise re-raise
+ if not PY3:
+ view = memoryview(buffer(obj))
+ warnings.warn("using old buffer interface to unpack %s; "
+ "this leads to unpacking errors if slicing is used and "
+ "will be removed in a future version" % type(obj),
+ RuntimeWarning)
+ else:
+ raise
+ if view.itemsize != 1:
+ raise ValueError("cannot unpack from multi-byte object")
+ return view
+
+
+def unpack(stream, **kwargs):
+ warnings.warn(
+ "Direct calling implementation's unpack() is deprecated, Use msgpack.unpack() or unpackb() instead.",
+ PendingDeprecationWarning)
+ data = stream.read()
+ return unpackb(data, **kwargs)
+
+
+def unpackb(packed, **kwargs):
+ """
+ Unpack an object from `packed`.
+
+ Raises `ExtraData` when `packed` contains extra bytes.
+ See :class:`Unpacker` for options.
+ """
+ unpacker = Unpacker(None, **kwargs)
+ unpacker.feed(packed)
+ try:
+ ret = unpacker._unpack()
+ except OutOfData:
+ raise UnpackValueError("Data is not enough.")
+ if unpacker._got_extradata():
+ raise ExtraData(ret, unpacker._get_extradata())
+ return ret
+
+
+class Unpacker(object):
+ """Streaming unpacker.
+
+ arguments:
+
+ :param file_like:
+ File-like object having `.read(n)` method.
+ If specified, unpacker reads serialized data from it and :meth:`feed()` is not usable.
+
+ :param int read_size:
+ Used as `file_like.read(read_size)`. (default: `min(16*1024, max_buffer_size)`)
+
+ :param bool use_list:
+ If true, unpack msgpack array to Python list.
+ Otherwise, unpack to Python tuple. (default: True)
+
+ :param bool raw:
+ If true, unpack msgpack raw to Python bytes (default).
+ Otherwise, unpack to Python str (or unicode on Python 2) by decoding
+ with UTF-8 encoding (recommended).
+ Currently, the default is true, but it will be changed to false in
+ near future. So you must specify it explicitly for keeping backward
+ compatibility.
+
+ *encoding* option which is deprecated overrides this option.
+
+ :param callable object_hook:
+ When specified, it should be callable.
+ Unpacker calls it with a dict argument after unpacking msgpack map.
+ (See also simplejson)
+
+ :param callable object_pairs_hook:
+ When specified, it should be callable.
+ Unpacker calls it with a list of key-value pairs after unpacking msgpack map.
+ (See also simplejson)
+
+ :param str encoding:
+ Encoding used for decoding msgpack raw.
+ If it is None (default), msgpack raw is deserialized to Python bytes.
+
+ :param str unicode_errors:
+ (deprecated) Used for decoding msgpack raw with *encoding*.
+ (default: `'strict'`)
+
+ :param int max_buffer_size:
+ Limits size of data waiting unpacked. 0 means system's INT_MAX (default).
+ Raises `BufferFull` exception when it is insufficient.
+ You should set this parameter when unpacking data from untrusted source.
+
+ :param int max_str_len:
+ Limits max length of str. (default: 2**31-1)
+
+ :param int max_bin_len:
+ Limits max length of bin. (default: 2**31-1)
+
+ :param int max_array_len:
+ Limits max length of array. (default: 2**31-1)
+
+ :param int max_map_len:
+ Limits max length of map. (default: 2**31-1)
+
+
+ example of streaming deserialize from file-like object::
+
+ unpacker = Unpacker(file_like, raw=False)
+ for o in unpacker:
+ process(o)
+
+ example of streaming deserialize from socket::
+
+ unpacker = Unpacker(raw=False)
+ while True:
+ buf = sock.recv(1024**2)
+ if not buf:
+ break
+ unpacker.feed(buf)
+ for o in unpacker:
+ process(o)
+ """
+
+ def __init__(self, file_like=None, read_size=0, use_list=True, raw=True,
+ object_hook=None, object_pairs_hook=None, list_hook=None,
+ encoding=None, unicode_errors=None, max_buffer_size=0,
+ ext_hook=ExtType,
+ max_str_len=2147483647, # 2**32-1
+ max_bin_len=2147483647,
+ max_array_len=2147483647,
+ max_map_len=2147483647,
+ max_ext_len=2147483647):
+
+ if encoding is not None:
+ warnings.warn(
+ "encoding is deprecated, Use raw=False instead.",
+ PendingDeprecationWarning)
+
+ if unicode_errors is None:
+ unicode_errors = 'strict'
+
+ if file_like is None:
+ self._feeding = True
+ else:
+ if not callable(file_like.read):
+ raise TypeError("`file_like.read` must be callable")
+ self.file_like = file_like
+ self._feeding = False
+
+ #: array of bytes fed.
+ self._buffer = bytearray()
+ #: Which position we currently reads
+ self._buff_i = 0
+
+ # When Unpacker is used as an iterable, between the calls to next(),
+ # the buffer is not "consumed" completely, for efficiency sake.
+ # Instead, it is done sloppily. To make sure we raise BufferFull at
+ # the correct moments, we have to keep track of how sloppy we were.
+ # Furthermore, when the buffer is incomplete (that is: in the case
+ # we raise an OutOfData) we need to rollback the buffer to the correct
+ # state, which _buf_checkpoint records.
+ self._buf_checkpoint = 0
+
+ self._max_buffer_size = max_buffer_size or 2**31-1
+ if read_size > self._max_buffer_size:
+ raise ValueError("read_size must be smaller than max_buffer_size")
+ self._read_size = read_size or min(self._max_buffer_size, 16*1024)
+ self._raw = bool(raw)
+ self._encoding = encoding
+ self._unicode_errors = unicode_errors
+ self._use_list = use_list
+ self._list_hook = list_hook
+ self._object_hook = object_hook
+ self._object_pairs_hook = object_pairs_hook
+ self._ext_hook = ext_hook
+ self._max_str_len = max_str_len
+ self._max_bin_len = max_bin_len
+ self._max_array_len = max_array_len
+ self._max_map_len = max_map_len
+ self._max_ext_len = max_ext_len
+ self._stream_offset = 0
+
+ if list_hook is not None and not callable(list_hook):
+ raise TypeError('`list_hook` is not callable')
+ if object_hook is not None and not callable(object_hook):
+ raise TypeError('`object_hook` is not callable')
+ if object_pairs_hook is not None and not callable(object_pairs_hook):
+ raise TypeError('`object_pairs_hook` is not callable')
+ if object_hook is not None and object_pairs_hook is not None:
+ raise TypeError("object_pairs_hook and object_hook are mutually "
+ "exclusive")
+ if not callable(ext_hook):
+ raise TypeError("`ext_hook` is not callable")
+
+ def feed(self, next_bytes):
+ assert self._feeding
+ view = _get_data_from_buffer(next_bytes)
+ if (len(self._buffer) - self._buff_i + len(view) > self._max_buffer_size):
+ raise BufferFull
+
+ # Strip buffer before checkpoint before reading file.
+ if self._buf_checkpoint > 0:
+ del self._buffer[:self._buf_checkpoint]
+ self._buff_i -= self._buf_checkpoint
+ self._buf_checkpoint = 0
+
+ self._buffer += view
+
+ def _consume(self):
+ """ Gets rid of the used parts of the buffer. """
+ self._stream_offset += self._buff_i - self._buf_checkpoint
+ self._buf_checkpoint = self._buff_i
+
+ def _got_extradata(self):
+ return self._buff_i < len(self._buffer)
+
+ def _get_extradata(self):
+ return self._buffer[self._buff_i:]
+
+ def read_bytes(self, n):
+ return self._read(n)
+
+ def _read(self, n):
+ # (int) -> bytearray
+ self._reserve(n)
+ i = self._buff_i
+ self._buff_i = i+n
+ return self._buffer[i:i+n]
+
+ def _reserve(self, n):
+ remain_bytes = len(self._buffer) - self._buff_i - n
+
+ # Fast path: buffer has n bytes already
+ if remain_bytes >= 0:
+ return
+
+ if self._feeding:
+ self._buff_i = self._buf_checkpoint
+ raise OutOfData
+
+ # Strip buffer before checkpoint before reading file.
+ if self._buf_checkpoint > 0:
+ del self._buffer[:self._buf_checkpoint]
+ self._buff_i -= self._buf_checkpoint
+ self._buf_checkpoint = 0
+
+ # Read from file
+ remain_bytes = -remain_bytes
+ while remain_bytes > 0:
+ to_read_bytes = max(self._read_size, remain_bytes)
+ read_data = self.file_like.read(to_read_bytes)
+ if not read_data:
+ break
+ assert isinstance(read_data, bytes)
+ self._buffer += read_data
+ remain_bytes -= len(read_data)
+
+ if len(self._buffer) < n + self._buff_i:
+ self._buff_i = 0 # rollback
+ raise OutOfData
+
+ def _read_header(self, execute=EX_CONSTRUCT):
+ typ = TYPE_IMMEDIATE
+ n = 0
+ obj = None
+ self._reserve(1)
+ b = self._buffer[self._buff_i]
+ self._buff_i += 1
+ if b & 0b10000000 == 0:
+ obj = b
+ elif b & 0b11100000 == 0b11100000:
+ obj = -1 - (b ^ 0xff)
+ elif b & 0b11100000 == 0b10100000:
+ n = b & 0b00011111
+ typ = TYPE_RAW
+ if n > self._max_str_len:
+ raise UnpackValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
+ obj = self._read(n)
+ elif b & 0b11110000 == 0b10010000:
+ n = b & 0b00001111
+ typ = TYPE_ARRAY
+ if n > self._max_array_len:
+ raise UnpackValueError("%s exceeds max_array_len(%s)", n, self._max_array_len)
+ elif b & 0b11110000 == 0b10000000:
+ n = b & 0b00001111
+ typ = TYPE_MAP
+ if n > self._max_map_len:
+ raise UnpackValueError("%s exceeds max_map_len(%s)", n, self._max_map_len)
+ elif b == 0xc0:
+ obj = None
+ elif b == 0xc2:
+ obj = False
+ elif b == 0xc3:
+ obj = True
+ elif b == 0xc4:
+ typ = TYPE_BIN
+ self._reserve(1)
+ n = self._buffer[self._buff_i]
+ self._buff_i += 1
+ if n > self._max_bin_len:
+ raise UnpackValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
+ obj = self._read(n)
+ elif b == 0xc5:
+ typ = TYPE_BIN
+ self._reserve(2)
+ n = struct.unpack_from(">H", self._buffer, self._buff_i)[0]
+ self._buff_i += 2
+ if n > self._max_bin_len:
+ raise UnpackValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
+ obj = self._read(n)
+ elif b == 0xc6:
+ typ = TYPE_BIN
+ self._reserve(4)
+ n = struct.unpack_from(">I", self._buffer, self._buff_i)[0]
+ self._buff_i += 4
+ if n > self._max_bin_len:
+ raise UnpackValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
+ obj = self._read(n)
+ elif b == 0xc7: # ext 8
+ typ = TYPE_EXT
+ self._reserve(2)
+ L, n = struct.unpack_from('Bb', self._buffer, self._buff_i)
+ self._buff_i += 2
+ if L > self._max_ext_len:
+ raise UnpackValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len))
+ obj = self._read(L)
+ elif b == 0xc8: # ext 16
+ typ = TYPE_EXT
+ self._reserve(3)
+ L, n = struct.unpack_from('>Hb', self._buffer, self._buff_i)
+ self._buff_i += 3
+ if L > self._max_ext_len:
+ raise UnpackValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len))
+ obj = self._read(L)
+ elif b == 0xc9: # ext 32
+ typ = TYPE_EXT
+ self._reserve(5)
+ L, n = struct.unpack_from('>Ib', self._buffer, self._buff_i)
+ self._buff_i += 5
+ if L > self._max_ext_len:
+ raise UnpackValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len))
+ obj = self._read(L)
+ elif b == 0xca:
+ self._reserve(4)
+ obj = struct.unpack_from(">f", self._buffer, self._buff_i)[0]
+ self._buff_i += 4
+ elif b == 0xcb:
+ self._reserve(8)
+ obj = struct.unpack_from(">d", self._buffer, self._buff_i)[0]
+ self._buff_i += 8
+ elif b == 0xcc:
+ self._reserve(1)
+ obj = self._buffer[self._buff_i]
+ self._buff_i += 1
+ elif b == 0xcd:
+ self._reserve(2)
+ obj = struct.unpack_from(">H", self._buffer, self._buff_i)[0]
+ self._buff_i += 2
+ elif b == 0xce:
+ self._reserve(4)
+ obj = struct.unpack_from(">I", self._buffer, self._buff_i)[0]
+ self._buff_i += 4
+ elif b == 0xcf:
+ self._reserve(8)
+ obj = struct.unpack_from(">Q", self._buffer, self._buff_i)[0]
+ self._buff_i += 8
+ elif b == 0xd0:
+ self._reserve(1)
+ obj = struct.unpack_from("b", self._buffer, self._buff_i)[0]
+ self._buff_i += 1
+ elif b == 0xd1:
+ self._reserve(2)
+ obj = struct.unpack_from(">h", self._buffer, self._buff_i)[0]
+ self._buff_i += 2
+ elif b == 0xd2:
+ self._reserve(4)
+ obj = struct.unpack_from(">i", self._buffer, self._buff_i)[0]
+ self._buff_i += 4
+ elif b == 0xd3:
+ self._reserve(8)
+ obj = struct.unpack_from(">q", self._buffer, self._buff_i)[0]
+ self._buff_i += 8
+ elif b == 0xd4: # fixext 1
+ typ = TYPE_EXT
+ if self._max_ext_len < 1:
+ raise UnpackValueError("%s exceeds max_ext_len(%s)" % (1, self._max_ext_len))
+ self._reserve(2)
+ n, obj = struct.unpack_from("b1s", self._buffer, self._buff_i)
+ self._buff_i += 2
+ elif b == 0xd5: # fixext 2
+ typ = TYPE_EXT
+ if self._max_ext_len < 2:
+ raise UnpackValueError("%s exceeds max_ext_len(%s)" % (2, self._max_ext_len))
+ self._reserve(3)
+ n, obj = struct.unpack_from("b2s", self._buffer, self._buff_i)
+ self._buff_i += 3
+ elif b == 0xd6: # fixext 4
+ typ = TYPE_EXT
+ if self._max_ext_len < 4:
+ raise UnpackValueError("%s exceeds max_ext_len(%s)" % (4, self._max_ext_len))
+ self._reserve(5)
+ n, obj = struct.unpack_from("b4s", self._buffer, self._buff_i)
+ self._buff_i += 5
+ elif b == 0xd7: # fixext 8
+ typ = TYPE_EXT
+ if self._max_ext_len < 8:
+ raise UnpackValueError("%s exceeds max_ext_len(%s)" % (8, self._max_ext_len))
+ self._reserve(9)
+ n, obj = struct.unpack_from("b8s", self._buffer, self._buff_i)
+ self._buff_i += 9
+ elif b == 0xd8: # fixext 16
+ typ = TYPE_EXT
+ if self._max_ext_len < 16:
+ raise UnpackValueError("%s exceeds max_ext_len(%s)" % (16, self._max_ext_len))
+ self._reserve(17)
+ n, obj = struct.unpack_from("b16s", self._buffer, self._buff_i)
+ self._buff_i += 17
+ elif b == 0xd9:
+ typ = TYPE_RAW
+ self._reserve(1)
+ n = self._buffer[self._buff_i]
+ self._buff_i += 1
+ if n > self._max_str_len:
+ raise UnpackValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
+ obj = self._read(n)
+ elif b == 0xda:
+ typ = TYPE_RAW
+ self._reserve(2)
+ n, = struct.unpack_from(">H", self._buffer, self._buff_i)
+ self._buff_i += 2
+ if n > self._max_str_len:
+ raise UnpackValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
+ obj = self._read(n)
+ elif b == 0xdb:
+ typ = TYPE_RAW
+ self._reserve(4)
+ n, = struct.unpack_from(">I", self._buffer, self._buff_i)
+ self._buff_i += 4
+ if n > self._max_str_len:
+ raise UnpackValueError("%s exceeds max_str_len(%s)", n, self._max_str_len)
+ obj = self._read(n)
+ elif b == 0xdc:
+ typ = TYPE_ARRAY
+ self._reserve(2)
+ n, = struct.unpack_from(">H", self._buffer, self._buff_i)
+ self._buff_i += 2
+ if n > self._max_array_len:
+ raise UnpackValueError("%s exceeds max_array_len(%s)", n, self._max_array_len)
+ elif b == 0xdd:
+ typ = TYPE_ARRAY
+ self._reserve(4)
+ n, = struct.unpack_from(">I", self._buffer, self._buff_i)
+ self._buff_i += 4
+ if n > self._max_array_len:
+ raise UnpackValueError("%s exceeds max_array_len(%s)", n, self._max_array_len)
+ elif b == 0xde:
+ self._reserve(2)
+ n, = struct.unpack_from(">H", self._buffer, self._buff_i)
+ self._buff_i += 2
+ if n > self._max_map_len:
+ raise UnpackValueError("%s exceeds max_map_len(%s)", n, self._max_map_len)
+ typ = TYPE_MAP
+ elif b == 0xdf:
+ self._reserve(4)
+ n, = struct.unpack_from(">I", self._buffer, self._buff_i)
+ self._buff_i += 4
+ if n > self._max_map_len:
+ raise UnpackValueError("%s exceeds max_map_len(%s)", n, self._max_map_len)
+ typ = TYPE_MAP
+ else:
+ raise UnpackValueError("Unknown header: 0x%x" % b)
+ return typ, n, obj
+
+ def _unpack(self, execute=EX_CONSTRUCT):
+ typ, n, obj = self._read_header(execute)
+
+ if execute == EX_READ_ARRAY_HEADER:
+ if typ != TYPE_ARRAY:
+ raise UnpackValueError("Expected array")
+ return n
+ if execute == EX_READ_MAP_HEADER:
+ if typ != TYPE_MAP:
+ raise UnpackValueError("Expected map")
+ return n
+ # TODO should we eliminate the recursion?
+ if typ == TYPE_ARRAY:
+ if execute == EX_SKIP:
+ for i in xrange(n):
+ # TODO check whether we need to call `list_hook`
+ self._unpack(EX_SKIP)
+ return
+ ret = newlist_hint(n)
+ for i in xrange(n):
+ ret.append(self._unpack(EX_CONSTRUCT))
+ if self._list_hook is not None:
+ ret = self._list_hook(ret)
+ # TODO is the interaction between `list_hook` and `use_list` ok?
+ return ret if self._use_list else tuple(ret)
+ if typ == TYPE_MAP:
+ if execute == EX_SKIP:
+ for i in xrange(n):
+ # TODO check whether we need to call hooks
+ self._unpack(EX_SKIP)
+ self._unpack(EX_SKIP)
+ return
+ if self._object_pairs_hook is not None:
+ ret = self._object_pairs_hook(
+ (self._unpack(EX_CONSTRUCT),
+ self._unpack(EX_CONSTRUCT))
+ for _ in xrange(n))
+ else:
+ ret = {}
+ for _ in xrange(n):
+ key = self._unpack(EX_CONSTRUCT)
+ ret[key] = self._unpack(EX_CONSTRUCT)
+ if self._object_hook is not None:
+ ret = self._object_hook(ret)
+ return ret
+ if execute == EX_SKIP:
+ return
+ if typ == TYPE_RAW:
+ if self._encoding is not None:
+ obj = obj.decode(self._encoding, self._unicode_errors)
+ elif self._raw:
+ obj = bytes(obj)
+ else:
+ obj = obj.decode('utf_8')
+ return obj
+ if typ == TYPE_EXT:
+ return self._ext_hook(n, bytes(obj))
+ if typ == TYPE_BIN:
+ return bytes(obj)
+ assert typ == TYPE_IMMEDIATE
+ return obj
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ try:
+ ret = self._unpack(EX_CONSTRUCT)
+ self._consume()
+ return ret
+ except OutOfData:
+ self._consume()
+ raise StopIteration
+
+ next = __next__
+
+ def skip(self, write_bytes=None):
+ self._unpack(EX_SKIP)
+ if write_bytes is not None:
+ warnings.warn("`write_bytes` option is deprecated. Use `.tell()` instead.", DeprecationWarning)
+ write_bytes(self._buffer[self._buf_checkpoint:self._buff_i])
+ self._consume()
+
+ def unpack(self, write_bytes=None):
+ ret = self._unpack(EX_CONSTRUCT)
+ if write_bytes is not None:
+ warnings.warn("`write_bytes` option is deprecated. Use `.tell()` instead.", DeprecationWarning)
+ write_bytes(self._buffer[self._buf_checkpoint:self._buff_i])
+ self._consume()
+ return ret
+
+ def read_array_header(self, write_bytes=None):
+ ret = self._unpack(EX_READ_ARRAY_HEADER)
+ if write_bytes is not None:
+ warnings.warn("`write_bytes` option is deprecated. Use `.tell()` instead.", DeprecationWarning)
+ write_bytes(self._buffer[self._buf_checkpoint:self._buff_i])
+ self._consume()
+ return ret
+
+ def read_map_header(self, write_bytes=None):
+ ret = self._unpack(EX_READ_MAP_HEADER)
+ if write_bytes is not None:
+ warnings.warn("`write_bytes` option is deprecated. Use `.tell()` instead.", DeprecationWarning)
+ write_bytes(self._buffer[self._buf_checkpoint:self._buff_i])
+ self._consume()
+ return ret
+
+ def tell(self):
+ return self._stream_offset
+
+
+class Packer(object):
+ """
+ MessagePack Packer
+
+ usage:
+
+ packer = Packer()
+ astream.write(packer.pack(a))
+ astream.write(packer.pack(b))
+
+ Packer's constructor has some keyword arguments:
+
+ :param callable default:
+ Convert user type to builtin type that Packer supports.
+ See also simplejson's document.
+
+ :param bool use_single_float:
+ Use single precision float type for float. (default: False)
+
+ :param bool autoreset:
+ Reset buffer after each pack and return its content as `bytes`. (default: True).
+ If set this to false, use `bytes()` to get content and `.reset()` to clear buffer.
+
+ :param bool use_bin_type:
+ Use bin type introduced in msgpack spec 2.0 for bytes.
+ It also enables str8 type for unicode.
+
+ :param bool strict_types:
+ If set to true, types will be checked to be exact. Derived classes
+ from serializeable types will not be serialized and will be
+ treated as unsupported type and forwarded to default.
+ Additionally tuples will not be serialized as lists.
+ This is useful when trying to implement accurate serialization
+ for python types.
+
+ :param str encoding:
+ (deprecated) Convert unicode to bytes with this encoding. (default: 'utf-8')
+
+ :param str unicode_errors:
+ Error handler for encoding unicode. (default: 'strict')
+ """
+ def __init__(self, default=None, encoding=None, unicode_errors=None,
+ use_single_float=False, autoreset=True, use_bin_type=False,
+ strict_types=False):
+ if encoding is None:
+ encoding = 'utf_8'
+ else:
+ warnings.warn(
+ "encoding is deprecated, Use raw=False instead.",
+ PendingDeprecationWarning)
+
+ if unicode_errors is None:
+ unicode_errors = 'strict'
+
+ self._strict_types = strict_types
+ self._use_float = use_single_float
+ self._autoreset = autoreset
+ self._use_bin_type = use_bin_type
+ self._encoding = encoding
+ self._unicode_errors = unicode_errors
+ self._buffer = StringIO()
+ if default is not None:
+ if not callable(default):
+ raise TypeError("default must be callable")
+ self._default = default
+
+ def _pack(self, obj, nest_limit=DEFAULT_RECURSE_LIMIT,
+ check=isinstance, check_type_strict=_check_type_strict):
+ default_used = False
+ if self._strict_types:
+ check = check_type_strict
+ list_types = list
+ else:
+ list_types = (list, tuple)
+ while True:
+ if nest_limit < 0:
+ raise PackValueError("recursion limit exceeded")
+ if obj is None:
+ return self._buffer.write(b"\xc0")
+ if check(obj, bool):
+ if obj:
+ return self._buffer.write(b"\xc3")
+ return self._buffer.write(b"\xc2")
+ if check(obj, int_types):
+ if 0 <= obj < 0x80:
+ return self._buffer.write(struct.pack("B", obj))
+ if -0x20 <= obj < 0:
+ return self._buffer.write(struct.pack("b", obj))
+ if 0x80 <= obj <= 0xff:
+ return self._buffer.write(struct.pack("BB", 0xcc, obj))
+ if -0x80 <= obj < 0:
+ return self._buffer.write(struct.pack(">Bb", 0xd0, obj))
+ if 0xff < obj <= 0xffff:
+ return self._buffer.write(struct.pack(">BH", 0xcd, obj))
+ if -0x8000 <= obj < -0x80:
+ return self._buffer.write(struct.pack(">Bh", 0xd1, obj))
+ if 0xffff < obj <= 0xffffffff:
+ return self._buffer.write(struct.pack(">BI", 0xce, obj))
+ if -0x80000000 <= obj < -0x8000:
+ return self._buffer.write(struct.pack(">Bi", 0xd2, obj))
+ if 0xffffffff < obj <= 0xffffffffffffffff:
+ return self._buffer.write(struct.pack(">BQ", 0xcf, obj))
+ if -0x8000000000000000 <= obj < -0x80000000:
+ return self._buffer.write(struct.pack(">Bq", 0xd3, obj))
+ if not default_used and self._default is not None:
+ obj = self._default(obj)
+ default_used = True
+ continue
+ raise PackOverflowError("Integer value out of range")
+ if check(obj, (bytes, bytearray)):
+ n = len(obj)
+ if n >= 2**32:
+ raise PackValueError("%s is too large" % type(obj).__name__)
+ self._pack_bin_header(n)
+ return self._buffer.write(obj)
+ if check(obj, Unicode):
+ if self._encoding is None:
+ raise TypeError(
+ "Can't encode unicode string: "
+ "no encoding is specified")
+ obj = obj.encode(self._encoding, self._unicode_errors)
+ n = len(obj)
+ if n >= 2**32:
+ raise PackValueError("String is too large")
+ self._pack_raw_header(n)
+ return self._buffer.write(obj)
+ if check(obj, memoryview):
+ n = len(obj) * obj.itemsize
+ if n >= 2**32:
+ raise PackValueError("Memoryview is too large")
+ self._pack_bin_header(n)
+ return self._buffer.write(obj)
+ if check(obj, float):
+ if self._use_float:
+ return self._buffer.write(struct.pack(">Bf", 0xca, obj))
+ return self._buffer.write(struct.pack(">Bd", 0xcb, obj))
+ if check(obj, ExtType):
+ code = obj.code
+ data = obj.data
+ assert isinstance(code, int)
+ assert isinstance(data, bytes)
+ L = len(data)
+ if L == 1:
+ self._buffer.write(b'\xd4')
+ elif L == 2:
+ self._buffer.write(b'\xd5')
+ elif L == 4:
+ self._buffer.write(b'\xd6')
+ elif L == 8:
+ self._buffer.write(b'\xd7')
+ elif L == 16:
+ self._buffer.write(b'\xd8')
+ elif L <= 0xff:
+ self._buffer.write(struct.pack(">BB", 0xc7, L))
+ elif L <= 0xffff:
+ self._buffer.write(struct.pack(">BH", 0xc8, L))
+ else:
+ self._buffer.write(struct.pack(">BI", 0xc9, L))
+ self._buffer.write(struct.pack("b", code))
+ self._buffer.write(data)
+ return
+ if check(obj, list_types):
+ n = len(obj)
+ self._pack_array_header(n)
+ for i in xrange(n):
+ self._pack(obj[i], nest_limit - 1)
+ return
+ if check(obj, dict):
+ return self._pack_map_pairs(len(obj), dict_iteritems(obj),
+ nest_limit - 1)
+ if not default_used and self._default is not None:
+ obj = self._default(obj)
+ default_used = 1
+ continue
+ raise TypeError("Cannot serialize %r" % (obj, ))
+
+ def pack(self, obj):
+ try:
+ self._pack(obj)
+ except:
+ self._buffer = StringIO() # force reset
+ raise
+ ret = self._buffer.getvalue()
+ if self._autoreset:
+ self._buffer = StringIO()
+ elif USING_STRINGBUILDER:
+ self._buffer = StringIO(ret)
+ return ret
+
+ def pack_map_pairs(self, pairs):
+ self._pack_map_pairs(len(pairs), pairs)
+ ret = self._buffer.getvalue()
+ if self._autoreset:
+ self._buffer = StringIO()
+ elif USING_STRINGBUILDER:
+ self._buffer = StringIO(ret)
+ return ret
+
+ def pack_array_header(self, n):
+ if n >= 2**32:
+ raise PackValueError
+ self._pack_array_header(n)
+ ret = self._buffer.getvalue()
+ if self._autoreset:
+ self._buffer = StringIO()
+ elif USING_STRINGBUILDER:
+ self._buffer = StringIO(ret)
+ return ret
+
+ def pack_map_header(self, n):
+ if n >= 2**32:
+ raise PackValueError
+ self._pack_map_header(n)
+ ret = self._buffer.getvalue()
+ if self._autoreset:
+ self._buffer = StringIO()
+ elif USING_STRINGBUILDER:
+ self._buffer = StringIO(ret)
+ return ret
+
+ def pack_ext_type(self, typecode, data):
+ if not isinstance(typecode, int):
+ raise TypeError("typecode must have int type.")
+ if not 0 <= typecode <= 127:
+ raise ValueError("typecode should be 0-127")
+ if not isinstance(data, bytes):
+ raise TypeError("data must have bytes type")
+ L = len(data)
+ if L > 0xffffffff:
+ raise PackValueError("Too large data")
+ if L == 1:
+ self._buffer.write(b'\xd4')
+ elif L == 2:
+ self._buffer.write(b'\xd5')
+ elif L == 4:
+ self._buffer.write(b'\xd6')
+ elif L == 8:
+ self._buffer.write(b'\xd7')
+ elif L == 16:
+ self._buffer.write(b'\xd8')
+ elif L <= 0xff:
+ self._buffer.write(b'\xc7' + struct.pack('B', L))
+ elif L <= 0xffff:
+ self._buffer.write(b'\xc8' + struct.pack('>H', L))
+ else:
+ self._buffer.write(b'\xc9' + struct.pack('>I', L))
+ self._buffer.write(struct.pack('B', typecode))
+ self._buffer.write(data)
+
+ def _pack_array_header(self, n):
+ if n <= 0x0f:
+ return self._buffer.write(struct.pack('B', 0x90 + n))
+ if n <= 0xffff:
+ return self._buffer.write(struct.pack(">BH", 0xdc, n))
+ if n <= 0xffffffff:
+ return self._buffer.write(struct.pack(">BI", 0xdd, n))
+ raise PackValueError("Array is too large")
+
+ def _pack_map_header(self, n):
+ if n <= 0x0f:
+ return self._buffer.write(struct.pack('B', 0x80 + n))
+ if n <= 0xffff:
+ return self._buffer.write(struct.pack(">BH", 0xde, n))
+ if n <= 0xffffffff:
+ return self._buffer.write(struct.pack(">BI", 0xdf, n))
+ raise PackValueError("Dict is too large")
+
+ def _pack_map_pairs(self, n, pairs, nest_limit=DEFAULT_RECURSE_LIMIT):
+ self._pack_map_header(n)
+ for (k, v) in pairs:
+ self._pack(k, nest_limit - 1)
+ self._pack(v, nest_limit - 1)
+
+ def _pack_raw_header(self, n):
+ if n <= 0x1f:
+ self._buffer.write(struct.pack('B', 0xa0 + n))
+ elif self._use_bin_type and n <= 0xff:
+ self._buffer.write(struct.pack('>BB', 0xd9, n))
+ elif n <= 0xffff:
+ self._buffer.write(struct.pack(">BH", 0xda, n))
+ elif n <= 0xffffffff:
+ self._buffer.write(struct.pack(">BI", 0xdb, n))
+ else:
+ raise PackValueError('Raw is too large')
+
+ def _pack_bin_header(self, n):
+ if not self._use_bin_type:
+ return self._pack_raw_header(n)
+ elif n <= 0xff:
+ return self._buffer.write(struct.pack('>BB', 0xc4, n))
+ elif n <= 0xffff:
+ return self._buffer.write(struct.pack(">BH", 0xc5, n))
+ elif n <= 0xffffffff:
+ return self._buffer.write(struct.pack(">BI", 0xc6, n))
+ else:
+ raise PackValueError('Bin is too large')
+
+ def bytes(self):
+ return self._buffer.getvalue()
+
+ def reset(self):
+ self._buffer = StringIO()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/numpy/LICENSE.txt b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/numpy/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8e6cc62a6c811680dde2cbf559bce9963e717457
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/numpy/LICENSE.txt
@@ -0,0 +1,940 @@
+Copyright (c) 2005-2019, NumPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+
+ * Neither the name of the NumPy Developers nor the names of any
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+The NumPy repository and source distributions bundle several libraries that are
+compatibly licensed. We list these here.
+
+Name: Numpydoc
+Files: doc/sphinxext/numpydoc/*
+License: 2-clause BSD
+ For details, see doc/sphinxext/LICENSE.txt
+
+Name: scipy-sphinx-theme
+Files: doc/scipy-sphinx-theme/*
+License: 3-clause BSD, PSF and Apache 2.0
+ For details, see doc/scipy-sphinx-theme/LICENSE.txt
+
+Name: lapack-lite
+Files: numpy/linalg/lapack_lite/*
+License: 3-clause BSD
+ For details, see numpy/linalg/lapack_lite/LICENSE.txt
+
+Name: tempita
+Files: tools/npy_tempita/*
+License: BSD derived
+ For details, see tools/npy_tempita/license.txt
+
+Name: dragon4
+Files: numpy/core/src/multiarray/dragon4.c
+License: One of a kind
+ For license text, see numpy/core/src/multiarray/dragon4.c
+
+----
+
+This binary distribution of NumPy also bundles the following software:
+
+
+Name: OpenBLAS
+Files: .libs/libopenb*.so
+Description: bundled as a dynamically linked library
+Availability: https://github.com/xianyi/OpenBLAS/
+License: 3-clause BSD
+ Copyright (c) 2011-2014, The OpenBLAS Project
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ 1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the
+ distribution.
+ 3. Neither the name of the OpenBLAS project nor the names of
+ its contributors may be used to endorse or promote products
+ derived from this software without specific prior written
+ permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Name: LAPACK
+Files: .libs/libopenb*.so
+Description: bundled in OpenBLAS
+Availability: https://github.com/xianyi/OpenBLAS/
+License 3-clause BSD
+ Copyright (c) 1992-2013 The University of Tennessee and The University
+ of Tennessee Research Foundation. All rights
+ reserved.
+ Copyright (c) 2000-2013 The University of California Berkeley. All
+ rights reserved.
+ Copyright (c) 2006-2013 The University of Colorado Denver. All rights
+ reserved.
+
+ $COPYRIGHT$
+
+ Additional copyrights may follow
+
+ $HEADER$
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are
+ met:
+
+ - Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer listed
+ in this license in the documentation and/or other materials
+ provided with the distribution.
+
+ - Neither the name of the copyright holders nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+ The copyright holders provide no reassurances that the source code
+ provided does not infringe any patent, copyright, or any other
+ intellectual property rights of third parties. The copyright holders
+ disclaim any liability to any recipient for claims brought against
+ recipient by any third party for infringement of that parties
+ intellectual property rights.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Name: GCC runtime library
+Files: .libs/libgfortran*.so
+Description: dynamically linked to files compiled with gcc
+Availability: https://gcc.gnu.org/viewcvs/gcc/
+License: GPLv3 + runtime exception
+ Copyright (C) 2002-2017 Free Software Foundation, Inc.
+
+ Libgfortran is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ Libgfortran is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ Under Section 7 of GPL version 3, you are granted additional
+ permissions described in the GCC Runtime Library Exception, version
+ 3.1, as published by the Free Software Foundation.
+
+ You should have received a copy of the GNU General Public License and
+ a copy of the GCC Runtime Library Exception along with this program;
+ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+
+ Copyright (C)
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see Copyright (C)
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+.
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/numpy/matlib.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/numpy/matlib.py
new file mode 100644
index 0000000000000000000000000000000000000000..004e5f0c82ea841e13d2280854192e856ca91dc8
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/numpy/matlib.py
@@ -0,0 +1,363 @@
+from __future__ import division, absolute_import, print_function
+
+import numpy as np
+from numpy.matrixlib.defmatrix import matrix, asmatrix
+# need * as we're copying the numpy namespace
+from numpy import *
+
+__version__ = np.__version__
+
+__all__ = np.__all__[:] # copy numpy namespace
+__all__ += ['rand', 'randn', 'repmat']
+
+def empty(shape, dtype=None, order='C'):
+ """Return a new matrix of given shape and type, without initializing entries.
+
+ Parameters
+ ----------
+ shape : int or tuple of int
+ Shape of the empty matrix.
+ dtype : data-type, optional
+ Desired output data-type.
+ order : {'C', 'F'}, optional
+ Whether to store multi-dimensional data in row-major
+ (C-style) or column-major (Fortran-style) order in
+ memory.
+
+ See Also
+ --------
+ empty_like, zeros
+
+ Notes
+ -----
+ `empty`, unlike `zeros`, does not set the matrix values to zero,
+ and may therefore be marginally faster. On the other hand, it requires
+ the user to manually set all the values in the array, and should be
+ used with caution.
+
+ Examples
+ --------
+ >>> import numpy.matlib
+ >>> np.matlib.empty((2, 2)) # filled with random data
+ matrix([[ 6.76425276e-320, 9.79033856e-307],
+ [ 7.39337286e-309, 3.22135945e-309]]) #random
+ >>> np.matlib.empty((2, 2), dtype=int)
+ matrix([[ 6600475, 0],
+ [ 6586976, 22740995]]) #random
+
+ """
+ return ndarray.__new__(matrix, shape, dtype, order=order)
+
+def ones(shape, dtype=None, order='C'):
+ """
+ Matrix of ones.
+
+ Return a matrix of given shape and type, filled with ones.
+
+ Parameters
+ ----------
+ shape : {sequence of ints, int}
+ Shape of the matrix
+ dtype : data-type, optional
+ The desired data-type for the matrix, default is np.float64.
+ order : {'C', 'F'}, optional
+ Whether to store matrix in C- or Fortran-contiguous order,
+ default is 'C'.
+
+ Returns
+ -------
+ out : matrix
+ Matrix of ones of given shape, dtype, and order.
+
+ See Also
+ --------
+ ones : Array of ones.
+ matlib.zeros : Zero matrix.
+
+ Notes
+ -----
+ If `shape` has length one i.e. ``(N,)``, or is a scalar ``N``,
+ `out` becomes a single row matrix of shape ``(1,N)``.
+
+ Examples
+ --------
+ >>> np.matlib.ones((2,3))
+ matrix([[ 1., 1., 1.],
+ [ 1., 1., 1.]])
+
+ >>> np.matlib.ones(2)
+ matrix([[ 1., 1.]])
+
+ """
+ a = ndarray.__new__(matrix, shape, dtype, order=order)
+ a.fill(1)
+ return a
+
+def zeros(shape, dtype=None, order='C'):
+ """
+ Return a matrix of given shape and type, filled with zeros.
+
+ Parameters
+ ----------
+ shape : int or sequence of ints
+ Shape of the matrix
+ dtype : data-type, optional
+ The desired data-type for the matrix, default is float.
+ order : {'C', 'F'}, optional
+ Whether to store the result in C- or Fortran-contiguous order,
+ default is 'C'.
+
+ Returns
+ -------
+ out : matrix
+ Zero matrix of given shape, dtype, and order.
+
+ See Also
+ --------
+ numpy.zeros : Equivalent array function.
+ matlib.ones : Return a matrix of ones.
+
+ Notes
+ -----
+ If `shape` has length one i.e. ``(N,)``, or is a scalar ``N``,
+ `out` becomes a single row matrix of shape ``(1,N)``.
+
+ Examples
+ --------
+ >>> import numpy.matlib
+ >>> np.matlib.zeros((2, 3))
+ matrix([[ 0., 0., 0.],
+ [ 0., 0., 0.]])
+
+ >>> np.matlib.zeros(2)
+ matrix([[ 0., 0.]])
+
+ """
+ a = ndarray.__new__(matrix, shape, dtype, order=order)
+ a.fill(0)
+ return a
+
+def identity(n,dtype=None):
+ """
+ Returns the square identity matrix of given size.
+
+ Parameters
+ ----------
+ n : int
+ Size of the returned identity matrix.
+ dtype : data-type, optional
+ Data-type of the output. Defaults to ``float``.
+
+ Returns
+ -------
+ out : matrix
+ `n` x `n` matrix with its main diagonal set to one,
+ and all other elements zero.
+
+ See Also
+ --------
+ numpy.identity : Equivalent array function.
+ matlib.eye : More general matrix identity function.
+
+ Examples
+ --------
+ >>> import numpy.matlib
+ >>> np.matlib.identity(3, dtype=int)
+ matrix([[1, 0, 0],
+ [0, 1, 0],
+ [0, 0, 1]])
+
+ """
+ a = array([1]+n*[0], dtype=dtype)
+ b = empty((n, n), dtype=dtype)
+ b.flat = a
+ return b
+
+def eye(n,M=None, k=0, dtype=float, order='C'):
+ """
+ Return a matrix with ones on the diagonal and zeros elsewhere.
+
+ Parameters
+ ----------
+ n : int
+ Number of rows in the output.
+ M : int, optional
+ Number of columns in the output, defaults to `n`.
+ k : int, optional
+ Index of the diagonal: 0 refers to the main diagonal,
+ a positive value refers to an upper diagonal,
+ and a negative value to a lower diagonal.
+ dtype : dtype, optional
+ Data-type of the returned matrix.
+ order : {'C', 'F'}, optional
+ Whether the output should be stored in row-major (C-style) or
+ column-major (Fortran-style) order in memory.
+
+ .. versionadded:: 1.14.0
+
+ Returns
+ -------
+ I : matrix
+ A `n` x `M` matrix where all elements are equal to zero,
+ except for the `k`-th diagonal, whose values are equal to one.
+
+ See Also
+ --------
+ numpy.eye : Equivalent array function.
+ identity : Square identity matrix.
+
+ Examples
+ --------
+ >>> import numpy.matlib
+ >>> np.matlib.eye(3, k=1, dtype=float)
+ matrix([[ 0., 1., 0.],
+ [ 0., 0., 1.],
+ [ 0., 0., 0.]])
+
+ """
+ return asmatrix(np.eye(n, M=M, k=k, dtype=dtype, order=order))
+
+def rand(*args):
+ """
+ Return a matrix of random values with given shape.
+
+ Create a matrix of the given shape and propagate it with
+ random samples from a uniform distribution over ``[0, 1)``.
+
+ Parameters
+ ----------
+ \\*args : Arguments
+ Shape of the output.
+ If given as N integers, each integer specifies the size of one
+ dimension.
+ If given as a tuple, this tuple gives the complete shape.
+
+ Returns
+ -------
+ out : ndarray
+ The matrix of random values with shape given by `\\*args`.
+
+ See Also
+ --------
+ randn, numpy.random.rand
+
+ Examples
+ --------
+ >>> import numpy.matlib
+ >>> np.matlib.rand(2, 3)
+ matrix([[ 0.68340382, 0.67926887, 0.83271405],
+ [ 0.00793551, 0.20468222, 0.95253525]]) #random
+ >>> np.matlib.rand((2, 3))
+ matrix([[ 0.84682055, 0.73626594, 0.11308016],
+ [ 0.85429008, 0.3294825 , 0.89139555]]) #random
+
+ If the first argument is a tuple, other arguments are ignored:
+
+ >>> np.matlib.rand((2, 3), 4)
+ matrix([[ 0.46898646, 0.15163588, 0.95188261],
+ [ 0.59208621, 0.09561818, 0.00583606]]) #random
+
+ """
+ if isinstance(args[0], tuple):
+ args = args[0]
+ return asmatrix(np.random.rand(*args))
+
+def randn(*args):
+ """
+ Return a random matrix with data from the "standard normal" distribution.
+
+ `randn` generates a matrix filled with random floats sampled from a
+ univariate "normal" (Gaussian) distribution of mean 0 and variance 1.
+
+ Parameters
+ ----------
+ \\*args : Arguments
+ Shape of the output.
+ If given as N integers, each integer specifies the size of one
+ dimension. If given as a tuple, this tuple gives the complete shape.
+
+ Returns
+ -------
+ Z : matrix of floats
+ A matrix of floating-point samples drawn from the standard normal
+ distribution.
+
+ See Also
+ --------
+ rand, random.randn
+
+ Notes
+ -----
+ For random samples from :math:`N(\\mu, \\sigma^2)`, use:
+
+ ``sigma * np.matlib.randn(...) + mu``
+
+ Examples
+ --------
+ >>> import numpy.matlib
+ >>> np.matlib.randn(1)
+ matrix([[-0.09542833]]) #random
+ >>> np.matlib.randn(1, 2, 3)
+ matrix([[ 0.16198284, 0.0194571 , 0.18312985],
+ [-0.7509172 , 1.61055 , 0.45298599]]) #random
+
+ Two-by-four matrix of samples from :math:`N(3, 6.25)`:
+
+ >>> 2.5 * np.matlib.randn((2, 4)) + 3
+ matrix([[ 4.74085004, 8.89381862, 4.09042411, 4.83721922],
+ [ 7.52373709, 5.07933944, -2.64043543, 0.45610557]]) #random
+
+ """
+ if isinstance(args[0], tuple):
+ args = args[0]
+ return asmatrix(np.random.randn(*args))
+
+def repmat(a, m, n):
+ """
+ Repeat a 0-D to 2-D array or matrix MxN times.
+
+ Parameters
+ ----------
+ a : array_like
+ The array or matrix to be repeated.
+ m, n : int
+ The number of times `a` is repeated along the first and second axes.
+
+ Returns
+ -------
+ out : ndarray
+ The result of repeating `a`.
+
+ Examples
+ --------
+ >>> import numpy.matlib
+ >>> a0 = np.array(1)
+ >>> np.matlib.repmat(a0, 2, 3)
+ array([[1, 1, 1],
+ [1, 1, 1]])
+
+ >>> a1 = np.arange(4)
+ >>> np.matlib.repmat(a1, 2, 2)
+ array([[0, 1, 2, 3, 0, 1, 2, 3],
+ [0, 1, 2, 3, 0, 1, 2, 3]])
+
+ >>> a2 = np.asmatrix(np.arange(6).reshape(2, 3))
+ >>> np.matlib.repmat(a2, 2, 3)
+ matrix([[0, 1, 2, 0, 1, 2, 0, 1, 2],
+ [3, 4, 5, 3, 4, 5, 3, 4, 5],
+ [0, 1, 2, 0, 1, 2, 0, 1, 2],
+ [3, 4, 5, 3, 4, 5, 3, 4, 5]])
+
+ """
+ a = asanyarray(a)
+ ndim = a.ndim
+ if ndim == 0:
+ origrows, origcols = (1, 1)
+ elif ndim == 1:
+ origrows, origcols = (1, a.shape[0])
+ else:
+ origrows, origcols = a.shape
+ rows = origrows * m
+ cols = origcols * n
+ c = a.reshape(1, a.size).repeat(m, 0).reshape(rows, origcols).repeat(n, 0)
+ return c.reshape(rows, cols)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/numpy/setup.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/numpy/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ccdaeea5e94830655424f4a5c642f8aea9e2f95
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/numpy/setup.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+from __future__ import division, print_function
+
+
+def configuration(parent_package='',top_path=None):
+ from numpy.distutils.misc_util import Configuration
+ config = Configuration('numpy', parent_package, top_path)
+
+ config.add_subpackage('compat')
+ config.add_subpackage('core')
+ config.add_subpackage('distutils')
+ config.add_subpackage('doc')
+ config.add_subpackage('f2py')
+ config.add_subpackage('fft')
+ config.add_subpackage('lib')
+ config.add_subpackage('linalg')
+ config.add_subpackage('ma')
+ config.add_subpackage('matrixlib')
+ config.add_subpackage('polynomial')
+ config.add_subpackage('random')
+ config.add_subpackage('testing')
+ config.add_data_dir('doc')
+ config.add_data_dir('tests')
+ config.make_config_py() # installs __config__.py
+ return config
+
+if __name__ == '__main__':
+ print('This is the wrong setup.py file to run')
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/numpy/version.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/numpy/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea4af9f8fe4ea2c4c4584e0a79551eb89c81e4f4
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/numpy/version.py
@@ -0,0 +1,12 @@
+
+# THIS FILE IS GENERATED FROM NUMPY SETUP.PY
+#
+# To compare versions robustly, use `numpy.lib.NumpyVersion`
+short_version = '1.16.5'
+version = '1.16.5'
+full_version = '1.16.5'
+git_revision = 'cbdc3b7477aa0b497406bbb2df1025bed290f3cb'
+release = True
+
+if not release:
+ version = full_version
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/INSTALLER b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/LICENSE b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..6f62d44e4ef733c0e713afcd2371fed7f2b3de67
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/LICENSE
@@ -0,0 +1,3 @@
+This software is made available under the terms of *either* of the licenses
+found in LICENSE.APACHE or LICENSE.BSD. Contributions to this software is made
+under the terms of *both* these licenses.
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/LICENSE.APACHE b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/LICENSE.APACHE
new file mode 100644
index 0000000000000000000000000000000000000000..4947287f7b5ccb5d1e8b7b2d3aa5d89f322c160d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/LICENSE.APACHE
@@ -0,0 +1,177 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
\ No newline at end of file
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/LICENSE.BSD b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/LICENSE.BSD
new file mode 100644
index 0000000000000000000000000000000000000000..42ce7b75c92fb01a3f6ed17eea363f756b7da582
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/LICENSE.BSD
@@ -0,0 +1,23 @@
+Copyright (c) Donald Stufft and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/METADATA b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..94bf64f0db3509abacdd74e654161cacf4c23c32
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/METADATA
@@ -0,0 +1,311 @@
+Metadata-Version: 2.1
+Name: packaging
+Version: 19.1
+Summary: Core utilities for Python packages
+Home-page: https://github.com/pypa/packaging
+Author: Donald Stufft and individual contributors
+Author-email: donald@stufft.io
+License: BSD or Apache License, Version 2.0
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
+Requires-Dist: attrs
+Requires-Dist: pyparsing (>=2.0.2)
+Requires-Dist: six
+
+packaging
+=========
+
+Core utilities for Python packages.
+
+The ``packaging`` project includes the following: version handling, specifiers,
+markers, requirements, tags, utilities.
+
+Documentation
+-------------
+
+The `documentation`_ provides information and the API for the following:
+
+- Version Handling
+- Specifiers
+- Markers
+- Requirements
+- Tags
+- Utilities
+
+Installation
+------------
+
+Use ``pip`` to install these utilities::
+
+ pip install packaging
+
+Discussion
+----------
+
+If you run into bugs, you can file them in our `issue tracker`_.
+
+You can also join ``#pypa`` on Freenode to ask questions or get involved.
+
+
+.. _`documentation`: https://packaging.pypa.io/
+.. _`issue tracker`: https://github.com/pypa/packaging/issues
+
+
+Code of Conduct
+---------------
+
+Everyone interacting in the packaging project's codebases, issue trackers, chat
+rooms, and mailing lists is expected to follow the `PyPA Code of Conduct`_.
+
+.. _PyPA Code of Conduct: https://www.pypa.io/en/latest/code-of-conduct/
+
+Contributing
+------------
+
+The ``CONTRIBUTING.rst`` file outlines how to contribute to this project as
+well as how to report a potential security issue. The documentation for this
+project also covers information about `project development`_ and `security`_.
+
+.. _`project development`: https://packaging.pypa.io/en/latest/development/
+.. _`security`: https://packaging.pypa.io/en/latest/security/
+
+Project History
+---------------
+
+Please review the ``CHANGELOG.rst`` file or the `Changelog documentation`_ for
+recent changes and project history.
+
+.. _`Changelog documentation`: https://packaging.pypa.io/en/latest/changelog/
+
+Changelog
+---------
+
+19.1 - 2019-07-30
+~~~~~~~~~~~~~~~~~
+
+* Add the ``packaging.tags`` module. (`#156 `__)
+
+* Correctly handle two-digit versions in ``python_version`` (`#119 `__)
+
+
+19.0 - 2019-01-20
+~~~~~~~~~~~~~~~~~
+
+* Fix string representation of PEP 508 direct URL requirements with markers.
+
+* Better handling of file URLs
+
+ This allows for using ``file:///absolute/path``, which was previously
+ prevented due to the missing ``netloc``.
+
+ This allows for all file URLs that ``urlunparse`` turns back into the
+ original URL to be valid.
+
+
+18.0 - 2018-09-26
+~~~~~~~~~~~~~~~~~
+
+* Improve error messages when invalid requirements are given. (`#129 `__)
+
+
+17.1 - 2017-02-28
+~~~~~~~~~~~~~~~~~
+
+* Fix ``utils.canonicalize_version`` when supplying non PEP 440 versions.
+
+
+17.0 - 2017-02-28
+~~~~~~~~~~~~~~~~~
+
+* Drop support for python 2.6, 3.2, and 3.3.
+
+* Define minimal pyparsing version to 2.0.2 (`#91 `__).
+
+* Add ``epoch``, ``release``, ``pre``, ``dev``, and ``post`` attributes to
+ ``Version`` and ``LegacyVersion`` (`#34 `__).
+
+* Add ``Version().is_devrelease`` and ``LegacyVersion().is_devrelease`` to
+ make it easy to determine if a release is a development release.
+
+* Add ``utils.canonicalize_version`` to canonicalize version strings or
+ ``Version`` instances (`#121 `__).
+
+
+16.8 - 2016-10-29
+~~~~~~~~~~~~~~~~~
+
+* Fix markers that utilize ``in`` so that they render correctly.
+
+* Fix an erroneous test on Python RC releases.
+
+
+16.7 - 2016-04-23
+~~~~~~~~~~~~~~~~~
+
+* Add support for the deprecated ``python_implementation`` marker which was
+ an undocumented setuptools marker in addition to the newer markers.
+
+
+16.6 - 2016-03-29
+~~~~~~~~~~~~~~~~~
+
+* Add support for the deprecated, PEP 345 environment markers in addition to
+ the newer markers.
+
+
+16.5 - 2016-02-26
+~~~~~~~~~~~~~~~~~
+
+* Fix a regression in parsing requirements with whitespaces between the comma
+ separators.
+
+
+16.4 - 2016-02-22
+~~~~~~~~~~~~~~~~~
+
+* Fix a regression in parsing requirements like ``foo (==4)``.
+
+
+16.3 - 2016-02-21
+~~~~~~~~~~~~~~~~~
+
+* Fix a bug where ``packaging.requirements:Requirement`` was overly strict when
+ matching legacy requirements.
+
+
+16.2 - 2016-02-09
+~~~~~~~~~~~~~~~~~
+
+* Add a function that implements the name canonicalization from PEP 503.
+
+
+16.1 - 2016-02-07
+~~~~~~~~~~~~~~~~~
+
+* Implement requirement specifiers from PEP 508.
+
+
+16.0 - 2016-01-19
+~~~~~~~~~~~~~~~~~
+
+* Relicense so that packaging is available under *either* the Apache License,
+ Version 2.0 or a 2 Clause BSD license.
+
+* Support installation of packaging when only distutils is available.
+
+* Fix ``==`` comparison when there is a prefix and a local version in play.
+ (`#41 `__).
+
+* Implement environment markers from PEP 508.
+
+
+15.3 - 2015-08-01
+~~~~~~~~~~~~~~~~~
+
+* Normalize post-release spellings for rev/r prefixes. `#35 `__
+
+
+15.2 - 2015-05-13
+~~~~~~~~~~~~~~~~~
+
+* Fix an error where the arbitary specifier (``===``) was not correctly
+ allowing pre-releases when it was being used.
+
+* Expose the specifier and version parts through properties on the
+ ``Specifier`` classes.
+
+* Allow iterating over the ``SpecifierSet`` to get access to all of the
+ ``Specifier`` instances.
+
+* Allow testing if a version is contained within a specifier via the ``in``
+ operator.
+
+
+15.1 - 2015-04-13
+~~~~~~~~~~~~~~~~~
+
+* Fix a logic error that was causing inconsistent answers about whether or not
+ a pre-release was contained within a ``SpecifierSet`` or not.
+
+
+15.0 - 2015-01-02
+~~~~~~~~~~~~~~~~~
+
+* Add ``Version().is_postrelease`` and ``LegacyVersion().is_postrelease`` to
+ make it easy to determine if a release is a post release.
+
+* Add ``Version().base_version`` and ``LegacyVersion().base_version`` to make
+ it easy to get the public version without any pre or post release markers.
+
+* Support the update to PEP 440 which removed the implied ``!=V.*`` when using
+ either ``>V`` or ``V`` or ````) operator.
+
+
+14.3 - 2014-11-19
+~~~~~~~~~~~~~~~~~
+
+* **BACKWARDS INCOMPATIBLE** Refactor specifier support so that it can sanely
+ handle legacy specifiers as well as PEP 440 specifiers.
+
+* **BACKWARDS INCOMPATIBLE** Move the specifier support out of
+ ``packaging.version`` into ``packaging.specifiers``.
+
+
+14.2 - 2014-09-10
+~~~~~~~~~~~~~~~~~
+
+* Add prerelease support to ``Specifier``.
+* Remove the ability to do ``item in Specifier()`` and replace it with
+ ``Specifier().contains(item)`` in order to allow flags that signal if a
+ prerelease should be accepted or not.
+* Add a method ``Specifier().filter()`` which will take an iterable and returns
+ an iterable with items that do not match the specifier filtered out.
+
+
+14.1 - 2014-09-08
+~~~~~~~~~~~~~~~~~
+
+* Allow ``LegacyVersion`` and ``Version`` to be sorted together.
+* Add ``packaging.version.parse()`` to enable easily parsing a version string
+ as either a ``Version`` or a ``LegacyVersion`` depending on it's PEP 440
+ validity.
+
+
+14.0 - 2014-09-05
+~~~~~~~~~~~~~~~~~
+
+* Initial release.
+
+
+.. _`master`: https://github.com/pypa/packaging/
+
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/RECORD b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..c7332f4e5f162d93b1826587cb0c941fe127f61b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/RECORD
@@ -0,0 +1,28 @@
+packaging-19.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+packaging-19.1.dist-info/LICENSE,sha256=ytHvW9NA1z4HS6YU0m996spceUDD2MNIUuZcSQlobEg,197
+packaging-19.1.dist-info/LICENSE.APACHE,sha256=DOwG4OVfvD3FzuT8qbYH9my49OTbzzs8ATWU3RVnMuk,10173
+packaging-19.1.dist-info/LICENSE.BSD,sha256=tw5-m3QvHMb5SLNMFqo5_-zpQZY2S8iP8NIYDwAo-sU,1344
+packaging-19.1.dist-info/METADATA,sha256=HzhzUKr1FDDfuP7VS2deRTDsyG93r9NrXKnT6M45Iq0,8477
+packaging-19.1.dist-info/RECORD,,
+packaging-19.1.dist-info/WHEEL,sha256=h_aVn5OB2IERUjMbi2pucmR_zzWJtk303YXvhh60NJ8,110
+packaging-19.1.dist-info/top_level.txt,sha256=zFdHrhWnPslzsiP455HutQsqPB6v0KCtNUMtUtrefDw,10
+packaging/__about__.py,sha256=Wy9hJ3fA43-f3WQk3UL_4-AY21eExyL6pXx-vlJqpos,744
+packaging/__about__.pyc,,
+packaging/__init__.py,sha256=6enbp5XgRfjBjsI9-bn00HjHf5TH21PDMOKkJW8xw-w,562
+packaging/__init__.pyc,,
+packaging/_compat.py,sha256=Ugdm-qcneSchW25JrtMIKgUxfEEBcCAz6WrEeXeqz9o,865
+packaging/_compat.pyc,,
+packaging/_structures.py,sha256=pVd90XcXRGwpZRB_qdFuVEibhCHpX_bL5zYr9-N0mc8,1416
+packaging/_structures.pyc,,
+packaging/markers.py,sha256=g6HRCklg_3YQg6lHcMsctcwaI6KCw3AFsNGOmV2z6mI,8214
+packaging/markers.pyc,,
+packaging/requirements.py,sha256=1BnLnuPsAIpbYRi0jBemiD26Z7ukCzpIy-zP_0pv_4k,4652
+packaging/requirements.pyc,,
+packaging/specifiers.py,sha256=0ZzQpcUnvrQ6LjR-mQRLzMr8G6hdRv-mY0VSf_amFtI,27778
+packaging/specifiers.pyc,,
+packaging/tags.py,sha256=D3NN0sx2HyXk9obyauLUZRE_OUHN1SPJAemD9cv9RJ0,11529
+packaging/tags.pyc,,
+packaging/utils.py,sha256=VaTC0Ei7zO2xl9ARiWmz2YFLFt89PuuhLbAlXMyAGms,1520
+packaging/utils.pyc,,
+packaging/version.py,sha256=Npdwnb8OHedj_2L86yiUqscujb7w_i5gmSK1PhOAFzg,11978
+packaging/version.pyc,,
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/WHEEL b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..78e6f69d1d8fe46bdd9dd3bbfdee02380aaede3b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.33.4)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/top_level.txt b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..748809f75c471b0336136cdfe160463a52952339
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging-19.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+packaging
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging/__about__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging/__about__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d35b23a63477a5fbd39a0472d9b8f09ae59e0d2d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging/__about__.py
@@ -0,0 +1,27 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+__all__ = [
+ "__title__",
+ "__summary__",
+ "__uri__",
+ "__version__",
+ "__author__",
+ "__email__",
+ "__license__",
+ "__copyright__",
+]
+
+__title__ = "packaging"
+__summary__ = "Core utilities for Python packages"
+__uri__ = "https://github.com/pypa/packaging"
+
+__version__ = "19.1"
+
+__author__ = "Donald Stufft and individual contributors"
+__email__ = "donald@stufft.io"
+
+__license__ = "BSD or Apache License, Version 2.0"
+__copyright__ = "Copyright 2014-2019 %s" % __author__
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0cf67df5245be16a020ca048832e180f7ce8661
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging/__init__.py
@@ -0,0 +1,26 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+from .__about__ import (
+ __author__,
+ __copyright__,
+ __email__,
+ __license__,
+ __summary__,
+ __title__,
+ __uri__,
+ __version__,
+)
+
+__all__ = [
+ "__title__",
+ "__summary__",
+ "__uri__",
+ "__version__",
+ "__author__",
+ "__email__",
+ "__license__",
+ "__copyright__",
+]
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging/_compat.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging/_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..25da473c196855ad59a6d2d785ef1ddef49795be
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging/_compat.py
@@ -0,0 +1,31 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import sys
+
+
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+
+# flake8: noqa
+
+if PY3:
+ string_types = (str,)
+else:
+ string_types = (basestring,)
+
+
+def with_metaclass(meta, *bases):
+ """
+ Create a base class with a metaclass.
+ """
+ # This requires a bit of explanation: the basic idea is to make a dummy
+ # metaclass for one level of class instantiation that replaces itself with
+ # the actual metaclass.
+ class metaclass(meta):
+ def __new__(cls, name, this_bases, d):
+ return meta(name, bases, d)
+
+ return type.__new__(metaclass, "temporary_class", (), {})
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging/_structures.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging/_structures.py
new file mode 100644
index 0000000000000000000000000000000000000000..68dcca634d8e3f0081bad2f9ae5e653a2942db68
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/packaging/_structures.py
@@ -0,0 +1,68 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+
+class Infinity(object):
+ def __repr__(self):
+ return "Infinity"
+
+ def __hash__(self):
+ return hash(repr(self))
+
+ def __lt__(self, other):
+ return False
+
+ def __le__(self, other):
+ return False
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__)
+
+ def __ne__(self, other):
+ return not isinstance(other, self.__class__)
+
+ def __gt__(self, other):
+ return True
+
+ def __ge__(self, other):
+ return True
+
+ def __neg__(self):
+ return NegativeInfinity
+
+
+Infinity = Infinity()
+
+
+class NegativeInfinity(object):
+ def __repr__(self):
+ return "-Infinity"
+
+ def __hash__(self):
+ return hash(repr(self))
+
+ def __lt__(self, other):
+ return True
+
+ def __le__(self, other):
+ return True
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__)
+
+ def __ne__(self, other):
+ return not isinstance(other, self.__class__)
+
+ def __gt__(self, other):
+ return False
+
+ def __ge__(self, other):
+ return False
+
+ def __neg__(self):
+ return Infinity
+
+
+NegativeInfinity = NegativeInfinity()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/INSTALLER b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/METADATA b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..a1e9ec057d7070800f513666af118c2429561e72
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/METADATA
@@ -0,0 +1,90 @@
+Metadata-Version: 2.1
+Name: pandas
+Version: 0.24.2
+Summary: Powerful data structures for data analysis, time series, and statistics
+Home-page: http://pandas.pydata.org
+Maintainer: The PyData Development Team
+Maintainer-email: pydata@googlegroups.com
+License: BSD
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Cython
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*
+Requires-Dist: python-dateutil (>=2.5.0)
+Requires-Dist: pytz (>=2011k)
+Requires-Dist: numpy (>=1.12.0)
+
+**pandas** is a Python package providing fast, flexible, and expressive data
+structures designed to make working with structured (tabular, multidimensional,
+potentially heterogeneous) and time series data both easy and intuitive. It
+aims to be the fundamental high-level building block for doing practical,
+**real world** data analysis in Python. Additionally, it has the broader goal
+of becoming **the most powerful and flexible open source data analysis /
+manipulation tool available in any language**. It is already well on its way
+toward this goal.
+
+pandas is well suited for many different kinds of data:
+
+ - Tabular data with heterogeneously-typed columns, as in an SQL table or
+ Excel spreadsheet
+ - Ordered and unordered (not necessarily fixed-frequency) time series data.
+ - Arbitrary matrix data (homogeneously typed or heterogeneous) with row and
+ column labels
+ - Any other form of observational / statistical data sets. The data actually
+ need not be labeled at all to be placed into a pandas data structure
+
+The two primary data structures of pandas, Series (1-dimensional) and DataFrame
+(2-dimensional), handle the vast majority of typical use cases in finance,
+statistics, social science, and many areas of engineering. For R users,
+DataFrame provides everything that R's ``data.frame`` provides and much
+more. pandas is built on top of `NumPy `__ and is
+intended to integrate well within a scientific computing environment with many
+other 3rd party libraries.
+
+Here are just a few of the things that pandas does well:
+
+ - Easy handling of **missing data** (represented as NaN) in floating point as
+ well as non-floating point data
+ - Size mutability: columns can be **inserted and deleted** from DataFrame and
+ higher dimensional objects
+ - Automatic and explicit **data alignment**: objects can be explicitly
+ aligned to a set of labels, or the user can simply ignore the labels and
+ let `Series`, `DataFrame`, etc. automatically align the data for you in
+ computations
+ - Powerful, flexible **group by** functionality to perform
+ split-apply-combine operations on data sets, for both aggregating and
+ transforming data
+ - Make it **easy to convert** ragged, differently-indexed data in other
+ Python and NumPy data structures into DataFrame objects
+ - Intelligent label-based **slicing**, **fancy indexing**, and **subsetting**
+ of large data sets
+ - Intuitive **merging** and **joining** data sets
+ - Flexible **reshaping** and pivoting of data sets
+ - **Hierarchical** labeling of axes (possible to have multiple labels per
+ tick)
+ - Robust IO tools for loading data from **flat files** (CSV and delimited),
+ Excel files, databases, and saving / loading data from the ultrafast **HDF5
+ format**
+ - **Time series**-specific functionality: date range generation and frequency
+ conversion, moving window statistics, moving window linear regressions,
+ date shifting and lagging, etc.
+
+Many of these principles are here to address the shortcomings frequently
+experienced using other languages / scientific research environments. For data
+scientists, working with data is typically divided into multiple stages:
+munging and cleaning data, analyzing / modeling it, then organizing the results
+of the analysis into a form suitable for plotting or tabular display. pandas is
+the ideal tool for all of these tasks.
+
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/RECORD b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..9662ce7f57b0a4a5fe2b51e6bbd23c0ecb9e603e
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/RECORD
@@ -0,0 +1,1533 @@
+pandas-0.24.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pandas-0.24.2.dist-info/METADATA,sha256=lPpTNsNXyRqskCUupEw-8DoGNe7lfm_AKp9FQ90iiOM,4474
+pandas-0.24.2.dist-info/RECORD,,
+pandas-0.24.2.dist-info/WHEEL,sha256=M5Ujap42zjfAFnpJOoFU72TFHuBKh-JF0Rqu5vZhkVE,110
+pandas-0.24.2.dist-info/top_level.txt,sha256=_W-EYOwsRjyO7fqakAIX0J3vvvCqzSWZ8z5RtnXISDw,7
+pandas/__init__.py,sha256=f789PrEpnDzVjzudxaosYDBLMAjAHKxYI_ay0fWXT1I,3973
+pandas/__init__.pyc,,
+pandas/_libs/__init__.py,sha256=Obovf0KPR6QyZnCWOL6XqP1iol8RfiXR7Di-wuLjnmI,128
+pandas/_libs/__init__.pyc,,
+pandas/_libs/algos.so,sha256=4rN2n88wfHmXpMXZNrMPa1c3B_Ki8-O-L7vX4mqWBfo,1782304
+pandas/_libs/groupby.so,sha256=_FvCC3L5LLrJhJYF-XYeZqxv2ktULIvlL-dbhNJwBfg,787904
+pandas/_libs/hashing.so,sha256=zeHsJlWwyUxRnr8ZWmgO8sghvYIqfZg7PJ5zhNO9svI,194272
+pandas/_libs/hashtable.so,sha256=nhTgZySrklgypGPZC8LTTYkfnrXy6cG9b1DIKFzWRlM,628928
+pandas/_libs/index.so,sha256=tt3EcLMHxeEPtqbns0GF0z12k9KktiqkKDg0PaIbZ-0,709312
+pandas/_libs/indexing.so,sha256=GOHQsqOO6oefNm7nS2KtIfH0swz9m3D2KfJRzMQgCWU,38136
+pandas/_libs/internals.so,sha256=KeV2yv_CtAyKuopBI6H5UrBerquB6FE1LFN4KX5-CB4,286752
+pandas/_libs/interval.so,sha256=PXMqTdzXrRntJ1huV7EXa5NKb2Juk6O9CPOj5xJhqrM,2228544
+pandas/_libs/join.so,sha256=DOEft95qUeVKZSKM1U10UWyfvw-0kgtEr-CajBzeQdQ,2657504
+pandas/_libs/json.so,sha256=HWtbaJ7O51XWAQ3ENytlZKFWNoC70DAAIbtdAI_5MRo,90824
+pandas/_libs/lib.so,sha256=Hp-SEok9PuyJsnDtbPi0KhQ6ZyZ9lmn6K3Vc-5YL8kE,483456
+pandas/_libs/missing.so,sha256=UuZiWabI7fa6zzPA34uEb_ocLIQi_YdWrPU3ACJRp8w,98816
+pandas/_libs/ops.so,sha256=lo3Di6atJIuq5t-jbR0xScC65HEA2JzrgWKgPGw5AJg,235552
+pandas/_libs/parsers.so,sha256=VkEBrq09exJO24XCyfBRPXJBI3hF0vkcJOpkQsgWYE0,602496
+pandas/_libs/properties.so,sha256=lCD8c9zXKZmMu1qcBntN7P_-WGlVimiYNRtfb5c36hg,60280
+pandas/_libs/reduction.so,sha256=Hr-UNbPpOYXzQ22mnPvp0T7buLjvv-_mAqBqYdvaIVE,277056
+pandas/_libs/reshape.so,sha256=t1RmsuXywADa8XUelIna5CwJ-wcfPmsy6Zyp-JOOxgc,263872
+pandas/_libs/skiplist.so,sha256=92qVoQfGwaBsOrdW-OsgVcpGKsUgRndR6MWhSQx1FzU,84792
+pandas/_libs/sparse.so,sha256=JbCb4XXsiBswOQXrkdq7zr2XZxh8iPEf0-eWP34Hz2U,927136
+pandas/_libs/testing.so,sha256=XgpfeB-uQCwbgcoiWqoiQP-cBCdsiNKWAumvFfWHijM,76824
+pandas/_libs/tslib.so,sha256=P7cODO963BLygP3f4wuTUyAhFFyGREO7lKf7OqkuusE,344224
+pandas/_libs/tslibs/__init__.py,sha256=XRTugOSj--eZjLe7USBurNwaSaj2cSy_UXthqP-m9SI,378
+pandas/_libs/tslibs/__init__.pyc,,
+pandas/_libs/tslibs/ccalendar.so,sha256=hlA9Cv4Vvo6_WKVhE_dm7eIIiCTqt9zpjKWBczwdTrw,57624
+pandas/_libs/tslibs/conversion.so,sha256=q60iSDHkDOwGma3BihyjQD-nTfLMB9SK8eDxQgYOSjU,457024
+pandas/_libs/tslibs/fields.so,sha256=QNgpdwzz6lTAYc0FYM3uyt6tOu_4BoC81AA29zVnHAg,283392
+pandas/_libs/tslibs/frequencies.so,sha256=yMCnaLWrWJF2FRtD1P6tVH3MbchoHR9o23DhT-YH6VA,136768
+pandas/_libs/tslibs/nattype.so,sha256=JQz5UfGF2OxtMU2C3s65w7EC4jYDhDZj9npZneV9yUo,173976
+pandas/_libs/tslibs/np_datetime.so,sha256=uSncXGVaKfgokZY0Gia-_i_ot-34R54w56jZkegap0U,49672
+pandas/_libs/tslibs/offsets.so,sha256=1IeVmMBRONoKULc4CkkT4QH_57Z6daKaNLJLCTC9tDY,453920
+pandas/_libs/tslibs/parsing.so,sha256=Z2AH2uWc3J4ajaTnUlmA2lwipIuwhZ_QnP2vlKb0Rl4,389728
+pandas/_libs/tslibs/period.so,sha256=bKblE0ovi0LtT3sSJ-3cMzZffPde8w0eIxej_bQpaNk,494208
+pandas/_libs/tslibs/resolution.so,sha256=qnPMqLfk-vx2D84LunxUivG6qox8yI4LJyfx08t4F_w,290944
+pandas/_libs/tslibs/strptime.so,sha256=CyWEfAQGTwQI3YGkVHp5ewdG-fC-OOKEaMNYzXfZdO0,447040
+pandas/_libs/tslibs/timedeltas.so,sha256=oCNRCv2w9NuBNu1am7GbKoJfuA51kgaWzPYfQSQthIw,510688
+pandas/_libs/tslibs/timestamps.so,sha256=MKciJ4zom8w0cdeuw8jWIlcDsUtXeFgRHLcRH_GeJ-c,544704
+pandas/_libs/tslibs/timezones.so,sha256=T0NWTYBw_Qhybe1hhY2KCChX7SVov6h-vm_TNlaJ4gE,254208
+pandas/_libs/window.so,sha256=ETPhxYl_VjIpnA5esYZ8OvosndHeYbHxd8kYEDX-O60,793592
+pandas/_libs/writers.so,sha256=XVCfwWLDuyuL_AutEtnZf88wtZjpdydmSeIEXO5LQ9E,231296
+pandas/_version.py,sha256=ZPQIXXfuGtEPS3SEUI4eoZbvGbvKHU7-ZtTSFb4gwRk,546
+pandas/_version.pyc,,
+pandas/api/__init__.py,sha256=-alwyQlpzKgAMm_2PSzSBUVDHkK4ol7ZwmRUJFVTuqg,67
+pandas/api/__init__.pyc,,
+pandas/api/extensions/__init__.py,sha256=kL-0rAcMMhiiLZlMKHMJOQD5XUzrmEYnyVF1F2HdR-g,495
+pandas/api/extensions/__init__.pyc,,
+pandas/api/types/__init__.py,sha256=YxfrhHzcy-AzvN3gkstQmHqo8qfVihDoDEAybcRp3XU,414
+pandas/api/types/__init__.pyc,,
+pandas/arrays/__init__.py,sha256=HEd_pJVZwFpA_mtSb9124mqylKVenAY_2OQ2E9gMTVk,427
+pandas/arrays/__init__.pyc,,
+pandas/compat/__init__.py,sha256=Y9k8PP5UoalVoRwqLgx5S8_0SEicrSq1DhAgdpEV1-U,12974
+pandas/compat/__init__.pyc,,
+pandas/compat/chainmap.py,sha256=iUBBayAMnkeGajbMrVzS3gXnNhTUOhQo1SkDghPzHuc,715
+pandas/compat/chainmap.pyc,,
+pandas/compat/chainmap_impl.py,sha256=OdLUjcFo3UmqevwUqsotZWMqvmC0USQckcCk0Q2CB64,4700
+pandas/compat/chainmap_impl.pyc,,
+pandas/compat/numpy/__init__.py,sha256=a2knalo07g4hQCHjzUzTj0ZhWMdBtB5K69CZFY8uF3U,2158
+pandas/compat/numpy/__init__.pyc,,
+pandas/compat/numpy/function.py,sha256=miilNXtK2gJpPsFiilKepFoS6te2UkcyUIRXQChxp04,14251
+pandas/compat/numpy/function.pyc,,
+pandas/compat/pickle_compat.py,sha256=lionA2hgliD1Xt0APut4Q2ZzzFpU_1baPDghyWCF--c,6718
+pandas/compat/pickle_compat.pyc,,
+pandas/conftest.py,sha256=UIeJaAnpETd-U3kHjTkT0kcTQMj-uWiWYhzoyCxJkN4,18042
+pandas/conftest.pyc,,
+pandas/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/__init__.pyc,,
+pandas/core/accessor.py,sha256=KxGvV8loZpqoSIR46xYPiZKTyYwUFqABgMXTzdMHxoE,8531
+pandas/core/accessor.pyc,,
+pandas/core/algorithms.py,sha256=KE9uBuNyHOB0ZFVqGlyftel-SCx-BhueuW1a849K9H4,60783
+pandas/core/algorithms.pyc,,
+pandas/core/api.py,sha256=LZ9bnOOR8ilcG4IcTIUHjLAejmCSOqOULUiqoCKEh0I,2245
+pandas/core/api.pyc,,
+pandas/core/apply.py,sha256=EYZ91NR8hSU1d9Z2fm06GyHlwI0zbPbh1_90zckMmrs,12763
+pandas/core/apply.pyc,,
+pandas/core/arrays/__init__.py,sha256=-R-dOIczYSPx0UF-bqfTAfm7wEnkA8Kh0MYjCpR7Xho,553
+pandas/core/arrays/__init__.pyc,,
+pandas/core/arrays/_ranges.py,sha256=nR9WTf0ok3rOFVhzCwTG5OnkdTosIcq-OUZtwPFomW8,6894
+pandas/core/arrays/_ranges.pyc,,
+pandas/core/arrays/array_.py,sha256=vVgVGuOp87Ra24Aqux8D5UtpaWMx-iY3LFxz6c9z0jk,9365
+pandas/core/arrays/array_.pyc,,
+pandas/core/arrays/base.py,sha256=AVwgXLHFe-6TR58IPc7XVINR1hNqKRz5cIwNTH-TfFY,38965
+pandas/core/arrays/base.pyc,,
+pandas/core/arrays/categorical.py,sha256=SNnlrdwLRbSIHa8SJeURpcSZTO21zga-ThSjsuhLQyU,92357
+pandas/core/arrays/categorical.pyc,,
+pandas/core/arrays/datetimelike.py,sha256=6TNVAXeEn4COfcIMA-11WKa2_Efym-fwkZnlY-r8K9s,54430
+pandas/core/arrays/datetimelike.pyc,,
+pandas/core/arrays/datetimes.py,sha256=BodSGQlp4K6-kivSujQiWmdDxIRxQIzYb-eMXeRiWk8,76876
+pandas/core/arrays/datetimes.pyc,,
+pandas/core/arrays/integer.py,sha256=wSn9gd6SfkiMXe7McV2thiJOxifYCsDhAJffBL5g1hI,21104
+pandas/core/arrays/integer.pyc,,
+pandas/core/arrays/interval.py,sha256=p4A8lAxOkgBaskUngnnxBYD5LgBjhnFw2tFHQWqM30c,38353
+pandas/core/arrays/interval.pyc,,
+pandas/core/arrays/numpy_.py,sha256=ewkN4lR1488jOkxVRedLP8DIX3EtnEvT8dDyWIhFlx4,15461
+pandas/core/arrays/numpy_.pyc,,
+pandas/core/arrays/period.py,sha256=sUxy9DmKSgqydVmXoo4ZSejeeW7F339HAoXRgfNHwFU,31494
+pandas/core/arrays/period.pyc,,
+pandas/core/arrays/sparse.py,sha256=ZGvNMhN6J0_C04F3h4QInAsbmp8FsATnoyv4_CHKfxA,66808
+pandas/core/arrays/sparse.pyc,,
+pandas/core/arrays/timedeltas.py,sha256=yyEbedcBtzLJpkzK3HIYzgNXXnKUU2na4YIjzVy2L-Q,37283
+pandas/core/arrays/timedeltas.pyc,,
+pandas/core/base.py,sha256=pRfP_3Yy6t2h7A2hlKIDnyWvMm8i8P-lMDcSLsG2Lxc,49277
+pandas/core/base.pyc,,
+pandas/core/categorical.py,sha256=PJSp52txr4XqppD1PO50Mo1wMX-wZgrY2pYZT2s_AxM,272
+pandas/core/categorical.pyc,,
+pandas/core/common.py,sha256=jByOB3M92mVYZgN-WguLKFcngzYOe_j_miWscp8bE_Y,12515
+pandas/core/common.pyc,,
+pandas/core/computation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/computation/__init__.pyc,,
+pandas/core/computation/align.py,sha256=gT3VDsnToLgMleN6f9t0msDQmsQEgqpG533ZZWaXkZk,5610
+pandas/core/computation/align.pyc,,
+pandas/core/computation/api.py,sha256=Q_hRn-f6r45ph3AJqKmXlodzOufxNc9masH1q-DbSjE,62
+pandas/core/computation/api.pyc,,
+pandas/core/computation/check.py,sha256=UUBhwHY2X3L4IKGznAJuhy3h_C6H2Bb7UTTAnUYXujM,722
+pandas/core/computation/check.pyc,,
+pandas/core/computation/common.py,sha256=_2BE9hhW_Loxm-OlZ9MjPXdOn_Iwby52ECeTdc3Dh1A,654
+pandas/core/computation/common.pyc,,
+pandas/core/computation/engines.py,sha256=hzj9sUIPdY5on5j7oc_PJrg5F3OPOkcO7MdctODhE70,3796
+pandas/core/computation/engines.pyc,,
+pandas/core/computation/eval.py,sha256=ukL1Q5JtDSXWj90KjUQ2O74YwW0BkQJoygSh9jEmDHQ,12419
+pandas/core/computation/eval.pyc,,
+pandas/core/computation/expr.py,sha256=lKRuH7VAHVGfyOP0MOQteJsHZriWxHz-Uqn4_735GCw,26830
+pandas/core/computation/expr.pyc,,
+pandas/core/computation/expressions.py,sha256=A1KevJ90I2TkyYKR7CWg1wEecW5h1lOm2dz0_qOyFmU,7107
+pandas/core/computation/expressions.pyc,,
+pandas/core/computation/ops.py,sha256=S4NOOM7n13AEc5JhDiohFgsIvcqvnV2Jj6pJfNzYukE,16315
+pandas/core/computation/ops.pyc,,
+pandas/core/computation/pytables.py,sha256=N2zXwGnnLXMNvYfgFpg26HFMbvdPXJmNXFa5RFSXSY8,19388
+pandas/core/computation/pytables.pyc,,
+pandas/core/computation/scope.py,sha256=y8nB84CDpQEZuoP95Xr2ZPGilMJCcOmyixfBcTT8Fdc,9213
+pandas/core/computation/scope.pyc,,
+pandas/core/config.py,sha256=hjorVv--_WShatWvJvqk0QLLyamSF2siIbh0hGIHOPU,23287
+pandas/core/config.pyc,,
+pandas/core/config_init.py,sha256=Pxu7xNpI45ZR1tmOm_42j1fwemOmg6RMr7czJHcV2ME,17143
+pandas/core/config_init.pyc,,
+pandas/core/dtypes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/dtypes/__init__.pyc,,
+pandas/core/dtypes/api.py,sha256=0-rOxt3BqIJIk0a1Y4R-wI63n8dhYJY97rhJ1US3Yyk,797
+pandas/core/dtypes/api.pyc,,
+pandas/core/dtypes/base.py,sha256=Q7jCbO6tjMa78dZZT-OJHfq69oPMXxo9vBjJpX1cSeY,8746
+pandas/core/dtypes/base.pyc,,
+pandas/core/dtypes/cast.py,sha256=CeX4n_FvWD7VjW9tmfVyN0IKi22a7eVzToaHjv83_5Y,43577
+pandas/core/dtypes/cast.pyc,,
+pandas/core/dtypes/common.py,sha256=-LOG_OfnpC_YUTnMgABeljA4UryG4DsT0ViJsM7M678,53111
+pandas/core/dtypes/common.pyc,,
+pandas/core/dtypes/concat.py,sha256=H6Vy3Ttv9B7rj1oL3tvVSPXc7D8DqgyemZ5WlD2yMNE,19564
+pandas/core/dtypes/concat.pyc,,
+pandas/core/dtypes/dtypes.py,sha256=YY7uUifBtBwvFN2F4EOKAnt5FULr27vth_TooLi9Ycs,31586
+pandas/core/dtypes/dtypes.pyc,,
+pandas/core/dtypes/generic.py,sha256=sOkMm8m3B4M8t_avFI75UMUCGjwFda0G8PYmSFNs_1M,4437
+pandas/core/dtypes/generic.pyc,,
+pandas/core/dtypes/inference.py,sha256=74WWHO67wHoKsi2gB5E6DTAEQxGzErYNxFoIVt0hryg,10256
+pandas/core/dtypes/inference.pyc,,
+pandas/core/dtypes/missing.py,sha256=iYBRjnZRZQIEr7pzhHisgReM89X55lrnUh9u2RHMldU,15114
+pandas/core/dtypes/missing.pyc,,
+pandas/core/frame.py,sha256=VJrVJ-ljR3xCc7rQg0hmMTMS6TKhtc6SHnxVf4nyBkU,292992
+pandas/core/frame.pyc,,
+pandas/core/generic.py,sha256=oAxcTDSfI42DF-1WPsjPtTwCxIcWFhKg1Wb5coQz3to,387253
+pandas/core/generic.pyc,,
+pandas/core/groupby/__init__.py,sha256=YKMq3IOZCwsyLyZSmphdI6HTXAvAsOPbNF2ZkWmHiy4,231
+pandas/core/groupby/__init__.pyc,,
+pandas/core/groupby/base.py,sha256=Gxe2fshVcq6TfcEvFFASGemiTXtEsv_xGdiy8DWrwY4,4921
+pandas/core/groupby/base.pyc,,
+pandas/core/groupby/categorical.py,sha256=45-bT9LXYygPfrFrW-UvBB22F20xpAkrFperBF58gT0,3121
+pandas/core/groupby/categorical.pyc,,
+pandas/core/groupby/generic.py,sha256=v0ybAYxqL9fUonXmJ8XhqQ4B3ur3A5MCNGxiaQlDo1I,59340
+pandas/core/groupby/generic.pyc,,
+pandas/core/groupby/groupby.py,sha256=RF42vJhPEA0HJOWz2u7GiMX9WsIyKwQ8Zxg_LNOW03E,68506
+pandas/core/groupby/groupby.pyc,,
+pandas/core/groupby/grouper.py,sha256=Kt0ws5eJ9t2smJA5w2qpTT_uBWAFeNLG5GkkUC0UKUU,22487
+pandas/core/groupby/grouper.pyc,,
+pandas/core/groupby/ops.py,sha256=WNzNCK_YJ6G4QpW3ilkaEZK1yyxAZuEfjjguohATKSw,29244
+pandas/core/groupby/ops.pyc,,
+pandas/core/index.py,sha256=XDe5U6ale2FuR4S8fzzMXca2a89fak2CbqAHp0ycRlA,101
+pandas/core/index.pyc,,
+pandas/core/indexes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/indexes/__init__.pyc,,
+pandas/core/indexes/accessors.py,sha256=0G2olmcaLN1UkIvu-PAztIs3Pvrb5H6oy7bFEGx0A5s,10922
+pandas/core/indexes/accessors.pyc,,
+pandas/core/indexes/api.py,sha256=9c_qtNdceaXm5nBySGMYBKey2NrAGTdFlebXj6MqyKA,8238
+pandas/core/indexes/api.pyc,,
+pandas/core/indexes/base.py,sha256=zoLub9506oYULUhQrHk-VYFXDYzpF6jYGebHaXFC9uQ,184668
+pandas/core/indexes/base.pyc,,
+pandas/core/indexes/category.py,sha256=roHiZgLXK_6Cs1q7yKgkmWk413z9jLi8otoyZ_V6OhU,29581
+pandas/core/indexes/category.pyc,,
+pandas/core/indexes/datetimelike.py,sha256=uQS7D9NCVAmH_nDJU6Rvx75NVF1xpNpvA5Cdcdxr838,23530
+pandas/core/indexes/datetimelike.pyc,,
+pandas/core/indexes/datetimes.py,sha256=j0f8zwJkqykmRN4r1CSW0THIcmhh9l1GmZkFdC0-ZOI,61038
+pandas/core/indexes/datetimes.pyc,,
+pandas/core/indexes/frozen.py,sha256=V3X5ZSkYuonrX7pY-cqzBtD73Ksj9JLtDhTiAfSVNCY,5915
+pandas/core/indexes/frozen.pyc,,
+pandas/core/indexes/interval.py,sha256=poUsJk_PGlYJRFvxzyTkdUH-_NpHRusuvxuxdzxq3jY,45940
+pandas/core/indexes/interval.pyc,,
+pandas/core/indexes/multi.py,sha256=gtaYksR8I5_zFoJe-OEsEJolll5PiBjR-bsSMJDuUKU,113443
+pandas/core/indexes/multi.pyc,,
+pandas/core/indexes/numeric.py,sha256=JsnloDYkcZvmmi7wwhAIpqVl0VNBP9Fio0yRau31mUY,14865
+pandas/core/indexes/numeric.pyc,,
+pandas/core/indexes/period.py,sha256=5f0Pkrssq-5jid0uOdQll_QW02LAyzF9EPZqTktEZK8,35129
+pandas/core/indexes/period.pyc,,
+pandas/core/indexes/range.py,sha256=QrCpjErwkNsb3DTPMSMpQpjKtUNQNL26JVUsWJk_aH4,24595
+pandas/core/indexes/range.pyc,,
+pandas/core/indexes/timedeltas.py,sha256=PkM52dVOhAmP6T2ehXVfg2xZ7HEu4mFAJzvbUpn4BsE,27500
+pandas/core/indexes/timedeltas.pyc,,
+pandas/core/indexing.py,sha256=vV6DTpiF63Oy_Ia48s1VSF6CleO0QzaiQs08UpL_EEo,92100
+pandas/core/indexing.pyc,,
+pandas/core/internals/__init__.py,sha256=fKv49zqzTHjsHJya1TRvEy6CSlyH29PvLJKCYgr1cs0,630
+pandas/core/internals/__init__.pyc,,
+pandas/core/internals/arrays.py,sha256=Vpqz3wzhOp2WPxaJ9E0ZfaLXFIiWphbRdyqeyB_sS-c,1447
+pandas/core/internals/arrays.pyc,,
+pandas/core/internals/blocks.py,sha256=G4aT-52wIpHv7bqyhU8xC_OQWtDXJkprKtJz6oK07rM,115017
+pandas/core/internals/blocks.pyc,,
+pandas/core/internals/concat.py,sha256=qaEQixayZg8BR0_Ht1IIER4cwTgPXfzy8jF3V7XBuDA,17144
+pandas/core/internals/concat.pyc,,
+pandas/core/internals/construction.py,sha256=SwozVdmHgakDjPMJMXGk_z_T99wyFAOQ_KLu2pgXTO4,25188
+pandas/core/internals/construction.pyc,,
+pandas/core/internals/managers.py,sha256=52uuyoJnwZo4x7saQfVvrBW5XFADoXiSFlY5mHugsOs,68634
+pandas/core/internals/managers.pyc,,
+pandas/core/missing.py,sha256=p3jzYy_RWuc2nU8ABbaB4MVWtgkpH9pEhqiKRmx3hR8,24349
+pandas/core/missing.pyc,,
+pandas/core/nanops.py,sha256=zjCLz4soU5pluyiLPWBa-pluoirqA5ykfFZKkx6YMb4,36951
+pandas/core/nanops.pyc,,
+pandas/core/ops.py,sha256=Ce7_oR2no6InnglusbXYK7EUXn3Cgahn_O9p5YAWGNw,73735
+pandas/core/ops.pyc,,
+pandas/core/panel.py,sha256=gciVQht8Wn5cuPLlXYyhhC4kRYSuIis-wAhQmzA-M0w,55911
+pandas/core/panel.pyc,,
+pandas/core/resample.py,sha256=yQ0koVaiZ4ubZRKAh6sjntx2KjK0VXdu6qv5JX6UR0U,58001
+pandas/core/resample.pyc,,
+pandas/core/reshape/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/reshape/__init__.pyc,,
+pandas/core/reshape/api.py,sha256=pRwwOuS6LNFLQOEFVrVKgvJk2ZrjIPf14ZHmnrN_7vA,365
+pandas/core/reshape/api.pyc,,
+pandas/core/reshape/concat.py,sha256=e2sMHKrZ57hrzOUBK7V1j56EoCOg-ie7IpReUM77BNc,22164
+pandas/core/reshape/concat.pyc,,
+pandas/core/reshape/melt.py,sha256=EnE_iF8ZbBCuRkG1YNRUpRDOpVLlgS5wE0u1RDZ5_BM,15849
+pandas/core/reshape/melt.pyc,,
+pandas/core/reshape/merge.py,sha256=cpUxYc75m1S7pVlx5u5S-pQibyDJNUozB2Jjw7hWjWo,66049
+pandas/core/reshape/merge.pyc,,
+pandas/core/reshape/pivot.py,sha256=WUsUO9ukwfEuNKGMH5-DYDTMXTSqt-6NLX88os5eTlc,21962
+pandas/core/reshape/pivot.pyc,,
+pandas/core/reshape/reshape.py,sha256=hak1JAVc6djBQgNv6sbujU1Dkl1FxHffyKsHBSjXVQ8,36545
+pandas/core/reshape/reshape.pyc,,
+pandas/core/reshape/tile.py,sha256=h9-Bbpn_sSu-q-9lEqKd5_rpW9nqAtJuQ7dVMzAeIQA,19404
+pandas/core/reshape/tile.pyc,,
+pandas/core/reshape/util.py,sha256=lbxpf0KNOkq9UDayJw8L-66DJMNClJnPDis1ual_v18,1429
+pandas/core/reshape/util.pyc,,
+pandas/core/series.py,sha256=VvZ4EJaIPIXEW_Jdz9J4SywSWlFP5qaRjAg0OZsBORU,143381
+pandas/core/series.pyc,,
+pandas/core/sorting.py,sha256=og9jr6dDuYAjIsRDZeL3mSzmStnqvq4NQC-JC9_k708,17047
+pandas/core/sorting.pyc,,
+pandas/core/sparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/sparse/__init__.pyc,,
+pandas/core/sparse/api.py,sha256=_9h7DFXs53j0Xjfu5wv3fxDl1cbfXo5tDGOyUYQRSCY,206
+pandas/core/sparse/api.pyc,,
+pandas/core/sparse/frame.py,sha256=JsD752KUnBP47FqhHBHwzZpLYG4u9rR3FGHyzhBVgsQ,37513
+pandas/core/sparse/frame.pyc,,
+pandas/core/sparse/scipy_sparse.py,sha256=R6fsJ60tuq80yJWLUfK0NBPb6-drz92KBsO1tCciV6o,5341
+pandas/core/sparse/scipy_sparse.pyc,,
+pandas/core/sparse/series.py,sha256=KFaskfvUpjWNrTAeymvb37_vHE12I4lNl_inu5ywy0s,20518
+pandas/core/sparse/series.pyc,,
+pandas/core/strings.py,sha256=TJ9N3STU21PmIIQAsUiXGNnXBGuShxgkkgxOYtMm7Fo,100753
+pandas/core/strings.pyc,,
+pandas/core/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/tools/__init__.pyc,,
+pandas/core/tools/datetimes.py,sha256=qAQE7y0RV181UlmDEzAHvSXugCkbuAnsc_zZgekljUg,32266
+pandas/core/tools/datetimes.pyc,,
+pandas/core/tools/numeric.py,sha256=G5DiUAYgrnNpHPatkMrTK5GXxL387CAjKe35bObfnaE,6019
+pandas/core/tools/numeric.pyc,,
+pandas/core/tools/timedeltas.py,sha256=5iVTj4d4Oevl6kkxrKtZPPziwHmA6XKrE1PQwgLukIo,6153
+pandas/core/tools/timedeltas.pyc,,
+pandas/core/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/core/util/__init__.pyc,,
+pandas/core/util/hashing.py,sha256=OfUWQ52Bvz1uMFNHbeM8wErPlAimg8TQhx7V49cwy2s,10752
+pandas/core/util/hashing.pyc,,
+pandas/core/window.py,sha256=jtEey-P6saotH-0ebczGMEu1n3UiBvZC4DGPBm0PNNg,83431
+pandas/core/window.pyc,,
+pandas/errors/__init__.py,sha256=X675dJOGLmKLo1V8DKyIXfGZ4wLMySxHki5ch6e4E64,5566
+pandas/errors/__init__.pyc,,
+pandas/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/io/__init__.pyc,,
+pandas/io/api.py,sha256=a0-LNl3IwsPq-pjPGwTNvzGgwMgvmYhe818W_2AjieE,709
+pandas/io/api.pyc,,
+pandas/io/clipboard/__init__.py,sha256=XHCwE-vqXYOzo0hpEU-_aJ0u3Y3kbhaDlyJSfiUFaRo,4135
+pandas/io/clipboard/__init__.pyc,,
+pandas/io/clipboard/clipboards.py,sha256=qj0Mvie4sb3Az_BnzBe-m5Al7WPrY181Ep9r-2EG5AQ,4246
+pandas/io/clipboard/clipboards.pyc,,
+pandas/io/clipboard/exceptions.py,sha256=0fpZwNow-CEX_5INDyVermOyKbLsJmVtx83kW1jmQao,279
+pandas/io/clipboard/exceptions.pyc,,
+pandas/io/clipboard/windows.py,sha256=Y7DdBr9MrzYROYtFZF2pWs7celC4PJ_Bkmv0vWPAFqw,5442
+pandas/io/clipboard/windows.pyc,,
+pandas/io/clipboards.py,sha256=Da3hiVWCwpkatjNtPNes3U6EcJZGePvCaQiYOEupIBw,4913
+pandas/io/clipboards.pyc,,
+pandas/io/common.py,sha256=_IebRVlHdMW325GJBBsO0WMC03GkrRpfKeAJXvZ8MnU,19689
+pandas/io/common.pyc,,
+pandas/io/date_converters.py,sha256=MYhbT305FZ2iM-uxbTzT-Zw09zs_hmTnOFsJ9CK3NnQ,1902
+pandas/io/date_converters.pyc,,
+pandas/io/excel.py,sha256=RkURkOzO4teb-aI-Whz0uaAyhfKg0s9TsbLAFKoB5tk,66296
+pandas/io/excel.pyc,,
+pandas/io/feather_format.py,sha256=CMyRgtHMbTWbpbKCkV8DLMt6yt6CylCkLxmQa6z_vf8,3970
+pandas/io/feather_format.pyc,,
+pandas/io/formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/io/formats/__init__.pyc,,
+pandas/io/formats/console.py,sha256=CBydaXq8tTT2djq07bJp32at1u7KcJsIsbZzVCYgcaw,4641
+pandas/io/formats/console.pyc,,
+pandas/io/formats/css.py,sha256=BkRsUTeJpSaPpE-lQ_Ajo__w7XDUij-_RGVQeBrlccI,7945
+pandas/io/formats/css.pyc,,
+pandas/io/formats/csvs.py,sha256=terw5Lfokb42zC-mO3fmdca8hFuBpFMUHP9Yz6UNw5c,11465
+pandas/io/formats/csvs.pyc,,
+pandas/io/formats/excel.py,sha256=CQJL5d9KUtoL_ThyMvCM2Guow2rIXFMsUbbAU23TVy8,24661
+pandas/io/formats/excel.pyc,,
+pandas/io/formats/format.py,sha256=ro5QzfxeJSmaXyPh_WeJaEZW4UOxq4r1fQ4DXs_tzF4,55267
+pandas/io/formats/format.pyc,,
+pandas/io/formats/html.py,sha256=S8VoYTGPgE1V0JwkmvrckqZWJ2wSaHU-rTsSukIz0Gw,21227
+pandas/io/formats/html.pyc,,
+pandas/io/formats/latex.py,sha256=6c5zNnIx7DrFrLVmj2wxrjvhRHvuaoKUr5mq1zVgXlY,9408
+pandas/io/formats/latex.pyc,,
+pandas/io/formats/printing.py,sha256=SuyNwJ1nBh1DEaT4YDcXNxasTU8vQ25HZnG_oYQMvy4,13669
+pandas/io/formats/printing.pyc,,
+pandas/io/formats/style.py,sha256=41y_WrlKK4ssd0H5-GynLLnyOr8ncSehWhEqFJ5mb4g,46534
+pandas/io/formats/style.pyc,,
+pandas/io/formats/templates/html.tpl,sha256=mCgH4jUkz-tgpB3rKqzIlCMb48cg7ffkrahQkyC4uIg,2040
+pandas/io/formats/terminal.py,sha256=bT-YvnubWVwDpXSKky-pm-p0JFnqzi_CB96a3_snSj4,4364
+pandas/io/formats/terminal.pyc,,
+pandas/io/gbq.py,sha256=ex_leKLjOihaK_HT4LDh65b0VTLLWAIv3yUMXDPFrFc,6668
+pandas/io/gbq.pyc,,
+pandas/io/gcs.py,sha256=T1LyjJpn3lQEsjgxxMUi_wVaCVcFxk5cNFYOH1gpBq0,476
+pandas/io/gcs.pyc,,
+pandas/io/html.py,sha256=EruLCWU11UJjKsLr_XDwGIzA5_c9jJNfCz0qnw8ZcVA,35083
+pandas/io/html.pyc,,
+pandas/io/json/__init__.py,sha256=nubUeI727d0nKhrnpnrVzskVbLIGFu4FstAk86lTZbA,201
+pandas/io/json/__init__.pyc,,
+pandas/io/json/json.py,sha256=fCzA4n0GT34fBMtgH5aHP-1ciZcf8CDxSBawCKtwUbI,33657
+pandas/io/json/json.pyc,,
+pandas/io/json/normalize.py,sha256=4qAnd2TMPkOm_D9D4EusNj502hqNPhPoIjv1aYAPcb8,9406
+pandas/io/json/normalize.pyc,,
+pandas/io/json/table_schema.py,sha256=Ot-bo0U1yGjo_3i1yPjpvh-jzxD-EGO6JJLjtD7Qclg,10231
+pandas/io/json/table_schema.pyc,,
+pandas/io/msgpack/__init__.py,sha256=NiGFlH8DAp6qOAY2CayowlYE8Ap8jyDIlWcels4FeUw,1233
+pandas/io/msgpack/__init__.pyc,,
+pandas/io/msgpack/_packer.so,sha256=iE8BOHfgrCzIApmYK3Lj4mymOAi-3FgEAgu8sEQyeEU,74200
+pandas/io/msgpack/_unpacker.so,sha256=863dwJYIwD-sJ-7EOtYGC8584WoePfeb574lLhNhI0A,93816
+pandas/io/msgpack/_version.py,sha256=QXoo6iFXPa7HetqR8eOrP1u3Z8qNt3S3zl_GyDwCT6Y,20
+pandas/io/msgpack/_version.pyc,,
+pandas/io/msgpack/exceptions.py,sha256=uvfwRHGIILIKFm2f1UANdwFr_qJ5Wp08eSXksMZsr00,506
+pandas/io/msgpack/exceptions.pyc,,
+pandas/io/packers.py,sha256=mP6c7Rddck6Eestu72Nu1y6NEdHx1gcrXpAotXwal2E,29313
+pandas/io/packers.pyc,,
+pandas/io/parquet.py,sha256=irQwrqPx2nAeYkeDPu93y5m_QV5rmB6P9R1hM8aesWQ,9617
+pandas/io/parquet.pyc,,
+pandas/io/parsers.py,sha256=2XTYi2R6tUV9-F3cGT_BCd2eg4pZc5dHTEGnBMkpSh0,130646
+pandas/io/parsers.pyc,,
+pandas/io/pickle.py,sha256=YEoOhNFQ28Lv0c09f-F_SrQWTj3KRpUQ8wXeSOCNLyI,6024
+pandas/io/pickle.pyc,,
+pandas/io/pytables.py,sha256=ltoXSn6eRRz15xCkl31G9eHYw17GnwSMoAMFLS2wZa0,168514
+pandas/io/pytables.pyc,,
+pandas/io/s3.py,sha256=q4AF-72thti3k2yO9VsrZFUqY6_hl-CixzhX0_px46Q,1324
+pandas/io/s3.pyc,,
+pandas/io/sas/__init__.py,sha256=P1ZbFZ6Wzbv_mC0s9hFdsHc394GQD4Nzd1blfkY5kwM,40
+pandas/io/sas/__init__.pyc,,
+pandas/io/sas/_sas.so,sha256=VX4ATWpgEIO3Rvm0IhAdaqSP8kVJlhs_t5TwyzHQqos,219296
+pandas/io/sas/sas7bdat.py,sha256=WtNWN665FTY8LqChyUvWZOAITLeIu-mSzigURQH46X8,27954
+pandas/io/sas/sas7bdat.pyc,,
+pandas/io/sas/sas_constants.py,sha256=Kn-dzqt1-EVr35uYnou91QJuVqeT_W2wpiMsxdUykeQ,6719
+pandas/io/sas/sas_constants.pyc,,
+pandas/io/sas/sas_xport.py,sha256=wVy5XPygGd7DvVIkSWJRpZMgS9ZjE_qQB9rIzjTJcIw,14695
+pandas/io/sas/sas_xport.pyc,,
+pandas/io/sas/sasreader.py,sha256=w5ZXdCLqNdBhAOOLwhU6E0-K2zsqWPjRA2h5BpS8o0Y,2504
+pandas/io/sas/sasreader.pyc,,
+pandas/io/sql.py,sha256=wfWmUGGC75JIvHinLRcjoWCEIbHI6zFDXJf3McLuSyQ,60720
+pandas/io/sql.pyc,,
+pandas/io/stata.py,sha256=7sClePe_K5Six34TB48Qx1kSr6b1wAXhiQcaDfpxuZA,109119
+pandas/io/stata.pyc,,
+pandas/plotting/__init__.py,sha256=-yTXk2Ms7Ix0XqRFg9rtcNdTus8ZTR34sTKEGT-gyOU,650
+pandas/plotting/__init__.pyc,,
+pandas/plotting/_compat.py,sha256=WItQ3NQNnfxj2y65mpaHsjPhnO0tE1QazdeKCKOUMFc,695
+pandas/plotting/_compat.pyc,,
+pandas/plotting/_converter.py,sha256=3MTFP6WRn_Casnh9Ga1ucyAXxvMASIDlDKvh20nDVpc,38826
+pandas/plotting/_converter.pyc,,
+pandas/plotting/_core.py,sha256=MWQaooc0FuNkSoLQefQ3DsBbH-u6MrNtsMwD8ufbA_s,128395
+pandas/plotting/_core.pyc,,
+pandas/plotting/_misc.py,sha256=kZ--tnUp90_lMKVj0l7vD85RF6dY5qXPkO0y9b7_ezM,20964
+pandas/plotting/_misc.pyc,,
+pandas/plotting/_style.py,sha256=BBXX5hGhOgG_mXYPVdEHbxNgc4EjT40TQLI94Q2-8eY,5763
+pandas/plotting/_style.pyc,,
+pandas/plotting/_timeseries.py,sha256=U4aysjbrIVhOAw-KZPin3BhYR5nW0GPl-_Rn7-plpyE,11191
+pandas/plotting/_timeseries.pyc,,
+pandas/plotting/_tools.py,sha256=qP8xrtT_OhJDZsip4uNHVxvLXqzwaYDhDeCpwRi2Gr4,12812
+pandas/plotting/_tools.pyc,,
+pandas/testing.py,sha256=UvzuqNH_1SftihpgvhcWeyHXIH2iapsqMXuCZePT6Dk,158
+pandas/testing.pyc,,
+pandas/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/__init__.pyc,,
+pandas/tests/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/api/__init__.pyc,,
+pandas/tests/api/test_api.py,sha256=P3LtFxcAATvFYy1lihVtPka_kJbZ71wPvGnIpRSxVTg,5452
+pandas/tests/api/test_api.pyc,,
+pandas/tests/api/test_types.py,sha256=Z2PvsuFoc6iIO0lEZLNfGpY-XUkW1E7DYFcx-YqPl4k,1732
+pandas/tests/api/test_types.pyc,,
+pandas/tests/arithmetic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arithmetic/__init__.pyc,,
+pandas/tests/arithmetic/conftest.py,sha256=QhDyYKpwPGwdDQf6tBRVkNpidOPweHMiNTb-2CFWSIg,5878
+pandas/tests/arithmetic/conftest.pyc,,
+pandas/tests/arithmetic/test_datetime64.py,sha256=NE2cGtGb4GuLTZTkTQpJdhzej61Awf80d8a26pqKAFU,92695
+pandas/tests/arithmetic/test_datetime64.pyc,,
+pandas/tests/arithmetic/test_numeric.py,sha256=G-uCLOlBBPsrD6Z4sTWH_BiYdAAD0ZpIgrjoJmzOTDc,39945
+pandas/tests/arithmetic/test_numeric.pyc,,
+pandas/tests/arithmetic/test_object.py,sha256=bEm6W0Jt0ezvLr13HRLEh_j7Y5jAkOmdoLc8LzNsoTU,10848
+pandas/tests/arithmetic/test_object.pyc,,
+pandas/tests/arithmetic/test_period.py,sha256=ztrovpJVtlT0CG0-G6MiMpM2Ilz6biE6UzzMo55TENE,46403
+pandas/tests/arithmetic/test_period.pyc,,
+pandas/tests/arithmetic/test_timedelta64.py,sha256=dtz77sohXcuOGsHEdxhjblrHFQ39NoLHlATQF-vAvoY,75677
+pandas/tests/arithmetic/test_timedelta64.pyc,,
+pandas/tests/arrays/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/__init__.pyc,,
+pandas/tests/arrays/categorical/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/categorical/__init__.pyc,,
+pandas/tests/arrays/categorical/common.py,sha256=qwI0ixQJ1bxSSRPylcjna_xIgCqN4rX8w2kuIlCrV7Q,250
+pandas/tests/arrays/categorical/common.pyc,,
+pandas/tests/arrays/categorical/conftest.py,sha256=rq1zLIwliLJ4Subns7LRmqNGtGqTgWYvUMDvconC-1Y,308
+pandas/tests/arrays/categorical/conftest.pyc,,
+pandas/tests/arrays/categorical/test_algos.py,sha256=lcV-_ZIPecPvoBxCH08iHEvlF9XyWAyv461BNRvgMu4,5449
+pandas/tests/arrays/categorical/test_algos.pyc,,
+pandas/tests/arrays/categorical/test_analytics.py,sha256=pOKGmrZE-e9XJiM36AlVOPJKemrVtHWgcKmD4ii_5O4,11679
+pandas/tests/arrays/categorical/test_analytics.pyc,,
+pandas/tests/arrays/categorical/test_api.py,sha256=sCkcwPc_vl4fQS0cXYeTJOY3dmA_sHdIdWJODP72CbU,20350
+pandas/tests/arrays/categorical/test_api.pyc,,
+pandas/tests/arrays/categorical/test_constructors.py,sha256=5t07xzZ_yJp-ak4IiNflI3W8aJJkXN92CDl46Ni7i8k,23804
+pandas/tests/arrays/categorical/test_constructors.pyc,,
+pandas/tests/arrays/categorical/test_dtypes.py,sha256=tCwjBgqb7Ljw8syUBsdBW-ie5T6G37JoNQxRfltFvwc,6796
+pandas/tests/arrays/categorical/test_dtypes.pyc,,
+pandas/tests/arrays/categorical/test_indexing.py,sha256=KO9Wd2tyJBNzQUejwU-jeLGYhKUJ1fQ-cnrUCPkIfas,9775
+pandas/tests/arrays/categorical/test_indexing.pyc,,
+pandas/tests/arrays/categorical/test_missing.py,sha256=VzOTGqCETsnz7PjbIKhEFNzoMFaC8Vj9OJjTl1dVcL8,3075
+pandas/tests/arrays/categorical/test_missing.pyc,,
+pandas/tests/arrays/categorical/test_operators.py,sha256=LPXTWG5y2to4F1RG_zZb_MBj8seQSrXjts2COajLlGM,12632
+pandas/tests/arrays/categorical/test_operators.pyc,,
+pandas/tests/arrays/categorical/test_repr.py,sha256=9bkISAzcoYihSGOVipG9VAVbB1pWRz7zWm5Itzp2nn0,26226
+pandas/tests/arrays/categorical/test_repr.pyc,,
+pandas/tests/arrays/categorical/test_sorting.py,sha256=68cE-G9MO2ZhShu0aN9hSfA7iz664Vg8gkRbeBrFVWU,5086
+pandas/tests/arrays/categorical/test_sorting.pyc,,
+pandas/tests/arrays/categorical/test_subclass.py,sha256=gsHAHnDuL_gI4IxcmN6J7Jy4TFSSV034gvJNEzWE4ZY,890
+pandas/tests/arrays/categorical/test_subclass.pyc,,
+pandas/tests/arrays/categorical/test_warnings.py,sha256=25Ri4LFTYdMpchAmlPeTWWpKxyK8mfTOHgGsMrytHe0,1146
+pandas/tests/arrays/categorical/test_warnings.pyc,,
+pandas/tests/arrays/interval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/interval/__init__.pyc,,
+pandas/tests/arrays/interval/test_interval.py,sha256=5ffelNxCvKLYvd-gC38NG_L0HccOEt7rwQOqSMsR3Fs,2360
+pandas/tests/arrays/interval/test_interval.pyc,,
+pandas/tests/arrays/interval/test_ops.py,sha256=M-uDRDYAWTdQ5ZWeToStZmrzxyGYox6Ujhd7OYU8ySU,3268
+pandas/tests/arrays/interval/test_ops.pyc,,
+pandas/tests/arrays/sparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/arrays/sparse/__init__.pyc,,
+pandas/tests/arrays/sparse/test_arithmetics.py,sha256=IUhMcaFEuwgJH2I-T-kXZYISQdfh2xwoSzOAUd_Jmac,22343
+pandas/tests/arrays/sparse/test_arithmetics.pyc,,
+pandas/tests/arrays/sparse/test_array.py,sha256=NGhY5cbFVV1fyZoM9EzIIJZmpXHD9ivimF-Z1I3YDGA,43678
+pandas/tests/arrays/sparse/test_array.pyc,,
+pandas/tests/arrays/sparse/test_dtype.py,sha256=DntwP8ysy1g50tspdYqaFCJyUj_1od1f1mHd17OrMI8,4695
+pandas/tests/arrays/sparse/test_dtype.pyc,,
+pandas/tests/arrays/sparse/test_libsparse.py,sha256=jqtsZVBRdk4DqX8aSWFgmUrw7MyYic7IhgoAk9YXXfI,21915
+pandas/tests/arrays/sparse/test_libsparse.pyc,,
+pandas/tests/arrays/test_array.py,sha256=qouOpktLUkHmTcl2rF9Rdver55t0MPQNs0NgKRZCPmc,8171
+pandas/tests/arrays/test_array.pyc,,
+pandas/tests/arrays/test_datetimelike.py,sha256=3rt8D4wKkyQNV5PQqWj6I5E6BcAOExk-0QmQBOUO8u0,23164
+pandas/tests/arrays/test_datetimelike.pyc,,
+pandas/tests/arrays/test_datetimes.py,sha256=6eF-NM-qiWDSMLrHRrHhOan7v6f1fq7e_5DL0jVDZ3g,10666
+pandas/tests/arrays/test_datetimes.pyc,,
+pandas/tests/arrays/test_integer.py,sha256=OGjfHMZldfsK9FTuiKQnzS7YlwetsBFFJsY48eH1nDA,22287
+pandas/tests/arrays/test_integer.pyc,,
+pandas/tests/arrays/test_numpy.py,sha256=-zMPqA6YVgeh0MWlbXapQAA4mZXWS8rV3EzwTZh-Rm4,5664
+pandas/tests/arrays/test_numpy.pyc,,
+pandas/tests/arrays/test_period.py,sha256=BnwnmfWtCzFQ4S4JcIDV20mALbKvr6OvYf57i0PyUJQ,9849
+pandas/tests/arrays/test_period.pyc,,
+pandas/tests/arrays/test_timedeltas.py,sha256=eVM3fi1MOa7eYn6FQ6O0Siw8B1e72eG8aQwRq2tWjRk,5389
+pandas/tests/arrays/test_timedeltas.pyc,,
+pandas/tests/computation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/computation/__init__.pyc,,
+pandas/tests/computation/test_compat.py,sha256=YhEYC7QluhAEQ8FujF6o-LErXMZJxo2-PeS_5q49p7A,1370
+pandas/tests/computation/test_compat.pyc,,
+pandas/tests/computation/test_eval.py,sha256=dtyOPeDVR2cB4NBhWqfOdsRH5AjWzCm3kXPnkr4MTis,70557
+pandas/tests/computation/test_eval.pyc,,
+pandas/tests/dtypes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/dtypes/__init__.pyc,,
+pandas/tests/dtypes/cast/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/dtypes/cast/__init__.pyc,,
+pandas/tests/dtypes/cast/test_construct_from_scalar.py,sha256=gqpGn2QcLgx4A2QaK2-tStsJIJUea1yrhEFGfL9u8nU,793
+pandas/tests/dtypes/cast/test_construct_from_scalar.pyc,,
+pandas/tests/dtypes/cast/test_construct_ndarray.py,sha256=RdummBO0opNhYDmyoW1FkzZ0gL_T0UiIjjoccVhjEW4,707
+pandas/tests/dtypes/cast/test_construct_ndarray.pyc,,
+pandas/tests/dtypes/cast/test_construct_object_arr.py,sha256=3i0qVmRx6YHXmw64YdcqmHTQvHahsKeZ3Ze3NgwXOf8,739
+pandas/tests/dtypes/cast/test_construct_object_arr.pyc,,
+pandas/tests/dtypes/cast/test_convert_objects.py,sha256=erC8zdZLdI_fIwrwcjhAE6awYb-V9KviaHRKo4VB5Aw,392
+pandas/tests/dtypes/cast/test_convert_objects.pyc,,
+pandas/tests/dtypes/cast/test_downcast.py,sha256=7gmNwoY-BZzdLerg8GZMSFTcp7AI9mf-A-4nFz75bvM,2419
+pandas/tests/dtypes/cast/test_downcast.pyc,,
+pandas/tests/dtypes/cast/test_find_common_type.py,sha256=exseIUvHhsoBYxuoD73p_30hCo9_7G0iA9ZgaHv4Sos,3593
+pandas/tests/dtypes/cast/test_find_common_type.pyc,,
+pandas/tests/dtypes/cast/test_infer_datetimelike.py,sha256=06XIsmTkgvaQqUK1V4aFYpvC0CaW6OcOGaWCZFLQq0M,579
+pandas/tests/dtypes/cast/test_infer_datetimelike.pyc,,
+pandas/tests/dtypes/cast/test_infer_dtype.py,sha256=YblErHaP7Ef6ccoIHmJTTlCDIQS_94RzMWmc-8Byp3g,5047
+pandas/tests/dtypes/cast/test_infer_dtype.pyc,,
+pandas/tests/dtypes/test_common.py,sha256=4mWXxf_ovFhoJSWnb6eQTwewBZ5LbTtgrLIHpfr3du0,23846
+pandas/tests/dtypes/test_common.pyc,,
+pandas/tests/dtypes/test_concat.py,sha256=j7jOlOhK2RXovZI_1jqHCtbw4V8suPlsShrKCq9mErQ,2001
+pandas/tests/dtypes/test_concat.pyc,,
+pandas/tests/dtypes/test_dtypes.py,sha256=LKAWgH4Kg0MtlHRPIkj0bLgiL3EEqQgPWmZ7InkC5jE,32818
+pandas/tests/dtypes/test_dtypes.pyc,,
+pandas/tests/dtypes/test_generic.py,sha256=tLsdQwg2bHTE9YlHROI4YzEdldz7QGl4c5jHgxvHEPY,4268
+pandas/tests/dtypes/test_generic.pyc,,
+pandas/tests/dtypes/test_inference.py,sha256=2Vvajn6l-cbOnZsQYW85Te7MdlHspGP4_ScHpQaeSbQ,48984
+pandas/tests/dtypes/test_inference.pyc,,
+pandas/tests/dtypes/test_missing.py,sha256=OHxUNFHVJF5xJebbeBS34vpamQaC1tLX9_J1H_TPmKo,17119
+pandas/tests/dtypes/test_missing.pyc,,
+pandas/tests/extension/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/extension/__init__.pyc,,
+pandas/tests/extension/arrow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/extension/arrow/__init__.pyc,,
+pandas/tests/extension/arrow/bool.py,sha256=NYE9apgNmbP4LWSRJabihFWUVATWqGLX9c1gxliIk-s,4047
+pandas/tests/extension/arrow/bool.pyc,,
+pandas/tests/extension/arrow/test_bool.py,sha256=GRQVGH_qYmdOTG3ITGmS8u3cBbYeI07NIAA_BIqMLoY,1693
+pandas/tests/extension/arrow/test_bool.pyc,,
+pandas/tests/extension/base/__init__.py,sha256=RN133WpskjuRceOXrTjcAA2TFr0oD4I8Ufd6fPJo64A,2104
+pandas/tests/extension/base/__init__.pyc,,
+pandas/tests/extension/base/base.py,sha256=dXKhE9DFR0oBHu8PtkQoUVMQ0q2f6Z9N4Yvn8ZdJ4rQ,337
+pandas/tests/extension/base/base.pyc,,
+pandas/tests/extension/base/casting.py,sha256=s6vLleYTVKF-zPffkRFRrMfZwTRxKYYTrIxr26IWDtw,717
+pandas/tests/extension/base/casting.pyc,,
+pandas/tests/extension/base/constructors.py,sha256=xir3XEFDfADpLSU-x4K14a9BzsulB89PECBZSI7zHPg,2884
+pandas/tests/extension/base/constructors.pyc,,
+pandas/tests/extension/base/dtype.py,sha256=lTHEMW-nKOfQPQH6u59yw0d2JJC5ClDZhcFLns4VDBU,2875
+pandas/tests/extension/base/dtype.pyc,,
+pandas/tests/extension/base/getitem.py,sha256=TSFSHv9jxobC7faAdhosp32Z3s1rMexD3EnH1tmjfcs,8062
+pandas/tests/extension/base/getitem.pyc,,
+pandas/tests/extension/base/groupby.py,sha256=wauj3MlGJ2aeuE87_yg0BftllEl0tljkd5fywQeGDFs,3097
+pandas/tests/extension/base/groupby.pyc,,
+pandas/tests/extension/base/interface.py,sha256=XH5ycHGBGvbmfQGgv-z1JP8XV5lX1exeS7_fdkbtGQk,2284
+pandas/tests/extension/base/interface.pyc,,
+pandas/tests/extension/base/io.py,sha256=-CAvsGuwtf-dkKDZZt7mcMaaLD81Mn5s_PRKTpw8LWM,636
+pandas/tests/extension/base/io.pyc,,
+pandas/tests/extension/base/methods.py,sha256=0STUdKT6ZllTvReFAwl6hKbbB_x5m-5AuPmaSKq4QpE,13053
+pandas/tests/extension/base/methods.pyc,,
+pandas/tests/extension/base/missing.py,sha256=ke81775gnnw-F5AOakcDwjGPnaic0Hi8ElgC41JyU6o,4326
+pandas/tests/extension/base/missing.pyc,,
+pandas/tests/extension/base/ops.py,sha256=ZHyN3djprbuc5K-7U3fzeWm3NosNyF4IipfIu6XID3I,5816
+pandas/tests/extension/base/ops.pyc,,
+pandas/tests/extension/base/printing.py,sha256=BEZrRJKiLHv_8Hr7yF-7AgAG52JAa9NNWdbQIWRxuHs,1231
+pandas/tests/extension/base/printing.pyc,,
+pandas/tests/extension/base/reduce.py,sha256=x6fKcB5YqWqXwzgfgqstPOF-inMOP35sV1kPxcggOJA,1911
+pandas/tests/extension/base/reduce.pyc,,
+pandas/tests/extension/base/reshaping.py,sha256=ryvA4BlscQVd8evgaA5IO7tSUyCns6WSLKqtScYCee8,10471
+pandas/tests/extension/base/reshaping.pyc,,
+pandas/tests/extension/base/setitem.py,sha256=5VgnH3kRhwmftrMY6rvbsR7aGmM4ST6HWQnamV28Fsw,6268
+pandas/tests/extension/base/setitem.pyc,,
+pandas/tests/extension/conftest.py,sha256=iygBkJor71dM0yB_LBQkO8yYAB-eU9pPlKoTCrTaKFE,2314
+pandas/tests/extension/conftest.pyc,,
+pandas/tests/extension/decimal/__init__.py,sha256=NbLUqrev2inMPAzf-bb5Am48pKZApvM1OmEGIwko6GE,141
+pandas/tests/extension/decimal/__init__.pyc,,
+pandas/tests/extension/decimal/array.py,sha256=15hyWbeI1anrlnWUGpT4lp6uSH1fyJoGtZ-GwhlaHUg,4805
+pandas/tests/extension/decimal/array.pyc,,
+pandas/tests/extension/decimal/test_decimal.py,sha256=I2AZLYVo3fz26VF59IeFScsHZ6zajyx2ARbwrsPcDgs,12690
+pandas/tests/extension/decimal/test_decimal.pyc,,
+pandas/tests/extension/json/__init__.py,sha256=oc5qIgYGFkmRgeBXFZOIpqEVEhl1Z6PWSG1JzlaJJ20,102
+pandas/tests/extension/json/__init__.pyc,,
+pandas/tests/extension/json/array.py,sha256=Q5x0xEM2cF1YSFcUhZ_z6oZNaQoVtQa0KjoAbOKcMLc,6580
+pandas/tests/extension/json/array.pyc,,
+pandas/tests/extension/json/test_json.py,sha256=zu8Gmo1cujyrZ1T_P2Wlo6leOimaGMfAor-utO8FDI0,9464
+pandas/tests/extension/json/test_json.pyc,,
+pandas/tests/extension/numpy_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/extension/numpy_/__init__.pyc,,
+pandas/tests/extension/numpy_/conftest.py,sha256=728SLySi4lC_ZDluLwSgcM_5lIdB1171_dLQKi1FgGI,909
+pandas/tests/extension/numpy_/conftest.pyc,,
+pandas/tests/extension/numpy_/test_numpy.py,sha256=kGh0ugUGDdS8ug4IexM-Bqh_phBd_DdhXHrrghjYax8,4754
+pandas/tests/extension/numpy_/test_numpy.pyc,,
+pandas/tests/extension/numpy_/test_numpy_nested.py,sha256=4SncgmLUOLJySOik2ieeUBDveXNyZUAG0ZygGw11Hxk,7134
+pandas/tests/extension/numpy_/test_numpy_nested.pyc,,
+pandas/tests/extension/test_categorical.py,sha256=M00zEl69zdhErmZQIRsoyXN2noi4oIkKwSPD32H8bV0,7289
+pandas/tests/extension/test_categorical.pyc,,
+pandas/tests/extension/test_common.py,sha256=d4ceGiKJ8ZigJfcKW2BH-xU0k5MQ9aoWpPSAj_R2G-Y,2092
+pandas/tests/extension/test_common.pyc,,
+pandas/tests/extension/test_datetime.py,sha256=VwKP4OrHTSCg1d0v7w4lSZ63y9WZ6zs9tqLz3dxFNL8,7238
+pandas/tests/extension/test_datetime.pyc,,
+pandas/tests/extension/test_external_block.py,sha256=ii1ff2gCY-hH_Lkmvy86CcLRcMDdkUJDFCtQBcXR9Uc,2246
+pandas/tests/extension/test_external_block.pyc,,
+pandas/tests/extension/test_integer.py,sha256=4wbyrrqBuFt1gyydAs7lDNDOlN-771kom_jygW7pvAk,6659
+pandas/tests/extension/test_integer.pyc,,
+pandas/tests/extension/test_interval.py,sha256=io7Ng5Ouy5v_12Ew6y7fzKeR04HstoQ8aU--W7jpmTo,3920
+pandas/tests/extension/test_interval.pyc,,
+pandas/tests/extension/test_period.py,sha256=_QtmA8XJJKw8zybDKpmcuQYMhXlK3eMeRepbegYcacU,4336
+pandas/tests/extension/test_period.pyc,,
+pandas/tests/extension/test_sparse.py,sha256=0UGx-soNnmLOs0Ln4UjwxTuFk_xYNtOEJNiNGV7NdsY,12324
+pandas/tests/extension/test_sparse.pyc,,
+pandas/tests/frame/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/frame/__init__.pyc,,
+pandas/tests/frame/common.py,sha256=7q5Vwii_uEYrI43hhP6rakpSUziBjxSQirw7fLJUeWQ,4641
+pandas/tests/frame/common.pyc,,
+pandas/tests/frame/conftest.py,sha256=igaMDz_FoqGjq-pDto385ea6IxaLKCS_Hy7_yY1DiGo,5594
+pandas/tests/frame/conftest.pyc,,
+pandas/tests/frame/test_alter_axes.py,sha256=4ftGAuEyZ11incTipCyGbZkXKwLiyp4G-42kY0icAOs,58625
+pandas/tests/frame/test_alter_axes.pyc,,
+pandas/tests/frame/test_analytics.py,sha256=OnaMUa7fYSR_HtPXOp2sHLC_ztArDFT5B7iqOX2MrXc,92396
+pandas/tests/frame/test_analytics.pyc,,
+pandas/tests/frame/test_api.py,sha256=7261HCiPJ5z5j2jYIqzMvly4nHY1_krJuXHZkd1-7Ps,18240
+pandas/tests/frame/test_api.pyc,,
+pandas/tests/frame/test_apply.py,sha256=3GqPECXdE4IiIZskZC1OngJUE4eCOnCdm4qU8D49khQ,45323
+pandas/tests/frame/test_apply.pyc,,
+pandas/tests/frame/test_arithmetic.py,sha256=PA1a1fTEWhoMDvkaqF9Ed9g7X59IT7CUC-19jNC_uOw,24411
+pandas/tests/frame/test_arithmetic.pyc,,
+pandas/tests/frame/test_asof.py,sha256=X2itT1BpqtAUnt5v6VDNK4pSz5MyKgluIAlvFW9V9w4,4640
+pandas/tests/frame/test_asof.pyc,,
+pandas/tests/frame/test_axis_select_reindex.py,sha256=zeOZndoEHXgFIATdbVoWPtVBKiNfD57KiRiFDkyMK-w,44950
+pandas/tests/frame/test_axis_select_reindex.pyc,,
+pandas/tests/frame/test_block_internals.py,sha256=35Cd-4Mquldmbaq82DqPOIn6mxOgaQQ6NzClcY6KJs0,21539
+pandas/tests/frame/test_block_internals.pyc,,
+pandas/tests/frame/test_combine_concat.py,sha256=RPI5FQhzbFuRWz34GKzbUhZreZ8o5lO9sblQkZo86JI,33654
+pandas/tests/frame/test_combine_concat.pyc,,
+pandas/tests/frame/test_constructors.py,sha256=5ADHXW_7RSE8MSy1TEU5qvaqSDAbP2SQxebI8Ggvf-s,89393
+pandas/tests/frame/test_constructors.pyc,,
+pandas/tests/frame/test_convert_to.py,sha256=teQFeYUbBQur0A0x67laOqF3ZdcoSo4E-jaZiwodIY4,20575
+pandas/tests/frame/test_convert_to.pyc,,
+pandas/tests/frame/test_dtypes.py,sha256=Xzki5n7jEpMjlnRcq08bS2r7hpgZiOvVTrDEMpAvt2k,41479
+pandas/tests/frame/test_dtypes.pyc,,
+pandas/tests/frame/test_duplicates.py,sha256=qYiziTSeqjTMl0p-CInXiip0bUBcRaNyrxnHdC4261c,14577
+pandas/tests/frame/test_duplicates.pyc,,
+pandas/tests/frame/test_indexing.py,sha256=U47tdSoZCcv9ylvBRZtLpZsZcz_P0xex8Ru6pon79sM,131238
+pandas/tests/frame/test_indexing.pyc,,
+pandas/tests/frame/test_join.py,sha256=diQ8eSjHxld1d4v4aDT7GcdIFL258vSm4K6ezny1MW8,5751
+pandas/tests/frame/test_join.pyc,,
+pandas/tests/frame/test_missing.py,sha256=8DxNlDo7y3x9aefMVEiDa91et8X_kyx-GxOOuQvMNF8,31904
+pandas/tests/frame/test_missing.pyc,,
+pandas/tests/frame/test_mutate_columns.py,sha256=PiVnz9Q042AoKTjnHfl3okr0XwN1HfTbuBimicX7WXs,9723
+pandas/tests/frame/test_mutate_columns.pyc,,
+pandas/tests/frame/test_nonunique_indexes.py,sha256=lrQbMKKfotJ71X18F-W3owrJPtHe_cHvGJIDX-wBaS4,18506
+pandas/tests/frame/test_nonunique_indexes.pyc,,
+pandas/tests/frame/test_operators.py,sha256=S298AC_HcXGmYoc4GjmIgiqdswGfMDQgnMQDO23zQ-c,27306
+pandas/tests/frame/test_operators.pyc,,
+pandas/tests/frame/test_period.py,sha256=F3ro3C-mSq7WK8JzzohUivAj-TujxbcmcWO9mRZDviY,5539
+pandas/tests/frame/test_period.pyc,,
+pandas/tests/frame/test_quantile.py,sha256=qu5SGk_8xyGO5eR6lHEJGOL1H7jE_tX3a51p8fs5ZVE,15647
+pandas/tests/frame/test_quantile.pyc,,
+pandas/tests/frame/test_query_eval.py,sha256=cu0-ir-OU3xLRAkDIMIZPHQxq8B_ONDro-V-gkQMR58,40871
+pandas/tests/frame/test_query_eval.pyc,,
+pandas/tests/frame/test_rank.py,sha256=tbSS2Sa8_MDwfl7eOLIXlWPCSPB38kuJ7sWwJ_3vSt8,11335
+pandas/tests/frame/test_rank.pyc,,
+pandas/tests/frame/test_replace.py,sha256=K5DA2MhYlry7KTFcTd_PjHv_Lush9w7MgCbYjrvKDS8,46185
+pandas/tests/frame/test_replace.pyc,,
+pandas/tests/frame/test_repr_info.py,sha256=jssiOuAoNcvgG20ywe_y-ofn5GMvf1__4gi91InUkUM,17634
+pandas/tests/frame/test_repr_info.pyc,,
+pandas/tests/frame/test_reshape.py,sha256=yK83m-aTkoyxC2mdWldiwtysJX52ayD9O07HD2Y2qAo,39627
+pandas/tests/frame/test_reshape.pyc,,
+pandas/tests/frame/test_sort_values_level_as_str.py,sha256=MVfZkKR_fEld7Z1iYddBTbt1oiMBmL49LxzvnXjObNI,2828
+pandas/tests/frame/test_sort_values_level_as_str.pyc,,
+pandas/tests/frame/test_sorting.py,sha256=srS4II-EjfkDlzNd891GzZqW5_c1j4tswSSbAJloGv0,25891
+pandas/tests/frame/test_sorting.pyc,,
+pandas/tests/frame/test_subclass.py,sha256=-dICiVDSSWS-25dW5CTqIHTaBCYQ0oZ9AkanpKUVulc,20675
+pandas/tests/frame/test_subclass.pyc,,
+pandas/tests/frame/test_timeseries.py,sha256=pTqy-t52wkMsH3C6e6crK19Ilklxuerx9w-rUzb9lAI,32091
+pandas/tests/frame/test_timeseries.pyc,,
+pandas/tests/frame/test_timezones.py,sha256=IPiEEt3BbpYjNJtneCjTYJ1d5am_sU8px5W_Z34J5ec,7574
+pandas/tests/frame/test_timezones.pyc,,
+pandas/tests/frame/test_to_csv.py,sha256=OqZpaVy1hJ67y9FZka2NHuPK_nRewbFDnRDVTr81_8c,46898
+pandas/tests/frame/test_to_csv.pyc,,
+pandas/tests/frame/test_validate.py,sha256=elkyOI_ZMYBLa3YtkE-02XMjIhGYyII_KiyyLkh8xKU,1063
+pandas/tests/frame/test_validate.pyc,,
+pandas/tests/generic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/generic/__init__.pyc,,
+pandas/tests/generic/test_frame.py,sha256=yMp3Q2VJ4j_QJl9lxGG_Q9s3IOeYeQAB8DU11HaAKI0,9723
+pandas/tests/generic/test_frame.pyc,,
+pandas/tests/generic/test_generic.py,sha256=Ab52y9-NX4iv0NMkB44crf9xBo6zh_dAuRSCqbmOMZ0,35901
+pandas/tests/generic/test_generic.pyc,,
+pandas/tests/generic/test_label_or_level_utils.py,sha256=Mq3UEGDAzwpt79gOV6aSNmgn7gGn7nvLLB4idxcOMpY,11936
+pandas/tests/generic/test_label_or_level_utils.pyc,,
+pandas/tests/generic/test_panel.py,sha256=CPkIbXP9ZUPn3q2DgZOtu6UtN8KqYPBDXKk7B_lsdOs,1915
+pandas/tests/generic/test_panel.pyc,,
+pandas/tests/generic/test_series.py,sha256=uJ5YZRfG1VDwB9Bn6D68dON5d0Vx8ONYtTWoTxk93FE,8206
+pandas/tests/generic/test_series.pyc,,
+pandas/tests/groupby/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/groupby/__init__.pyc,,
+pandas/tests/groupby/aggregate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/groupby/aggregate/__init__.pyc,,
+pandas/tests/groupby/aggregate/test_aggregate.py,sha256=PqRiPHiHk-p4DmQYVkcFcdqmF_0rHBR7RRLHeDxJp_0,9523
+pandas/tests/groupby/aggregate/test_aggregate.pyc,,
+pandas/tests/groupby/aggregate/test_cython.py,sha256=xQT41XJDZ3kaPr7GcNwvMgT6Ddfoa0wkO9O9K7UK3Cc,6820
+pandas/tests/groupby/aggregate/test_cython.pyc,,
+pandas/tests/groupby/aggregate/test_other.py,sha256=y1TGWTNQj09g0NbJdWljqRl_o3o7pGNEbBCs0-vuLvs,18478
+pandas/tests/groupby/aggregate/test_other.pyc,,
+pandas/tests/groupby/conftest.py,sha256=qWFEZHjNX-ygJ1Nh4IPjkkKYZt_r8TW6jsOTU5lMSxw,2288
+pandas/tests/groupby/conftest.pyc,,
+pandas/tests/groupby/test_apply.py,sha256=v27XRjRMnUyyv9xHWFnUXCMOYjpo2ikmGASQCOtcEy0,18087
+pandas/tests/groupby/test_apply.pyc,,
+pandas/tests/groupby/test_bin_groupby.py,sha256=n458O5GFP4shlMqZ2CNZZeqy1YGs0r6BfMbcABB59Lk,5217
+pandas/tests/groupby/test_bin_groupby.pyc,,
+pandas/tests/groupby/test_categorical.py,sha256=PBvbrvIqaCd8q8VOXPWkDWajd8aBVS0utzpi2AhPA9U,34764
+pandas/tests/groupby/test_categorical.pyc,,
+pandas/tests/groupby/test_counting.py,sha256=uSAy6e_QubV_ZPvIb7iFMIkoX0-c2YHsApjdRMrglOM,7838
+pandas/tests/groupby/test_counting.pyc,,
+pandas/tests/groupby/test_filters.py,sha256=4G0bvI0oyaLy8A4uYUfdJbLwqiD2GYrSN_zt-O0nT68,20566
+pandas/tests/groupby/test_filters.pyc,,
+pandas/tests/groupby/test_function.py,sha256=2eA5x5xLbumbhRFNqf9BHnDJfzVMnCyUgoID1BUBUNk,38953
+pandas/tests/groupby/test_function.pyc,,
+pandas/tests/groupby/test_groupby.py,sha256=uAW6cMS_125GbKSSTG-O4YdRNR7L4eMkF9Fx_Epl90g,55886
+pandas/tests/groupby/test_groupby.pyc,,
+pandas/tests/groupby/test_grouping.py,sha256=WfyJtKuBvQZREzR7eOvPfHO0tX0gXHLJCxndA77RbF4,33092
+pandas/tests/groupby/test_grouping.pyc,,
+pandas/tests/groupby/test_index_as_string.py,sha256=xI9hogc0waAvI3pY0PjhTYUqUY6tRm8BgNwsYYA2N5A,2023
+pandas/tests/groupby/test_index_as_string.pyc,,
+pandas/tests/groupby/test_nth.py,sha256=5whS6p2MLC_jMX0BFaQCmYHBYLV4DOzXEJc7Pd0mfIg,15227
+pandas/tests/groupby/test_nth.pyc,,
+pandas/tests/groupby/test_rank.py,sha256=RexzAyktMt5w3zfHqLw372Ddxz4VP64gHOpn2_Eo9nA,13101
+pandas/tests/groupby/test_rank.pyc,,
+pandas/tests/groupby/test_timegrouper.py,sha256=t_Mp2lGAbe-gAPuKE3gxkGiifYN8nFfFn9IR3fCvpEE,26928
+pandas/tests/groupby/test_timegrouper.pyc,,
+pandas/tests/groupby/test_transform.py,sha256=mL3oUAjW5fuhuVYvvkSvJCpr5I3kgMV1xJwZskYRh6g,29478
+pandas/tests/groupby/test_transform.pyc,,
+pandas/tests/groupby/test_value_counts.py,sha256=Z9EF5DkTl93kcGFfd-_zQC-1KtCIn_PlUh7FVewWnok,2351
+pandas/tests/groupby/test_value_counts.pyc,,
+pandas/tests/groupby/test_whitelist.py,sha256=5O5BB-WNe3b0zOk566hBZRtNmLkOejCqBbI18X2LO0Q,8524
+pandas/tests/groupby/test_whitelist.pyc,,
+pandas/tests/indexes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/__init__.pyc,,
+pandas/tests/indexes/common.py,sha256=YiODkARuXDgvGY-G057iZfDGFl0caJzjhoT2YLZs5KM,34613
+pandas/tests/indexes/common.pyc,,
+pandas/tests/indexes/conftest.py,sha256=9hJQ9uIndOG832QWxpU7jUHK1LKpmFfvNaCs2_6BIKk,1648
+pandas/tests/indexes/conftest.pyc,,
+pandas/tests/indexes/datetimelike.py,sha256=rhprv26Iy7Shw6cxX-v7yUkdXfTGQhRzOTmHxL8m-AA,3115
+pandas/tests/indexes/datetimelike.pyc,,
+pandas/tests/indexes/datetimes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/datetimes/__init__.pyc,,
+pandas/tests/indexes/datetimes/test_arithmetic.py,sha256=K97z6mbYwbrvFI5FeW7prOS5XWEcA9tkvVH_9nWNhx0,4190
+pandas/tests/indexes/datetimes/test_arithmetic.pyc,,
+pandas/tests/indexes/datetimes/test_astype.py,sha256=3Gr1SHnsLwSmixnjfRyj770QOYw_KatN7tfWgS4o5zY,13785
+pandas/tests/indexes/datetimes/test_astype.pyc,,
+pandas/tests/indexes/datetimes/test_construction.py,sha256=1RrVFM1cqCjKtt1MSW0NEc5MmSRI5_EBzTn_YBY1dEE,34237
+pandas/tests/indexes/datetimes/test_construction.pyc,,
+pandas/tests/indexes/datetimes/test_date_range.py,sha256=9WFCHoWqQjphKxZh4XIRj6Y2gTsfNCq4jBPK3hqvwho,33932
+pandas/tests/indexes/datetimes/test_date_range.pyc,,
+pandas/tests/indexes/datetimes/test_datetime.py,sha256=VmpBfR955L3L6qYPWc2T86K2daTNcBHV578GfEK2EAs,15901
+pandas/tests/indexes/datetimes/test_datetime.pyc,,
+pandas/tests/indexes/datetimes/test_datetimelike.py,sha256=cIPmOATVaS_V57q00bXa38-c-GIabiop9uB3Cujs1LM,842
+pandas/tests/indexes/datetimes/test_datetimelike.pyc,,
+pandas/tests/indexes/datetimes/test_formats.py,sha256=KpZ-hPOiEY24LXs207ZpICxTeV-BUrv87xQehZL0N7Q,8703
+pandas/tests/indexes/datetimes/test_formats.pyc,,
+pandas/tests/indexes/datetimes/test_indexing.py,sha256=XYKChQ0Tyi69O4utFeoBP5A_qa3T_VzQNT1SN9G5hVU,25946
+pandas/tests/indexes/datetimes/test_indexing.pyc,,
+pandas/tests/indexes/datetimes/test_misc.py,sha256=NvXiR62_mM6moNH0hWgaTXqNZq_HlZV_1Tgjxftppn4,13834
+pandas/tests/indexes/datetimes/test_misc.pyc,,
+pandas/tests/indexes/datetimes/test_missing.py,sha256=V1DjwMQEg0IJuugmR3jskAUY79rSr4IKkkqcWiXU6xw,2032
+pandas/tests/indexes/datetimes/test_missing.pyc,,
+pandas/tests/indexes/datetimes/test_ops.py,sha256=qO5UNIfO8aLBpDlubZ5eZ2PtAace50SMAS7jL-PhovM,18405
+pandas/tests/indexes/datetimes/test_ops.pyc,,
+pandas/tests/indexes/datetimes/test_partial_slicing.py,sha256=Eaj51_FObcXWbH_56DLvfiDR80VAoBl-Nop8Fc0SHsQ,15550
+pandas/tests/indexes/datetimes/test_partial_slicing.pyc,,
+pandas/tests/indexes/datetimes/test_scalar_compat.py,sha256=Cti4nxN1C0hL6bLxrjhi87sEeR50YuBRqFsub6uCyq8,11036
+pandas/tests/indexes/datetimes/test_scalar_compat.pyc,,
+pandas/tests/indexes/datetimes/test_setops.py,sha256=iNAdPyD5pjTRFkYUOsTTgFFeV7YCg79f7mKqGwfMQew,17810
+pandas/tests/indexes/datetimes/test_setops.pyc,,
+pandas/tests/indexes/datetimes/test_timezones.py,sha256=z6nfjtVXPGlsKy3y2Y3e3cGZpAziXQHgQpNhwVk6HWM,46778
+pandas/tests/indexes/datetimes/test_timezones.pyc,,
+pandas/tests/indexes/datetimes/test_tools.py,sha256=VXzMxlKaL8sR1ycmmjewLnxb0ql7RyU_CxcUQ4aNSvs,75942
+pandas/tests/indexes/datetimes/test_tools.pyc,,
+pandas/tests/indexes/interval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/interval/__init__.pyc,,
+pandas/tests/indexes/interval/test_astype.py,sha256=hil1ny0DHwGGUUzIo8uPeC3FWfkKSsOp4UrKoa8DOsA,7900
+pandas/tests/indexes/interval/test_astype.pyc,,
+pandas/tests/indexes/interval/test_construction.py,sha256=zimLa-jAS_O4Qj5kRzrGd4kGSHycWYKm-k1AhZDem1U,15259
+pandas/tests/indexes/interval/test_construction.pyc,,
+pandas/tests/indexes/interval/test_interval.py,sha256=XCeYUy6LqTJ4JFMYnfIm-cDLEBQWuwQ9vyn1f0BhVjg,51553
+pandas/tests/indexes/interval/test_interval.pyc,,
+pandas/tests/indexes/interval/test_interval_new.py,sha256=3grXpDsNdlrfqORMVHRYNQtsEm53fG6oPvwU_TGsXpY,10996
+pandas/tests/indexes/interval/test_interval_new.pyc,,
+pandas/tests/indexes/interval/test_interval_range.py,sha256=SRF4PPg-w_t89AyFQt4UoifA7ZNRiRhv0yZgPuc5o_Y,12906
+pandas/tests/indexes/interval/test_interval_range.pyc,,
+pandas/tests/indexes/interval/test_interval_tree.py,sha256=A1LFHBb1NTEtqrS2tClKhvjbBFKcOwrXEqdI8mZue2o,6676
+pandas/tests/indexes/interval/test_interval_tree.pyc,,
+pandas/tests/indexes/multi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/multi/__init__.pyc,,
+pandas/tests/indexes/multi/conftest.py,sha256=iIL1MZTXsRtAIzYwQja-mRFg2cXoG5pZzHbiU3cfgSY,1568
+pandas/tests/indexes/multi/conftest.pyc,,
+pandas/tests/indexes/multi/test_analytics.py,sha256=77zx4sa6OJ9j_yLu-VnOrYeszEbTCWWN1oMsYS_8hl8,10192
+pandas/tests/indexes/multi/test_analytics.pyc,,
+pandas/tests/indexes/multi/test_astype.py,sha256=LtXoNSrNLypqRrwJio2ZhpZu2EamfOLPBRBzqclpfBk,985
+pandas/tests/indexes/multi/test_astype.pyc,,
+pandas/tests/indexes/multi/test_compat.py,sha256=kYeOBG-lNlfzpDRIItffMIG-Uhn874rMTuiBebFBeXo,3416
+pandas/tests/indexes/multi/test_compat.pyc,,
+pandas/tests/indexes/multi/test_constructor.py,sha256=Ds0O-XghQFlPBzX0QV_hAth6txn4vr6KNeV8etsIl0k,19941
+pandas/tests/indexes/multi/test_constructor.pyc,,
+pandas/tests/indexes/multi/test_contains.py,sha256=JB2IMqnGfZ3AxXW55h7IJdhnA65P6gUTxFLkQeSzOXs,3129
+pandas/tests/indexes/multi/test_contains.pyc,,
+pandas/tests/indexes/multi/test_conversion.py,sha256=6UcWuukSVKlo7KwB_hT-NOEN8XDXWnd3kehpIP9qMwY,7293
+pandas/tests/indexes/multi/test_conversion.pyc,,
+pandas/tests/indexes/multi/test_copy.py,sha256=E1xibCqWIZXHcJJd3GJKl--DGbTcLqDQCAeJ0hKZOPM,2486
+pandas/tests/indexes/multi/test_copy.pyc,,
+pandas/tests/indexes/multi/test_drop.py,sha256=sOoMSO3WNR2E4SLlxkgoMuWDIrr38pL8erlV88R0NmA,4143
+pandas/tests/indexes/multi/test_drop.pyc,,
+pandas/tests/indexes/multi/test_duplicates.py,sha256=ueZgv7KHil20s4MPVj6fX1HwEu5QY3pv5UxhDgH48d0,9972
+pandas/tests/indexes/multi/test_duplicates.pyc,,
+pandas/tests/indexes/multi/test_equivalence.py,sha256=Wc4KfPHJDqNhfaImuzgx_rC8TND8t7NmksN9WaRRZ20,6970
+pandas/tests/indexes/multi/test_equivalence.pyc,,
+pandas/tests/indexes/multi/test_format.py,sha256=lm3qMcPDZovDfNwRpe7fsAFRvGP06od2L4XpN6OLYRY,3635
+pandas/tests/indexes/multi/test_format.pyc,,
+pandas/tests/indexes/multi/test_get_set.py,sha256=NRBjSxpz-fAHea6pvXErgG1BQZbv81tgDJQGeFDtV4E,15757
+pandas/tests/indexes/multi/test_get_set.pyc,,
+pandas/tests/indexes/multi/test_indexing.py,sha256=J8z1Vri2OAeUD77EvSqlm1eLKpuIAVaAxv8wv3FfvmU,12184
+pandas/tests/indexes/multi/test_indexing.pyc,,
+pandas/tests/indexes/multi/test_integrity.py,sha256=gbYItT4If5x-lKoHNvP7o6YZSA3piR2dYjMmpLtQ54Y,9162
+pandas/tests/indexes/multi/test_integrity.pyc,,
+pandas/tests/indexes/multi/test_join.py,sha256=5H3L1IsaERp-zlQCn_6fdrtmEQwbsrsLaougFubT6sk,3168
+pandas/tests/indexes/multi/test_join.pyc,,
+pandas/tests/indexes/multi/test_missing.py,sha256=aSTKd9fGyaBZSPolaF7uW3R0iNaELW70Uf44sGo3SYY,4113
+pandas/tests/indexes/multi/test_missing.pyc,,
+pandas/tests/indexes/multi/test_monotonic.py,sha256=Y46jz0ciq0Rq1SIHLsltb32z45xnXjFWzpwzHtaoYAo,8777
+pandas/tests/indexes/multi/test_monotonic.pyc,,
+pandas/tests/indexes/multi/test_names.py,sha256=UnIIsKxjK_UBGyBzRf2NQQipBEgsxC3gFRWlm4bWB2w,3942
+pandas/tests/indexes/multi/test_names.pyc,,
+pandas/tests/indexes/multi/test_partial_indexing.py,sha256=TCVkSEi0Nd_qprx3jcoWLcMnET4xg-3r-Bwp8NSsHEQ,3298
+pandas/tests/indexes/multi/test_partial_indexing.pyc,,
+pandas/tests/indexes/multi/test_reindex.py,sha256=HsjPsdTBxfL2s8ljEH-hJodkdR0iNtER9zJ3MMOSR1M,3759
+pandas/tests/indexes/multi/test_reindex.pyc,,
+pandas/tests/indexes/multi/test_reshape.py,sha256=R48FJORYTRFfYH50s9UyFqtf3Rw10Plm1eso0m0zIkI,3516
+pandas/tests/indexes/multi/test_reshape.pyc,,
+pandas/tests/indexes/multi/test_set_ops.py,sha256=IqbNb2WT4fEs7kyJMbCLsNTWmyRpG93kexGuWKRyzj8,11567
+pandas/tests/indexes/multi/test_set_ops.pyc,,
+pandas/tests/indexes/multi/test_sorting.py,sha256=iqTBolmcJmgr7MZxoy0WI70KJLAA0id0lH0pmEiIGWc,8624
+pandas/tests/indexes/multi/test_sorting.pyc,,
+pandas/tests/indexes/period/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/period/__init__.pyc,,
+pandas/tests/indexes/period/test_arithmetic.py,sha256=Ctkrd4zIruqjmkIB3q0SQnKaI4DSSOs7GRSX7vknilg,4539
+pandas/tests/indexes/period/test_arithmetic.pyc,,
+pandas/tests/indexes/period/test_asfreq.py,sha256=kAmboHhG84zzB8augrt7hbyqGAXjfqf7tpcVya3gHSs,6367
+pandas/tests/indexes/period/test_asfreq.pyc,,
+pandas/tests/indexes/period/test_astype.py,sha256=frucM9nIf_RWdofgCJWxHeQsTNTJRVP8YAM5lCYJWhc,5097
+pandas/tests/indexes/period/test_astype.pyc,,
+pandas/tests/indexes/period/test_construction.py,sha256=knxf_afhjseVy8aaaEe_WZCtI5bmsa7cXbGSHw50s-A,20424
+pandas/tests/indexes/period/test_construction.pyc,,
+pandas/tests/indexes/period/test_formats.py,sha256=zQsLnKOswKvXKscn4t15f0AMWgnDUs0qcGdji8Ssffs,7527
+pandas/tests/indexes/period/test_formats.pyc,,
+pandas/tests/indexes/period/test_indexing.py,sha256=FwC_UTkKIcWlSc7g1mA8ZfzUlJdjbS6_n5wTBtPQv9g,24776
+pandas/tests/indexes/period/test_indexing.pyc,,
+pandas/tests/indexes/period/test_ops.py,sha256=59uhvCgdEWH0Zhx6RVEOMDMxQFB77lzv2X9m2QZ1k1M,13633
+pandas/tests/indexes/period/test_ops.pyc,,
+pandas/tests/indexes/period/test_partial_slicing.py,sha256=Gb8Y_i7TJ9AN5bI10k_WQuCtml99-QLBBeSH0DAphv8,5498
+pandas/tests/indexes/period/test_partial_slicing.pyc,,
+pandas/tests/indexes/period/test_period.py,sha256=eLTjmk8FL82-e2H8heCfr6wQn4sZHyKJTIOjlpHKpww,21238
+pandas/tests/indexes/period/test_period.pyc,,
+pandas/tests/indexes/period/test_period_range.py,sha256=hCxBHDDMrhub5P4eYJdtDtkWsziIyphnqq_NioyKLn4,3623
+pandas/tests/indexes/period/test_period_range.pyc,,
+pandas/tests/indexes/period/test_scalar_compat.py,sha256=e71pjmODPZWVQ1bmjmNuyhl1Hhcujo9HNkonKYXDWNA,781
+pandas/tests/indexes/period/test_scalar_compat.pyc,,
+pandas/tests/indexes/period/test_setops.py,sha256=Y3oo5yO_bHuLeakh8mfr53X0FraaIdSH2pnlidrSxdA,12321
+pandas/tests/indexes/period/test_setops.pyc,,
+pandas/tests/indexes/period/test_tools.py,sha256=Bf5UHmVmPO5wgkaMXqiFkrWiPbujTQrTn7UvHCxd6WU,13520
+pandas/tests/indexes/period/test_tools.pyc,,
+pandas/tests/indexes/test_base.py,sha256=pJoO2CaSHJ0TeUJCGS2kBExQTfVmV7jGJYp4lQKW7Xg,101609
+pandas/tests/indexes/test_base.pyc,,
+pandas/tests/indexes/test_category.py,sha256=c6Kge-qOOJt-PpPgSj0CARgwkpLX3Be4tpVtzijqzLY,48766
+pandas/tests/indexes/test_category.pyc,,
+pandas/tests/indexes/test_common.py,sha256=OaOnrnJRRPQt4wM3K7JDWJ1H7i8838bu4LQTp0JlUQY,12813
+pandas/tests/indexes/test_common.pyc,,
+pandas/tests/indexes/test_frozen.py,sha256=oKj-QywWU_nwXoId7l_W__kAwfSwkNaKJjqAZFLhFLs,3495
+pandas/tests/indexes/test_frozen.pyc,,
+pandas/tests/indexes/test_numeric.py,sha256=_wmGYRmIuS9F2BeXxtM3R-7MoVHXy18n7qpFyuBFl6w,40845
+pandas/tests/indexes/test_numeric.pyc,,
+pandas/tests/indexes/test_range.py,sha256=bYVvzgtGMBLgzKbiAHAzaAumu_LVrPmH81-NUbb303I,31703
+pandas/tests/indexes/test_range.pyc,,
+pandas/tests/indexes/timedeltas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexes/timedeltas/__init__.pyc,,
+pandas/tests/indexes/timedeltas/test_arithmetic.py,sha256=8I3Iej0jAHwp7t3SrXWTKMku_hwkCwwKaKWvLulmEL4,10725
+pandas/tests/indexes/timedeltas/test_arithmetic.pyc,,
+pandas/tests/indexes/timedeltas/test_astype.py,sha256=Zb2S4IQvKFF59IOb7Noz94oRyRoPGrMq1DrLQvyqFao,4066
+pandas/tests/indexes/timedeltas/test_astype.pyc,,
+pandas/tests/indexes/timedeltas/test_construction.py,sha256=Ek2mf89XgadCSlMsxpqEkCaSzv-kQ4PyRnRh4chLm14,7916
+pandas/tests/indexes/timedeltas/test_construction.pyc,,
+pandas/tests/indexes/timedeltas/test_formats.py,sha256=P4efjnSJNNbt-wCFRa9XatCkIrQ47ytp85dGis7C_4Y,3573
+pandas/tests/indexes/timedeltas/test_formats.pyc,,
+pandas/tests/indexes/timedeltas/test_indexing.py,sha256=pUAK6tYPbsd6WcHNGWzCUIcs86fJ_TznBfMC-p8U7SA,13533
+pandas/tests/indexes/timedeltas/test_indexing.pyc,,
+pandas/tests/indexes/timedeltas/test_ops.py,sha256=d-6Yt4hZt_c1a-868-l6Lx3-ck6jJAeVadILMNYrCdc,11098
+pandas/tests/indexes/timedeltas/test_ops.pyc,,
+pandas/tests/indexes/timedeltas/test_partial_slicing.py,sha256=Rodv0oPmGWvUIIU7PHV_hoofIvnqEOam_QJKvEFyDZE,3107
+pandas/tests/indexes/timedeltas/test_partial_slicing.pyc,,
+pandas/tests/indexes/timedeltas/test_scalar_compat.py,sha256=zDE7EbcW_UlBsB2bQp0fWIS9V_slw-In8f6b-Fr4jCs,2423
+pandas/tests/indexes/timedeltas/test_scalar_compat.pyc,,
+pandas/tests/indexes/timedeltas/test_setops.py,sha256=zwvTOcDKkZchn65FvMME5DPT17nzwC3ljC4VCAmQnEs,2521
+pandas/tests/indexes/timedeltas/test_setops.pyc,,
+pandas/tests/indexes/timedeltas/test_timedelta.py,sha256=rKEU5QWLs7dXVlMTYzgp07R0nczcWljyVHEccrRxDpA,11213
+pandas/tests/indexes/timedeltas/test_timedelta.pyc,,
+pandas/tests/indexes/timedeltas/test_timedelta_range.py,sha256=sGvWRtlBvpFNyEo2H5CALoxkH_FaWhthzo6ldRH8xqE,3002
+pandas/tests/indexes/timedeltas/test_timedelta_range.pyc,,
+pandas/tests/indexes/timedeltas/test_tools.py,sha256=1ANYnovdwkQq8nU5T0NMyfEpAt9Jso2AjQySyZTCkpw,6893
+pandas/tests/indexes/timedeltas/test_tools.pyc,,
+pandas/tests/indexing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexing/__init__.pyc,,
+pandas/tests/indexing/common.py,sha256=f6we4e7eVaM1Is4CFq_7a1A9wqr1AATnPz3nJjdXy7c,10912
+pandas/tests/indexing/common.pyc,,
+pandas/tests/indexing/conftest.py,sha256=u3_F4gTBdBeR8Ahd_HZaY-QdCKY8VQ0Cgk4KuVhd1j8,606
+pandas/tests/indexing/conftest.pyc,,
+pandas/tests/indexing/interval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexing/interval/__init__.pyc,,
+pandas/tests/indexing/interval/test_interval.py,sha256=lz5XXQx-fb-f-Azp9YQkA3Dt8-vByKa7nX6T1LdvFd4,7948
+pandas/tests/indexing/interval/test_interval.pyc,,
+pandas/tests/indexing/interval/test_interval_new.py,sha256=ZLNQ68KWnEd1oTCdu2JWws0jHv5pldL-sn2uPmHRJ-Y,7254
+pandas/tests/indexing/interval/test_interval_new.pyc,,
+pandas/tests/indexing/multiindex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/indexing/multiindex/__init__.pyc,,
+pandas/tests/indexing/multiindex/conftest.py,sha256=BcCZACd-d9cxwgz1HYMv-m3YsTRElqt6Yt73ZmoKgdk,1273
+pandas/tests/indexing/multiindex/conftest.pyc,,
+pandas/tests/indexing/multiindex/test_chaining_and_caching.py,sha256=YisJl_aE2N4W30TKYa9UuLUR13Q4UUzipRvgn4Bz0TY,1964
+pandas/tests/indexing/multiindex/test_chaining_and_caching.pyc,,
+pandas/tests/indexing/multiindex/test_datetime.py,sha256=bv5KGd2X7JWxCPYVSWGrRDL4JA8ygN1fDTQXz5e8tfA,613
+pandas/tests/indexing/multiindex/test_datetime.pyc,,
+pandas/tests/indexing/multiindex/test_getitem.py,sha256=4-HO26SvHDyZN06VBYODw3-DYNboMjFs3cx9ghH5hao,8778
+pandas/tests/indexing/multiindex/test_getitem.pyc,,
+pandas/tests/indexing/multiindex/test_iloc.py,sha256=A9-jtobeReAWd3bxKZBFrm9xkfwnScHg7LBW1OAwffU,4872
+pandas/tests/indexing/multiindex/test_iloc.pyc,,
+pandas/tests/indexing/multiindex/test_indexing_slow.py,sha256=_12H0rZpB01Z3MJAgEib3qDBTruXIPaM_Zjvj3KEOzg,3162
+pandas/tests/indexing/multiindex/test_indexing_slow.pyc,,
+pandas/tests/indexing/multiindex/test_ix.py,sha256=GM1TA3h83x00ezxpT-WBjW0tfKi7uppXHJRjfK7Y7ZA,1878
+pandas/tests/indexing/multiindex/test_ix.pyc,,
+pandas/tests/indexing/multiindex/test_loc.py,sha256=1DdHbGSxPdQm_tsGM7Fji1khLjQhPXGgJwwqRBsqLdY,13266
+pandas/tests/indexing/multiindex/test_loc.pyc,,
+pandas/tests/indexing/multiindex/test_multiindex.py,sha256=3i6kQNI_ifyVJ1xlW7G1fY3x3eWiJlT5xLJbrLNL23M,2945
+pandas/tests/indexing/multiindex/test_multiindex.pyc,,
+pandas/tests/indexing/multiindex/test_panel.py,sha256=XmIsk9TWTdwH618b1VXx97n4AOldSI9HeqBhhmC04Qo,3761
+pandas/tests/indexing/multiindex/test_panel.pyc,,
+pandas/tests/indexing/multiindex/test_partial.py,sha256=EkI8dcPwIcwGZg3-F1dQo0GFcG1Nn9qQVOTaFBUOZps,6424
+pandas/tests/indexing/multiindex/test_partial.pyc,,
+pandas/tests/indexing/multiindex/test_set_ops.py,sha256=rtyqgiK19sxRyqzdXMMwRN67LrrTPyauaqc89vtvc7o,1443
+pandas/tests/indexing/multiindex/test_set_ops.pyc,,
+pandas/tests/indexing/multiindex/test_setitem.py,sha256=JjcmPEBBE0j1EkVPnGgC-6nXO3EO4JXgGO4GKITd2U4,16225
+pandas/tests/indexing/multiindex/test_setitem.pyc,,
+pandas/tests/indexing/multiindex/test_slice.py,sha256=RIvyFVDDLz0AgTL0BqbAdfxBIZfE67bDJpu7L7K6XXA,23104
+pandas/tests/indexing/multiindex/test_slice.pyc,,
+pandas/tests/indexing/multiindex/test_sorted.py,sha256=9d9zoHb8TEtdfUdH5jkDjeN5Fd9OILMC3lviv-QJy8A,3409
+pandas/tests/indexing/multiindex/test_sorted.pyc,,
+pandas/tests/indexing/multiindex/test_xs.py,sha256=J2u8EZcruXS99yXZaNCKbW5M6xIUJq54dVhtDifZav4,8158
+pandas/tests/indexing/multiindex/test_xs.pyc,,
+pandas/tests/indexing/test_callable.py,sha256=Qd5CLpEbViY0avcq6nI4c2CpeAqgwWgtC48YmYY3_eg,8722
+pandas/tests/indexing/test_callable.pyc,,
+pandas/tests/indexing/test_categorical.py,sha256=c6mR59Mw_mxdqGKtH_RKtqw0jxN6uv4QNLPQylOuDNU,26810
+pandas/tests/indexing/test_categorical.pyc,,
+pandas/tests/indexing/test_chaining_and_caching.py,sha256=GSqPPATLboLALNqUh-HCgBszAXPXjn83f2uQNfEw1kM,13520
+pandas/tests/indexing/test_chaining_and_caching.pyc,,
+pandas/tests/indexing/test_coercion.py,sha256=5q4kcF30kCf5f3zCCcwekkC-T-i6wiat1zEZuTlYuvc,35792
+pandas/tests/indexing/test_coercion.pyc,,
+pandas/tests/indexing/test_datetime.py,sha256=Kz_ncuyGz9tI5vfABiWjQaxKynzbB5-6mKGkTXMLkbg,11482
+pandas/tests/indexing/test_datetime.pyc,,
+pandas/tests/indexing/test_floats.py,sha256=IBGIDtaTmSVQqIYC8HffWY7X9Ygnqxj0ZMMHfTYRlH8,28404
+pandas/tests/indexing/test_floats.pyc,,
+pandas/tests/indexing/test_iloc.py,sha256=EKUhDeGiTvfEbXxxbFz_eVwAbw4iuSBF8By5rCsMmVY,24426
+pandas/tests/indexing/test_iloc.pyc,,
+pandas/tests/indexing/test_indexing.py,sha256=-4g3aOiFJyCX_dc5Q8MfuaXtXwGVqkrZF56i4dwYk2U,37009
+pandas/tests/indexing/test_indexing.pyc,,
+pandas/tests/indexing/test_indexing_engines.py,sha256=X-mNVMpamGbQvn3AFZecmWwotkjEi_IZmqherzWg61U,6145
+pandas/tests/indexing/test_indexing_engines.pyc,,
+pandas/tests/indexing/test_indexing_slow.py,sha256=AYeLis6QWoBXjtFWVfiBwZx-bIhXWrXZW5G1eoXChnA,456
+pandas/tests/indexing/test_indexing_slow.pyc,,
+pandas/tests/indexing/test_ix.py,sha256=Hw7hXvvNZp_IOxd7dp73Hatg89LP9h5-K4UkOA_2WaQ,11583
+pandas/tests/indexing/test_ix.pyc,,
+pandas/tests/indexing/test_loc.py,sha256=k_uE1Xfq-IPCOBlsBgFR0IYpyMlX8Yk9QyMApfdMPxo,29931
+pandas/tests/indexing/test_loc.pyc,,
+pandas/tests/indexing/test_panel.py,sha256=zCDnySid5TkExJlz5Cex6lw8PPAGy-HVulB-14thFyc,7529
+pandas/tests/indexing/test_panel.pyc,,
+pandas/tests/indexing/test_partial.py,sha256=AZMhNAbtWsGcUORM4OUo1LhU4XHDE28NROfZzlYx_N8,23326
+pandas/tests/indexing/test_partial.pyc,,
+pandas/tests/indexing/test_scalar.py,sha256=3ex1ISUPddQFaUBOJQv4xQHQlSiZ64FNn0dcxx85haM,6591
+pandas/tests/indexing/test_scalar.pyc,,
+pandas/tests/indexing/test_timedelta.py,sha256=XUAkKyyLDnFoVm7NGsEtoUIY_eR3jyFErGmSfYYS-S0,3710
+pandas/tests/indexing/test_timedelta.pyc,,
+pandas/tests/internals/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/internals/__init__.pyc,,
+pandas/tests/internals/test_internals.py,sha256=iSNr3rPR8XDFkcxuq50YbwpglOxKx29jSCQa2hMZRMk,48902
+pandas/tests/internals/test_internals.pyc,,
+pandas/tests/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/__init__.pyc,,
+pandas/tests/io/conftest.py,sha256=-ldEpNdisfalmiJS2utrHnqV9hjCXkWgiPnv8prMCSE,2660
+pandas/tests/io/conftest.pyc,,
+pandas/tests/io/formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/formats/__init__.pyc,,
+pandas/tests/io/formats/test_console.py,sha256=8Bu9UNRjDJs8WV10KCneXvLXiXB379ikegICPjgqxF8,3042
+pandas/tests/io/formats/test_console.pyc,,
+pandas/tests/io/formats/test_css.py,sha256=KNOaKHzabraZEIkhV9R3fmtLYgIt53xmChgLd9BsC8c,6472
+pandas/tests/io/formats/test_css.pyc,,
+pandas/tests/io/formats/test_eng_formatting.py,sha256=meWot7GaqBsu5du-zP67JYIcssued_FnxJTAFWzNFs8,8088
+pandas/tests/io/formats/test_eng_formatting.pyc,,
+pandas/tests/io/formats/test_format.py,sha256=1tzcbf2SpUJ4B6aDI-gA4eyUDuwcH3IHs2rftUZfn4s,110932
+pandas/tests/io/formats/test_format.pyc,,
+pandas/tests/io/formats/test_printing.py,sha256=YU2rpSCHozt161dwPX1WSLztIbcdcxildxYADCzPJgI,6914
+pandas/tests/io/formats/test_printing.pyc,,
+pandas/tests/io/formats/test_style.py,sha256=uH-0nNIJ42KqqjCLva54G2s04d7dYMk0Qkcf5_hfiPg,54964
+pandas/tests/io/formats/test_style.pyc,,
+pandas/tests/io/formats/test_to_csv.py,sha256=1mauIW_CCjh9Zf4OeXsqZnDlfGbjsx_GoRrv5Kz501o,20360
+pandas/tests/io/formats/test_to_csv.pyc,,
+pandas/tests/io/formats/test_to_excel.py,sha256=8F5LGi-S0TtP2-S5RlGGFBOxQx_tTh3hzkOc3DywTfI,10955
+pandas/tests/io/formats/test_to_excel.pyc,,
+pandas/tests/io/formats/test_to_html.py,sha256=uj7i_5O38Jdq7xbTDaIgg70w64Xw1e8LEvLa7QU95_s,20590
+pandas/tests/io/formats/test_to_html.pyc,,
+pandas/tests/io/formats/test_to_latex.py,sha256=bk6O0NxWrDOCvzXp50Zg0U0cu1i1ypoWlDBEp97Uj9I,19274
+pandas/tests/io/formats/test_to_latex.pyc,,
+pandas/tests/io/generate_legacy_storage_files.py,sha256=QD1F65qM7UnXS1BL9a2mHi1nWGANDl7AVWkvwy4l7O0,13572
+pandas/tests/io/generate_legacy_storage_files.pyc,,
+pandas/tests/io/json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/json/__init__.pyc,,
+pandas/tests/io/json/test_compression.py,sha256=YlCEYTReLIDg9-uzR0MM2cxTz6nm4fJxeNhJGJUFvYM,4162
+pandas/tests/io/json/test_compression.pyc,,
+pandas/tests/io/json/test_json_table_schema.py,sha256=wBIQQXvkRBgFF8jpMYZpRq3ncQ2wpHjiHTG32xQRJv8,24173
+pandas/tests/io/json/test_json_table_schema.pyc,,
+pandas/tests/io/json/test_normalize.py,sha256=qeFWeM08nESOAEmTirNyelLHKVUT8VtIu7NfHeS1VIk,17294
+pandas/tests/io/json/test_normalize.pyc,,
+pandas/tests/io/json/test_pandas.py,sha256=w1WdwzmL8Ca1p7J2WEcfNDdwAYppqpvADG1zhBfomKQ,52182
+pandas/tests/io/json/test_pandas.pyc,,
+pandas/tests/io/json/test_readlines.py,sha256=R6W9d3_y95FPdrxOhbX5iO5uodPSDJbIIB2zo_4N9rU,5721
+pandas/tests/io/json/test_readlines.pyc,,
+pandas/tests/io/json/test_ujson.py,sha256=kHBDjjUfoROz4YB0JxxHW9f48ds1IX2VD1DVlToA6B8,38511
+pandas/tests/io/json/test_ujson.pyc,,
+pandas/tests/io/msgpack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/msgpack/__init__.pyc,,
+pandas/tests/io/msgpack/common.py,sha256=6f9-jF0K0MPAJCk7TjsIF4nKFKPuVKiVufHaDYIwrwk,250
+pandas/tests/io/msgpack/common.pyc,,
+pandas/tests/io/msgpack/test_buffer.py,sha256=9zqkQNQb8FkfnR_oFn-xDGayDknBWGcwT67gX_u8qfM,508
+pandas/tests/io/msgpack/test_buffer.pyc,,
+pandas/tests/io/msgpack/test_case.py,sha256=Nwa0Wp4V20609-6csppOoGQQ6o2KdEs8DtPzaEM_O08,2724
+pandas/tests/io/msgpack/test_case.pyc,,
+pandas/tests/io/msgpack/test_except.py,sha256=a-Vs-MzgCvEwLV_QOTNJ04CynZJDiRP27utFSwbznoc,1177
+pandas/tests/io/msgpack/test_except.pyc,,
+pandas/tests/io/msgpack/test_extension.py,sha256=oIAfK9xulWH6nwyJMx9-HJ_2_uX_odU7_2wcwONSx10,2206
+pandas/tests/io/msgpack/test_extension.pyc,,
+pandas/tests/io/msgpack/test_format.py,sha256=x5hgz_1uqrthOnKQM2Es8qUjBXekvFODHsAY11sQQPA,2882
+pandas/tests/io/msgpack/test_format.pyc,,
+pandas/tests/io/msgpack/test_limits.py,sha256=Yc9tBbMijeVhNUMalnsphVkZ9ohrr94GhHxbgLeFaEc,3103
+pandas/tests/io/msgpack/test_limits.pyc,,
+pandas/tests/io/msgpack/test_newspec.py,sha256=FOIivIYGqZxRusUeg91jpRPFULnq2-Rah4SYo478Cl0,2650
+pandas/tests/io/msgpack/test_newspec.pyc,,
+pandas/tests/io/msgpack/test_obj.py,sha256=UgTPNUbuz7_zZYVXclweNUEoE0keDFhZ_CH_L1oDkNQ,2545
+pandas/tests/io/msgpack/test_obj.pyc,,
+pandas/tests/io/msgpack/test_pack.py,sha256=gP2cC_VAHE9ujqwu4ShwqAfpcMOvGnDRyO7Z3lqiKb0,5296
+pandas/tests/io/msgpack/test_pack.pyc,,
+pandas/tests/io/msgpack/test_read_size.py,sha256=S50d3PNe2r293Es-aa0Zd6EeXTFcholk4oJxbjmow_c,1871
+pandas/tests/io/msgpack/test_read_size.pyc,,
+pandas/tests/io/msgpack/test_seq.py,sha256=N2Bj-C4GmgemI8nWKQxZbRFTOCdSZ83ahwQ3EovOYBE,1171
+pandas/tests/io/msgpack/test_seq.pyc,,
+pandas/tests/io/msgpack/test_sequnpack.py,sha256=vcyEAD3hr085wZmmeEO36dNWnbrJBbkFf9DPZoY1hZk,3464
+pandas/tests/io/msgpack/test_sequnpack.pyc,,
+pandas/tests/io/msgpack/test_subtype.py,sha256=h4tPYBFmEJiP6BcG9IJviVYFjt3hShaylUqTH30xFzA,397
+pandas/tests/io/msgpack/test_subtype.pyc,,
+pandas/tests/io/msgpack/test_unpack.py,sha256=edC_E-mmLfsLC4U9mnfdfdBVU3qLm5SlbhJSpkNFgzk,2019
+pandas/tests/io/msgpack/test_unpack.pyc,,
+pandas/tests/io/msgpack/test_unpack_raw.py,sha256=ZfaQ5hlvFUoGqVoSMzSbB0z2ZAIGkeCb8P3RKTHJg_w,798
+pandas/tests/io/msgpack/test_unpack_raw.pyc,,
+pandas/tests/io/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/parser/__init__.pyc,,
+pandas/tests/io/parser/conftest.py,sha256=yId97wjVxnMkpdeNjZmSRwxjA5xtdyEkfO7zdTbolk0,1882
+pandas/tests/io/parser/conftest.pyc,,
+pandas/tests/io/parser/test_c_parser_only.py,sha256=NlzcStNPP-8j9hXhBt0LeuU1t1z_AoXSXWkUYWKtUmo,20312
+pandas/tests/io/parser/test_c_parser_only.pyc,,
+pandas/tests/io/parser/test_comment.py,sha256=gODvslASrxs2A2t7dVTbjOrz6IVLzBncbtvr0pzFP-4,3939
+pandas/tests/io/parser/test_comment.pyc,,
+pandas/tests/io/parser/test_common.py,sha256=gHB_Yup8GcgIoAF01z__RKsnwKR4REn2v9bC3eCioHg,60631
+pandas/tests/io/parser/test_common.pyc,,
+pandas/tests/io/parser/test_compression.py,sha256=qxUt7BP3xJVfGuHMJ5MEOopCs2-3doHXZuPN86R4Gyw,4647
+pandas/tests/io/parser/test_compression.pyc,,
+pandas/tests/io/parser/test_converters.py,sha256=0LoDlACfNKr9eEdlYMNOWT2B0KE2tVWRZ7EBI3AFnAE,4164
+pandas/tests/io/parser/test_converters.pyc,,
+pandas/tests/io/parser/test_dialect.py,sha256=MQssw_sMLwQJIoqqe6cCNrjlYgxjzfg6BvuthD5YpzE,4238
+pandas/tests/io/parser/test_dialect.pyc,,
+pandas/tests/io/parser/test_dtypes.py,sha256=bFD7J7y-cTEDAyJs_Oeb4_A-kpDwEOlE8xN2zRBEmYY,16415
+pandas/tests/io/parser/test_dtypes.pyc,,
+pandas/tests/io/parser/test_header.py,sha256=3jn5eDp7mjSZ2jA0ZNTFOSdhqvs83X5zDe3RyzNmhaU,14241
+pandas/tests/io/parser/test_header.pyc,,
+pandas/tests/io/parser/test_index_col.py,sha256=GRQU1V442nYYYMP8xD6ATmFSlb0cV2L9PeqCFPXFsnE,5272
+pandas/tests/io/parser/test_index_col.pyc,,
+pandas/tests/io/parser/test_mangle_dupes.py,sha256=uMV9AOYTekZsX0ZH3JZZsSjFrIO5Z0v7OgSM1IT7R2A,3922
+pandas/tests/io/parser/test_mangle_dupes.pyc,,
+pandas/tests/io/parser/test_multi_thread.py,sha256=bjdFRvteNi0R7Keqj3rMC25-7rVmDgoOrwI0j4iSUF8,3619
+pandas/tests/io/parser/test_multi_thread.pyc,,
+pandas/tests/io/parser/test_na_values.py,sha256=Q4VWoC19euNO0J6VXnka8lvTG8_cJLPZhPeTFv2CisI,14046
+pandas/tests/io/parser/test_na_values.pyc,,
+pandas/tests/io/parser/test_network.py,sha256=rJbe1a-p-ygQd_FFIP2LTqdefNuRtnc21ys0c8ssjb0,7742
+pandas/tests/io/parser/test_network.pyc,,
+pandas/tests/io/parser/test_parse_dates.py,sha256=KB_TYkQfC2J0yqLdWX_PF3YpBulmQ_QlXR3N15H9jro,34187
+pandas/tests/io/parser/test_parse_dates.pyc,,
+pandas/tests/io/parser/test_python_parser_only.py,sha256=XUzDfPRxhuh8n85rp3tikrrzjqdZXlwMyIb0jIELwNs,9543
+pandas/tests/io/parser/test_python_parser_only.pyc,,
+pandas/tests/io/parser/test_quoting.py,sha256=ulA6DFlVQf9MMdhcrYcDf6FTK6RkQhFQss3HRzKG0eA,5163
+pandas/tests/io/parser/test_quoting.pyc,,
+pandas/tests/io/parser/test_read_fwf.py,sha256=eii7fL8_Bf5jJ7pWwdx07dUgj4LHMvVVGQjH1WpCiqk,19195
+pandas/tests/io/parser/test_read_fwf.pyc,,
+pandas/tests/io/parser/test_skiprows.py,sha256=1us59HAqwhymP9AEZkWy96P03xajHjHb02L0W33V-AI,6948
+pandas/tests/io/parser/test_skiprows.pyc,,
+pandas/tests/io/parser/test_textreader.py,sha256=o2WzKktox1r5-fxA3k6e5_dXOVw_QSiT--bvl7PjCoE,11518
+pandas/tests/io/parser/test_textreader.pyc,,
+pandas/tests/io/parser/test_unsupported.py,sha256=RDiibmVhCZ5z66J5lLxpEuLpSXPil2N_ctL031DmF5w,4842
+pandas/tests/io/parser/test_unsupported.pyc,,
+pandas/tests/io/parser/test_usecols.py,sha256=T4ziZc5VeKqX2W4jcrVtPNAEXx-6NyMWAgEe4mZdTE8,16457
+pandas/tests/io/parser/test_usecols.pyc,,
+pandas/tests/io/sas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/io/sas/__init__.pyc,,
+pandas/tests/io/sas/test_sas.py,sha256=T5LC2aM-aVPzyCrV9e4AcdiDUpM_SUw4zJ5-aYjt8go,702
+pandas/tests/io/sas/test_sas.pyc,,
+pandas/tests/io/sas/test_sas7bdat.py,sha256=Bys4wGj-jW1Fe4yUslkzXdRkG6XD5PmKwJCiHWdMseI,8329
+pandas/tests/io/sas/test_sas7bdat.pyc,,
+pandas/tests/io/sas/test_xport.py,sha256=ihrAerKJZJKXuSkiPe9Md4cLrfFoczCST0IO4QgjL2w,4895
+pandas/tests/io/sas/test_xport.pyc,,
+pandas/tests/io/test_clipboard.py,sha256=yfKRKfGnnK8wPxNW4ifx-2_Xr6eLssLjep0oAkTnn2A,8025
+pandas/tests/io/test_clipboard.pyc,,
+pandas/tests/io/test_common.py,sha256=Fi8n2iZOiCc91zu2HZ2RgSQQYtPiDDquxfP1U7c-Sfk,12833
+pandas/tests/io/test_common.pyc,,
+pandas/tests/io/test_compression.py,sha256=8kndSrch3IWh3PzeETZES4Z_A1YZZe0CnTnb7Nr5Hc0,4797
+pandas/tests/io/test_compression.pyc,,
+pandas/tests/io/test_date_converters.py,sha256=75jpLSGTQEJFBWAEMxV9voL_9VbNSgjAZWDp9LD8_2E,1289
+pandas/tests/io/test_date_converters.pyc,,
+pandas/tests/io/test_excel.py,sha256=-4I0VStPKA3nVwYoLH84hFO_Ie4H1C1nSFFRa7nNYoI,102131
+pandas/tests/io/test_excel.pyc,,
+pandas/tests/io/test_feather.py,sha256=XmUPae7GuQR1LX1BSDSUeHtf61aOVkA0UiusAS50O2I,5734
+pandas/tests/io/test_feather.pyc,,
+pandas/tests/io/test_gbq.py,sha256=OZ3-lm_DOW42ECp2t10JR_m-gD39tYuJVa0EZrQ-kmo,4865
+pandas/tests/io/test_gbq.pyc,,
+pandas/tests/io/test_gcs.py,sha256=hJwCZe6UTSRc7RZzo5DQh3XXDbLNpTtzd-Kh3TS2asM,2325
+pandas/tests/io/test_gcs.pyc,,
+pandas/tests/io/test_html.py,sha256=_EHzn2Q7wYcD_LKXu1FIECvFjmEgRx6ev_SZBM1A1Yg,39547
+pandas/tests/io/test_html.pyc,,
+pandas/tests/io/test_packers.py,sha256=oWn0psJIGb4gEnPl_v7Ehi5PkYemZD1nu8rvoAndFNw,33322
+pandas/tests/io/test_packers.pyc,,
+pandas/tests/io/test_parquet.py,sha256=0mcuiokfzyxx9TmmMLfNjaqg9M3jpZqTolxi0LZvm0Y,18796
+pandas/tests/io/test_parquet.pyc,,
+pandas/tests/io/test_pickle.py,sha256=9RdO2QLQU0L23K9kP2Nqus4vWCHckt2GRraqvsTijrg,15460
+pandas/tests/io/test_pickle.pyc,,
+pandas/tests/io/test_pytables.py,sha256=kSLVvN6NzdyIPx50hKkRabLyW_pzsvBNIfi_At5Be-A,217491
+pandas/tests/io/test_pytables.pyc,,
+pandas/tests/io/test_s3.py,sha256=v_xjqmh9nBTXMCzaUWiWcE3ohvfHaHqa-Y3TyPa1kzY,728
+pandas/tests/io/test_s3.pyc,,
+pandas/tests/io/test_sql.py,sha256=eXHgkUKdhL5NDqcPxXunxX_n6ruDQOxQOiMwtv_Kito,99479
+pandas/tests/io/test_sql.pyc,,
+pandas/tests/io/test_stata.py,sha256=dDBb9vG5Yw_Jjzq4DelmaeY5rpu5JMpdMZ_0TnVTJqU,69850
+pandas/tests/io/test_stata.pyc,,
+pandas/tests/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/plotting/__init__.pyc,,
+pandas/tests/plotting/common.py,sha256=m_p1DwvxU_VWujaTRUBWMcACMjpLT_wuH2OxFyW94M0,18492
+pandas/tests/plotting/common.pyc,,
+pandas/tests/plotting/test_boxplot_method.py,sha256=3rx8ZI-d4SSJAu391YefvKMLisxvWwvCjH_fNa-fxug,16167
+pandas/tests/plotting/test_boxplot_method.pyc,,
+pandas/tests/plotting/test_converter.py,sha256=0_eAahgkrfNNCVpfnBlgirv7jQ5i8aCa7AW9eFjc0Ss,11932
+pandas/tests/plotting/test_converter.pyc,,
+pandas/tests/plotting/test_datetimelike.py,sha256=coiT_uSYnuoB_55PMMBbZwp7KP5zOAIQdAb6AixjXDY,57371
+pandas/tests/plotting/test_datetimelike.pyc,,
+pandas/tests/plotting/test_frame.py,sha256=5cPT7OlAf4m9lK20YA1VcsZIVir9PLtgcFmK_XtHEa8,123374
+pandas/tests/plotting/test_frame.pyc,,
+pandas/tests/plotting/test_groupby.py,sha256=gMUCC2Hx0NI1b1JKwKq69bWhT08adojqnjQ5PqbSw9c,2451
+pandas/tests/plotting/test_groupby.pyc,,
+pandas/tests/plotting/test_hist_method.py,sha256=xXjYu_6zrcrMFjrpAjTrHhZp1RWeiREZDf_DEZI5cuM,15812
+pandas/tests/plotting/test_hist_method.pyc,,
+pandas/tests/plotting/test_misc.py,sha256=hjnseymhTgKz-Sk2fyIcGsFyYZoIPFzXUH7XNYebK4A,14271
+pandas/tests/plotting/test_misc.pyc,,
+pandas/tests/plotting/test_series.py,sha256=YraAurXwZHBsS6vj3ZNU9QrT1gj0Hwt33SGJpOzbz8E,33857
+pandas/tests/plotting/test_series.pyc,,
+pandas/tests/reductions/__init__.py,sha256=vflo8yMcocx2X1Rdw9vt8NpiZ4ZFq9xZRC3PW6Gp-Cs,125
+pandas/tests/reductions/__init__.pyc,,
+pandas/tests/reductions/test_reductions.py,sha256=S1bmZtfOVl0IaMJt5V4KKHdZPH5loWuIosrCuux1n5U,40010
+pandas/tests/reductions/test_reductions.pyc,,
+pandas/tests/reductions/test_stat_reductions.py,sha256=2PIkW0hypIuP-jJ5TEF9P7y3ISYMYUh9o15sfoGEx9I,6997
+pandas/tests/reductions/test_stat_reductions.pyc,,
+pandas/tests/resample/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/resample/__init__.pyc,,
+pandas/tests/resample/conftest.py,sha256=YDJUwGxmkm-I6l-EhoHgEQh_WqjL2BNuzEyfjSgSt4w,4198
+pandas/tests/resample/conftest.pyc,,
+pandas/tests/resample/test_base.py,sha256=WUavHZKcLWOlEBUOQiI1c7lRkueHDFBRmToTxNOk_00,7948
+pandas/tests/resample/test_base.pyc,,
+pandas/tests/resample/test_datetime_index.py,sha256=KE5Zy96DFxHgw7UiXrNphO0RzBUYLknP6e-pLm8vEwQ,51659
+pandas/tests/resample/test_datetime_index.pyc,,
+pandas/tests/resample/test_period_index.py,sha256=9u73Gb_2YMCH3X6w20FfJQ4Ps0Rr6Tpd3GmxyFp97c4,33475
+pandas/tests/resample/test_period_index.pyc,,
+pandas/tests/resample/test_resample_api.py,sha256=dB-5mtAL0bOtN7r483bonAiBi4cT-7JnbjD7ssQmSqc,19159
+pandas/tests/resample/test_resample_api.pyc,,
+pandas/tests/resample/test_resampler_grouper.py,sha256=dw_o-7ifleljaU5al2wX6bgq-MbDhn9SJ740EudSEtM,8174
+pandas/tests/resample/test_resampler_grouper.pyc,,
+pandas/tests/resample/test_time_grouper.py,sha256=SQSIb9zlC3WXovQfphIofn62CQS2ROUA5Vkw-0kIlrQ,9849
+pandas/tests/resample/test_time_grouper.pyc,,
+pandas/tests/resample/test_timedelta.py,sha256=xAh5t52amEqG4h7dLaVbXBuY1m-kw6XC7-FQ-IAWq3I,4505
+pandas/tests/resample/test_timedelta.pyc,,
+pandas/tests/reshape/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/reshape/__init__.pyc,,
+pandas/tests/reshape/merge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/reshape/merge/__init__.pyc,,
+pandas/tests/reshape/merge/test_join.py,sha256=tMmwPBtaEdDrGS4kTWrPAa4IwGNMrjOPxWdGuD8nkVQ,34327
+pandas/tests/reshape/merge/test_join.pyc,,
+pandas/tests/reshape/merge/test_merge.py,sha256=i9Ka5QgpP50ZUz0RbRBDl-btYvo38IEyYJ6h4KMOYqA,66889
+pandas/tests/reshape/merge/test_merge.pyc,,
+pandas/tests/reshape/merge/test_merge_asof.py,sha256=1pXsR_pb21IxlJW_T5jsLHcsv0G4vitEcdlhH8t8UxM,40511
+pandas/tests/reshape/merge/test_merge_asof.pyc,,
+pandas/tests/reshape/merge/test_merge_index_as_string.py,sha256=6kBSDxs2R1AbCGe8_hHypHu4hQYGs0bA5iYmMgFz10k,5670
+pandas/tests/reshape/merge/test_merge_index_as_string.pyc,,
+pandas/tests/reshape/merge/test_merge_ordered.py,sha256=xt6zf36rOF6r0acngVSfzoEHv5q-3pmLVwEPIhswZqo,3703
+pandas/tests/reshape/merge/test_merge_ordered.pyc,,
+pandas/tests/reshape/merge/test_multi.py,sha256=7iUZw6sQJjAVYtYOtKomKzbk7PQzb8gPVDLUsPWeXjM,25016
+pandas/tests/reshape/merge/test_multi.pyc,,
+pandas/tests/reshape/test_concat.py,sha256=-0kOQIwMlpKOqlLWaXUdvvjWjGJ-DbkcV7krO96j0q4,104213
+pandas/tests/reshape/test_concat.pyc,,
+pandas/tests/reshape/test_cut.py,sha256=bJhZUfjGEuJ4iYbUllmtZsnqJaxArGVabAUbbmTFf00,15018
+pandas/tests/reshape/test_cut.pyc,,
+pandas/tests/reshape/test_melt.py,sha256=xgAYmVteFKOE1b8250XbP10ZKgIxM0VYWWlbujGvgt0,32565
+pandas/tests/reshape/test_melt.pyc,,
+pandas/tests/reshape/test_pivot.py,sha256=iIR-SGmtKbY5FPDE9GhogGsyhk7IxsfCB166VdyDV4A,81497
+pandas/tests/reshape/test_pivot.pyc,,
+pandas/tests/reshape/test_qcut.py,sha256=vCUz1pRr7hEYA3UQOkYbR7KYXXOwZB93ln-WWJL5YDU,6018
+pandas/tests/reshape/test_qcut.pyc,,
+pandas/tests/reshape/test_reshape.py,sha256=y9Fn4XWRb4axdC6omN36P-54f5xDJoWHW1qFSDCG0jI,25038
+pandas/tests/reshape/test_reshape.pyc,,
+pandas/tests/reshape/test_union_categoricals.py,sha256=FrSGmH18MNC3znY6d0Lr1vsdQi8S2qToGVYPSBn799s,14834
+pandas/tests/reshape/test_union_categoricals.pyc,,
+pandas/tests/reshape/test_util.py,sha256=kuEImZg4AnShHCJhnVqDbiwIXqLhNwfP_4wttxcKSJM,1899
+pandas/tests/reshape/test_util.pyc,,
+pandas/tests/scalar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/scalar/__init__.pyc,,
+pandas/tests/scalar/interval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/scalar/interval/__init__.pyc,,
+pandas/tests/scalar/interval/test_interval.py,sha256=4MZ-00n80NVF1T4wK7gXP3YMSaBkXP2Xn4IuKXzpw1k,7179
+pandas/tests/scalar/interval/test_interval.pyc,,
+pandas/tests/scalar/interval/test_ops.py,sha256=QbpiE9--5GARA8eAuV6DVglXF9RpXBY2xsoV_om4M0o,2334
+pandas/tests/scalar/interval/test_ops.pyc,,
+pandas/tests/scalar/period/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/scalar/period/__init__.pyc,,
+pandas/tests/scalar/period/test_asfreq.py,sha256=5Eh6HBFYeS4xYfd4Mq4Dr2ngt0Pzk5PElIDyXNbokJY,36670
+pandas/tests/scalar/period/test_asfreq.pyc,,
+pandas/tests/scalar/period/test_period.py,sha256=QHTyXUyPElfAS-9Lvu_t16i5jpPv5C-lcKlIPQ0ZmDs,52625
+pandas/tests/scalar/period/test_period.pyc,,
+pandas/tests/scalar/test_nat.py,sha256=uF-FtzL7JsVRuahYCAs3CJnYY0YQpyAQb1C2HmqverY,10666
+pandas/tests/scalar/test_nat.pyc,,
+pandas/tests/scalar/timedelta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/scalar/timedelta/__init__.pyc,,
+pandas/tests/scalar/timedelta/test_arithmetic.py,sha256=-k1mbZ4p-JRTdmUvf7cITDvgZKZtBZLARXQr2HLNiTQ,22242
+pandas/tests/scalar/timedelta/test_arithmetic.pyc,,
+pandas/tests/scalar/timedelta/test_construction.py,sha256=6lI2ktISOWN5RS8Qtx8wBvlP4RbVMtVL7lOgNbi73n4,8558
+pandas/tests/scalar/timedelta/test_construction.pyc,,
+pandas/tests/scalar/timedelta/test_formats.py,sha256=uHjjAhxlwNrT__2Zdqw-oDoA6EZv_xGJkvb2snO4DsI,1068
+pandas/tests/scalar/timedelta/test_formats.pyc,,
+pandas/tests/scalar/timedelta/test_timedelta.py,sha256=htzvlCV1893_kS04WnXq024lSsChimxvz5fXvw63RZw,27098
+pandas/tests/scalar/timedelta/test_timedelta.pyc,,
+pandas/tests/scalar/timestamp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/scalar/timestamp/__init__.pyc,,
+pandas/tests/scalar/timestamp/test_arithmetic.py,sha256=r1M_aqw6MyR4RvbdiJfTsZzBw2B9UDWURYpm_MMAyMc,4035
+pandas/tests/scalar/timestamp/test_arithmetic.pyc,,
+pandas/tests/scalar/timestamp/test_comparisons.py,sha256=TzhdT0cVBR98dUahFDpv_-4w1q3UYIV6f_viYRphoGA,4860
+pandas/tests/scalar/timestamp/test_comparisons.pyc,,
+pandas/tests/scalar/timestamp/test_rendering.py,sha256=-o_7sCHuU99-1PAyQBJRCkpxreVkenPilu1swVn6Kyg,3810
+pandas/tests/scalar/timestamp/test_rendering.pyc,,
+pandas/tests/scalar/timestamp/test_timestamp.py,sha256=OtwceCSxdhpHLF6tCpTm5Ks0ECZ_qAK4fI5fL0ENMsw,38289
+pandas/tests/scalar/timestamp/test_timestamp.pyc,,
+pandas/tests/scalar/timestamp/test_timezones.py,sha256=K2HFTHz_IMmE0YejACVR6di31T45ik1tA3wVqjLDzM4,16115
+pandas/tests/scalar/timestamp/test_timezones.pyc,,
+pandas/tests/scalar/timestamp/test_unary_ops.py,sha256=fdPPR4jAXCEDhfhTL_7p80flEau4rA4zfzo8-hQJzDk,13819
+pandas/tests/scalar/timestamp/test_unary_ops.pyc,,
+pandas/tests/series/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/series/__init__.pyc,,
+pandas/tests/series/common.py,sha256=SnPsu_AFR1qM6SyYTBhl6EMgsSeLwUnmiUYSgjtSaPo,626
+pandas/tests/series/common.pyc,,
+pandas/tests/series/conftest.py,sha256=_GznzB7MLoF3igOc9aktRxvSWCxFPKu3nBKggJXIYE4,736
+pandas/tests/series/conftest.pyc,,
+pandas/tests/series/indexing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/series/indexing/__init__.pyc,,
+pandas/tests/series/indexing/conftest.py,sha256=sSlea9ud0Z3d43mmS2e8KGoAdoX4v_M0ij3EpdlCBBU,136
+pandas/tests/series/indexing/conftest.pyc,,
+pandas/tests/series/indexing/test_alter_index.py,sha256=4BJEhfrzyBjpu7q0Iro-TFdqk4CYDsWVYdbucT2vq_g,17987
+pandas/tests/series/indexing/test_alter_index.pyc,,
+pandas/tests/series/indexing/test_boolean.py,sha256=L_VHumm4RnBMzPHiD3zWFn3WX_jFk398Qpu9SKqMofM,17284
+pandas/tests/series/indexing/test_boolean.pyc,,
+pandas/tests/series/indexing/test_callable.py,sha256=rygxcJGzCNzRHlIPnHW7KNsWKD0-GsJka49HmIEH8dA,814
+pandas/tests/series/indexing/test_callable.pyc,,
+pandas/tests/series/indexing/test_datetime.py,sha256=gbrvE6a6WJxCTF32udsGb7R2Tonnlw_G6baZ7HbbFPE,20794
+pandas/tests/series/indexing/test_datetime.pyc,,
+pandas/tests/series/indexing/test_iloc.py,sha256=2ZQ32OrpBU1P-NfdpkvQm2PYJrC1CCA01SXA8SGjbro,864
+pandas/tests/series/indexing/test_iloc.pyc,,
+pandas/tests/series/indexing/test_indexing.py,sha256=COhlxW4fFkPeEcqUHAFHdm470hySItPzQIAOv1DBDoY,24551
+pandas/tests/series/indexing/test_indexing.pyc,,
+pandas/tests/series/indexing/test_loc.py,sha256=1PBe5j8wdlhCnjv0LM0kyblALHCL30mvF6UrKXLJQoE,4466
+pandas/tests/series/indexing/test_loc.pyc,,
+pandas/tests/series/indexing/test_numeric.py,sha256=MXRVZ02medDE4FlumBBclGkWWAkCAoNzSq-3aJptqXk,6771
+pandas/tests/series/indexing/test_numeric.pyc,,
+pandas/tests/series/test_alter_axes.py,sha256=hckDjiLckMV2tvz7MwpxO4JRlPzY82-1v0v5Qkjm-Og,12763
+pandas/tests/series/test_alter_axes.pyc,,
+pandas/tests/series/test_analytics.py,sha256=gaPMPcuhDpoy2Wzd5nI4MRwOKgGr4bhtsqVtRMjOh7U,57867
+pandas/tests/series/test_analytics.pyc,,
+pandas/tests/series/test_api.py,sha256=pJStD5QgG-s_OtK3Ad7GRp3f53z0DZVYzOIUKi_TGj8,26237
+pandas/tests/series/test_api.pyc,,
+pandas/tests/series/test_apply.py,sha256=uFqkHi958kDAzYIAxxULvpZN8fNNqdaF9gfK-pvycRo,24589
+pandas/tests/series/test_apply.pyc,,
+pandas/tests/series/test_arithmetic.py,sha256=8urVrBhFcpjbM-OyFxMDV2HA1iPWHzpZtqCDDXJwmYM,6121
+pandas/tests/series/test_arithmetic.pyc,,
+pandas/tests/series/test_asof.py,sha256=KRjvTOD9FCE8OX9x0bRkZQoIp25tgG3TGnEidMgqYXE,5228
+pandas/tests/series/test_asof.pyc,,
+pandas/tests/series/test_block_internals.py,sha256=e_pklv5ge2mNNy4SrCwYzx0UwA3EvxDu3w3Ds5UOvmA,1472
+pandas/tests/series/test_block_internals.pyc,,
+pandas/tests/series/test_combine_concat.py,sha256=rrRMGm4NTSuSvBRFJYmALRmvb_PjaFRcamm7QdJZyRA,15033
+pandas/tests/series/test_combine_concat.pyc,,
+pandas/tests/series/test_constructors.py,sha256=1F694Noj0GhkHI1gjOLJDwXbHeqntyErkG-PONA6WE0,46677
+pandas/tests/series/test_constructors.pyc,,
+pandas/tests/series/test_datetime_values.py,sha256=tRqL590Q17Fd9S_MIQFz4J1SG1qpRBGmwlMme8Fm838,22804
+pandas/tests/series/test_datetime_values.pyc,,
+pandas/tests/series/test_dtypes.py,sha256=oJxK2pQFbDWExi-uz0I2cwnHPt3me0ZgvPfgmEfmiEs,20106
+pandas/tests/series/test_dtypes.pyc,,
+pandas/tests/series/test_duplicates.py,sha256=VcT6dmvpi3a_4euMBShln46iPfeJXHlpw9TpG_QRKwk,4544
+pandas/tests/series/test_duplicates.pyc,,
+pandas/tests/series/test_internals.py,sha256=mcPMaQhZmB80cLhP2QXKxMyZcqZVqDu5J4wdQUDjwgg,14036
+pandas/tests/series/test_internals.pyc,,
+pandas/tests/series/test_io.py,sha256=wDg3LngWUjqWspvcUks7VdF8KVnNssnidv56zH5ARyM,9655
+pandas/tests/series/test_io.pyc,,
+pandas/tests/series/test_missing.py,sha256=4p4syj_rcsOTm0toQqv0Ki-jZNYkWdEshttMlgXeT2M,54217
+pandas/tests/series/test_missing.pyc,,
+pandas/tests/series/test_operators.py,sha256=X7nncD_jUeJ1r1xklgA5eSrcB8rE6G2o1tSTm3-fYkw,25957
+pandas/tests/series/test_operators.pyc,,
+pandas/tests/series/test_period.py,sha256=OdpWxrgem731-7t5GgIbz0_YQ25mKzMtx4W5RSEpT8Y,5793
+pandas/tests/series/test_period.pyc,,
+pandas/tests/series/test_quantile.py,sha256=eJ7knwM3JwfNP76IYxb_DM915e94xfUycXbZBr-E8BA,6302
+pandas/tests/series/test_quantile.pyc,,
+pandas/tests/series/test_rank.py,sha256=xRmRoR6XeDWMVLz-qKBli5pcQAvIBaxKAi11NI5-Dr4,19479
+pandas/tests/series/test_rank.pyc,,
+pandas/tests/series/test_replace.py,sha256=-DJCFtjKA6imwTu6lzhvo8KRphq3kXHMc6Xew91WhSw,10588
+pandas/tests/series/test_replace.pyc,,
+pandas/tests/series/test_repr.py,sha256=ebkyn_esg1XU9CotuFfARkghykounD3agD39VKQAvbg,15089
+pandas/tests/series/test_repr.pyc,,
+pandas/tests/series/test_sorting.py,sha256=T6KNiaewdFPsARxWPUA4aukHnk8G22_lgtS8XA0D6Zc,10075
+pandas/tests/series/test_sorting.pyc,,
+pandas/tests/series/test_subclass.py,sha256=TGjiePxeNcgZUwiXxJ0VOpkoXZJr2x59tdA_USd0x1U,4076
+pandas/tests/series/test_subclass.pyc,,
+pandas/tests/series/test_timeseries.py,sha256=BW-vItdG32w3wvHdoHLUSPI9qNY4ZWuTZTa0LzOHRWs,38634
+pandas/tests/series/test_timeseries.pyc,,
+pandas/tests/series/test_timezones.py,sha256=Cx3VUgqv3oc7zHjS7LJqcMGL-RvpXq-3aM0ILZAnIXU,14177
+pandas/tests/series/test_timezones.pyc,,
+pandas/tests/series/test_validate.py,sha256=CEhR6xUTtcNAXm33lFtCkXSayp2MEB0Vt09YMk1-d1o,731
+pandas/tests/series/test_validate.pyc,,
+pandas/tests/sparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/sparse/__init__.pyc,,
+pandas/tests/sparse/common.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/sparse/common.pyc,,
+pandas/tests/sparse/frame/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/sparse/frame/__init__.pyc,,
+pandas/tests/sparse/frame/conftest.py,sha256=X9NmJvjhxSGc9KAX2iuJKHV67aA3pvrkRmn6HWp9N6c,3223
+pandas/tests/sparse/frame/conftest.pyc,,
+pandas/tests/sparse/frame/test_analytics.py,sha256=GCx0kP5uXC2cPxAfI7FEGYe5PUdNO5EvM_s4QHhuNm8,1118
+pandas/tests/sparse/frame/test_analytics.pyc,,
+pandas/tests/sparse/frame/test_apply.py,sha256=ajsBdgZxPug932vHUFP3yEZRFySkuoJWtCYxKRxgHzI,3018
+pandas/tests/sparse/frame/test_apply.pyc,,
+pandas/tests/sparse/frame/test_frame.py,sha256=GPRFmPm2SEz6s2MlYQEgqlqfZ5HgOox-8hgKciJx2vM,53954
+pandas/tests/sparse/frame/test_frame.pyc,,
+pandas/tests/sparse/frame/test_indexing.py,sha256=82WZO0zOrLYUzzCkgxkh3hnn8jiCIOkYjsfsp3xo7lE,3135
+pandas/tests/sparse/frame/test_indexing.pyc,,
+pandas/tests/sparse/frame/test_to_csv.py,sha256=BpFAiNd-uuricSgfSpAIMn4C3PqyyHayImgUuhaRAv0,685
+pandas/tests/sparse/frame/test_to_csv.pyc,,
+pandas/tests/sparse/frame/test_to_from_scipy.py,sha256=OmLOVLcDP90Kjgq_Uyr8ONcGgyiB2_ZhhRYugV4A10c,6717
+pandas/tests/sparse/frame/test_to_from_scipy.pyc,,
+pandas/tests/sparse/series/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/sparse/series/__init__.pyc,,
+pandas/tests/sparse/series/test_indexing.py,sha256=BQPNSB13LM2iyRqIODEUlmWG1M1bx_lQDteO6zPxLf4,3069
+pandas/tests/sparse/series/test_indexing.pyc,,
+pandas/tests/sparse/series/test_series.py,sha256=hapR-HsPryu-y7-SNRJpOnOAwDsn97bsrtpd8DLhask,57871
+pandas/tests/sparse/series/test_series.pyc,,
+pandas/tests/sparse/test_combine_concat.py,sha256=mLfd2sJ7X14wfMWy5csf7PQaxxFMViSZ0bPErEDbxH0,18908
+pandas/tests/sparse/test_combine_concat.pyc,,
+pandas/tests/sparse/test_format.py,sha256=fLtUHAexQ-CCt9V5d4BIuZg7VdBQVVJJTkDXFxiMIP0,5272
+pandas/tests/sparse/test_format.pyc,,
+pandas/tests/sparse/test_groupby.py,sha256=g7EXMNIL1qwbARu23oMWYTrU3QNTe3ZnGogBFoadP1c,2749
+pandas/tests/sparse/test_groupby.pyc,,
+pandas/tests/sparse/test_indexing.py,sha256=SxzhMeUDC7OBWVR_GFeFyTF53DEgOt6xgOG3KI9_QLQ,41153
+pandas/tests/sparse/test_indexing.pyc,,
+pandas/tests/sparse/test_pivot.py,sha256=fwccu8Yn5af_WL4g4uvdoVZsqhwEyToyQtjc6xxcv6A,2466
+pandas/tests/sparse/test_pivot.pyc,,
+pandas/tests/sparse/test_reshape.py,sha256=flpy8c57hBIx_XNCs65Tngl-LdGF1RG9FT6k-jhWctM,1229
+pandas/tests/sparse/test_reshape.pyc,,
+pandas/tests/test_algos.py,sha256=fyF0NLRiVDPd2sjIudvaDrrQWIG3QEPc33znGdOiEAI,72648
+pandas/tests/test_algos.pyc,,
+pandas/tests/test_base.py,sha256=74vkyfkaRZVhMWU73lcHtoTqufAIianza-iAn22iQp4,49728
+pandas/tests/test_base.pyc,,
+pandas/tests/test_common.py,sha256=-vFfLYASD7tMV5GOykh93IeSWfRB2WofwTqP30kyJzQ,3253
+pandas/tests/test_common.pyc,,
+pandas/tests/test_compat.py,sha256=I46Yg--zDuARQEeBYyBTUvw-7L28t9mgiyBmIIrQnFU,3215
+pandas/tests/test_compat.pyc,,
+pandas/tests/test_config.py,sha256=_jS_m_JdQBaWH9vmADedZ2-SJjr-blmd5cqkY1aYgLA,16196
+pandas/tests/test_config.pyc,,
+pandas/tests/test_downstream.py,sha256=61vvyew4nM1HeX_29lu6GYc1U1CkUNSvPufAs9ZxBmE,3563
+pandas/tests/test_downstream.pyc,,
+pandas/tests/test_errors.py,sha256=Hh_X3AkoH-mMA4ZNukuUGmfzoSfjvyoclGJ4nx5aOo4,1792
+pandas/tests/test_errors.pyc,,
+pandas/tests/test_expressions.py,sha256=oIXhR3-2IAdeqcskD3nxTFUzRgvcwWA37h7lK4T5UKg,18417
+pandas/tests/test_expressions.pyc,,
+pandas/tests/test_join.py,sha256=3k0QyrVHC_yQh4sQqynXPvfEWNcOZwVGvPQQnOSnEbo,8585
+pandas/tests/test_join.pyc,,
+pandas/tests/test_lib.py,sha256=a-ard8M4MJU17BpbIkda9oypod5jo9qDTqpYi98Gsfc,7875
+pandas/tests/test_lib.pyc,,
+pandas/tests/test_multilevel.py,sha256=Y8nfNvAg21PzNFS4_YvfY0ITO6KKE_zSC9_ymx1gC28,81775
+pandas/tests/test_multilevel.pyc,,
+pandas/tests/test_nanops.py,sha256=CSyXwhGH0vJxQ0e4z9rcbN6USwcG3vVXKzQDSgj9zXw,42774
+pandas/tests/test_nanops.pyc,,
+pandas/tests/test_panel.py,sha256=JzXLWo-Uy37lYosbxrYAtS6wAOml-XX1MbRO13B2nLU,95768
+pandas/tests/test_panel.pyc,,
+pandas/tests/test_register_accessor.py,sha256=SV-MueGG814sAyxbLhCLnjp2NfpfZCctzPlB0xsYang,2260
+pandas/tests/test_register_accessor.pyc,,
+pandas/tests/test_sorting.py,sha256=d74e38P-g1nGwcJsx_CVWzdkLIcR5Yue4TQ4rjRrK7o,17400
+pandas/tests/test_sorting.pyc,,
+pandas/tests/test_strings.py,sha256=I37KBPg7ZmqIYldLA51ZBPUs5k3tEpPI2q1lSVVmrn0,136268
+pandas/tests/test_strings.pyc,,
+pandas/tests/test_take.py,sha256=5O_S5YfIMxgIusJS3CdA2b08qxu7YqZLA96IkiUfhXc,16732
+pandas/tests/test_take.pyc,,
+pandas/tests/test_window.py,sha256=qkJ27wN4VcglneYllWmBpJc5I7rF8Vd1cVFN_PJDPok,156476
+pandas/tests/test_window.pyc,,
+pandas/tests/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/tools/__init__.pyc,,
+pandas/tests/tools/test_numeric.py,sha256=iadu3B9TgqBbZMOredZZ1qlllGN1HLf_fDuKkldcxL0,16325
+pandas/tests/tools/test_numeric.pyc,,
+pandas/tests/tseries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/tseries/__init__.pyc,,
+pandas/tests/tseries/offsets/__init__.py,sha256=iwhKnzeBJLKxpRVjvzwiRE63_zNpIBfaKLITauVph-0,24
+pandas/tests/tseries/offsets/__init__.pyc,,
+pandas/tests/tseries/offsets/common.py,sha256=vDnO8DT04mMz1jONCFb42H9somsis9fESVsWAwvJEK4,832
+pandas/tests/tseries/offsets/common.pyc,,
+pandas/tests/tseries/offsets/conftest.py,sha256=-6kDz8OcOb4EpHqnDHGXK2zpIsD1j0LzlQ5zYvTXEKY,610
+pandas/tests/tseries/offsets/conftest.pyc,,
+pandas/tests/tseries/offsets/test_fiscal.py,sha256=ngnldtJk0L3Jo_AHzKTK6ZXAZHr6yGv895z6gkRsCWw,29292
+pandas/tests/tseries/offsets/test_fiscal.pyc,,
+pandas/tests/tseries/offsets/test_offsets.py,sha256=siTq46ENUtXKZJj1eSvtvu4WEkyCntUHD78HjN3aKZA,129890
+pandas/tests/tseries/offsets/test_offsets.pyc,,
+pandas/tests/tseries/offsets/test_offsets_properties.py,sha256=q7wtyWwl7O5maFZ1DGzHtU7KC1oY3tsOvqXyjpZS1fA,3937
+pandas/tests/tseries/offsets/test_offsets_properties.pyc,,
+pandas/tests/tseries/offsets/test_ticks.py,sha256=5Rlz3eraDVMBTt4I4GBtH9sc4JfVUtGiX21ye_Jlzrc,9837
+pandas/tests/tseries/offsets/test_ticks.pyc,,
+pandas/tests/tseries/offsets/test_yqm_offsets.py,sha256=2zP2hzF8VjjjGtHTzy6kIEcNgIbp4TGZrfTdfvaHddM,43982
+pandas/tests/tseries/offsets/test_yqm_offsets.pyc,,
+pandas/tests/tseries/test_frequencies.py,sha256=4QNSfI9lnxzRr3Ioy_HMbzvHUIEn4iAnRDG7NnlxUUc,29684
+pandas/tests/tseries/test_frequencies.pyc,,
+pandas/tests/tseries/test_holiday.py,sha256=9CzYfbQuF4V_OzLZueuTh3It1B-zmo2Io-19H-dimWQ,15721
+pandas/tests/tseries/test_holiday.pyc,,
+pandas/tests/tslibs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/tslibs/__init__.pyc,,
+pandas/tests/tslibs/test_api.py,sha256=-_ev8E2_G4GktdsuD9Ci6o0DwUK3B_wOgwdmkhIehmA,1069
+pandas/tests/tslibs/test_api.pyc,,
+pandas/tests/tslibs/test_array_to_datetime.py,sha256=GopE1gu_x8gAMG7VgqFbrp4Zh4zjlViSnvbadwnafBo,5291
+pandas/tests/tslibs/test_array_to_datetime.pyc,,
+pandas/tests/tslibs/test_ccalendar.py,sha256=CKJEREmUQC9uJ7N2mx7riitzI-sXQsc6aP_XzWiQsvo,717
+pandas/tests/tslibs/test_ccalendar.pyc,,
+pandas/tests/tslibs/test_conversion.py,sha256=bDZDmYC_uM4sFLxbp5KNw9MCumSekDY-YVDEKEJZFR0,2198
+pandas/tests/tslibs/test_conversion.pyc,,
+pandas/tests/tslibs/test_libfrequencies.py,sha256=0rErsC-lKbFAYIzby8TAayGwCEkC5u4aH-gyN78wLWo,2647
+pandas/tests/tslibs/test_libfrequencies.pyc,,
+pandas/tests/tslibs/test_liboffsets.py,sha256=CGT-0MM3twlq4-QHSlxaUptLQa-b1Wl0uGa6OE1KCcI,5038
+pandas/tests/tslibs/test_liboffsets.pyc,,
+pandas/tests/tslibs/test_normalize_date.py,sha256=c34jhMHIpBCiqlnFmfcmA70VDnU2SpaAxqlIlvC0Fug,489
+pandas/tests/tslibs/test_normalize_date.pyc,,
+pandas/tests/tslibs/test_parse_iso8601.py,sha256=_r9eAeRwBhWtdN54YieOTQs5GmlgqfttiF8Xuu7hOFU,1723
+pandas/tests/tslibs/test_parse_iso8601.pyc,,
+pandas/tests/tslibs/test_parsing.py,sha256=93fywGTEqxmN6L3_kgjGo3bDLfEq9og3M4BaLjdQQOM,5799
+pandas/tests/tslibs/test_parsing.pyc,,
+pandas/tests/tslibs/test_period_asfreq.py,sha256=TnCuyzT86pV3YAs3A6YuHyANklxo0ZCHya_ZSMm9jD0,2036
+pandas/tests/tslibs/test_period_asfreq.pyc,,
+pandas/tests/tslibs/test_timedeltas.py,sha256=1ZVVygmupic446ANDagsCY7_NLTunPqu0gOJaH6Dbjc,780
+pandas/tests/tslibs/test_timedeltas.pyc,,
+pandas/tests/tslibs/test_timezones.py,sha256=syejxmWlmLU2WYzFNBmfqym0mK1PST880RMiFIAV0qo,2999
+pandas/tests/tslibs/test_timezones.pyc,,
+pandas/tests/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tests/util/__init__.pyc,,
+pandas/tests/util/conftest.py,sha256=jwFjj-8FSV4wF7VTB4FJAo1cKdvZ1EpUoQZNfqh-_vI,487
+pandas/tests/util/conftest.pyc,,
+pandas/tests/util/test_assert_almost_equal.py,sha256=jBanQU9CezbVgIcMATHLGk6Y-5NSDhb5U0XcJuik8S0,9948
+pandas/tests/util/test_assert_almost_equal.pyc,,
+pandas/tests/util/test_assert_categorical_equal.py,sha256=E_IihYnCxtzymk8XxOcWrqmQK8d17Nzb624R5nMAUxM,2796
+pandas/tests/util/test_assert_categorical_equal.pyc,,
+pandas/tests/util/test_assert_extension_array_equal.py,sha256=9Flk4sX7T5MTXqhl-2KFvfBeq3wf4MpIPIrg2Ib-E90,3219
+pandas/tests/util/test_assert_extension_array_equal.pyc,,
+pandas/tests/util/test_assert_frame_equal.py,sha256=26Y3rP1O48LVjLRCj1OrW4vivttvnr0QnPSrlis1ggk,6610
+pandas/tests/util/test_assert_frame_equal.pyc,,
+pandas/tests/util/test_assert_index_equal.py,sha256=hqfPQZ57bVSMm15Ga0SKcKzuEkRgZAcct06FcWo4JRY,6085
+pandas/tests/util/test_assert_index_equal.pyc,,
+pandas/tests/util/test_assert_interval_array_equal.py,sha256=yICl2i8V_9JZ0J-_QTSaSWwyfwAtTHp4BQLv3ygproI,2378
+pandas/tests/util/test_assert_interval_array_equal.pyc,,
+pandas/tests/util/test_assert_numpy_array_equal.py,sha256=7UiMGaXEEqVGzxNEErRzYLTpVUWl-Ju9cvtzjzT07yk,5625
+pandas/tests/util/test_assert_numpy_array_equal.pyc,,
+pandas/tests/util/test_assert_series_equal.py,sha256=AnUGIEFdkDmamZOomQsghlfa1iZBabXK8BInElheyys,5477
+pandas/tests/util/test_assert_series_equal.pyc,,
+pandas/tests/util/test_deprecate.py,sha256=yQvoymd9EFZgyP_eRySzhPdYqEnIHUYiSjrdBPFzJlE,1698
+pandas/tests/util/test_deprecate.pyc,,
+pandas/tests/util/test_deprecate_kwarg.py,sha256=ZcoddYvZr25xcTsNZDeDbalHaOLI_WY6dVJJ9mI2KLE,2080
+pandas/tests/util/test_deprecate_kwarg.pyc,,
+pandas/tests/util/test_hashing.py,sha256=I76-an6GNqDNHiTOxg7tdfonTWNgQrYMENavBFFwXQY,11141
+pandas/tests/util/test_hashing.pyc,,
+pandas/tests/util/test_locale.py,sha256=XmggTJqG4aLxiITG7rrBxJNfqtKXUFX7KbAnZT-vOgU,2689
+pandas/tests/util/test_locale.pyc,,
+pandas/tests/util/test_move.py,sha256=T3IDKdxgmw4xxKWirMmP2BShT2TCQMpeOlgxUaE28Ew,2761
+pandas/tests/util/test_move.pyc,,
+pandas/tests/util/test_safe_import.py,sha256=5aMHOPQiHPJvH0U0_Di0B9_GMO-mfFj-YjAzqxsus-E,1062
+pandas/tests/util/test_safe_import.pyc,,
+pandas/tests/util/test_util.py,sha256=Ch_IwSpndoWKaR9xo6Ti-QFaLOTDnzTEC5OMZBOQJGo,3410
+pandas/tests/util/test_util.pyc,,
+pandas/tests/util/test_validate_args.py,sha256=yapGyOI3QMe14DsKlgoEPTrSMEA8dRtqjZny7aIa5dc,2224
+pandas/tests/util/test_validate_args.pyc,,
+pandas/tests/util/test_validate_args_and_kwargs.py,sha256=OlYohNGHNsyaZC1LVj56MJ66WZ3598GcIVNRs_jKREw,3182
+pandas/tests/util/test_validate_args_and_kwargs.pyc,,
+pandas/tests/util/test_validate_kwargs.py,sha256=67mT8qwUEPpSAc5N4EcaJU20qzRqgNwZQqoKnJn1OTU,2040
+pandas/tests/util/test_validate_kwargs.pyc,,
+pandas/tseries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pandas/tseries/__init__.pyc,,
+pandas/tseries/api.py,sha256=GqF_UoX9OyCigcaoePStvDGasXZiFByVKSeATIYbWWY,131
+pandas/tseries/api.pyc,,
+pandas/tseries/converter.py,sha256=QNkUIyyYaK5IFzsBbifP3HkIii3fSFYYzYE4vDzet1Q,606
+pandas/tseries/converter.pyc,,
+pandas/tseries/frequencies.py,sha256=UD8Q8P_l_mr9yps43LUItGzAMBd9Fn0fADl8WRJecyA,15830
+pandas/tseries/frequencies.pyc,,
+pandas/tseries/holiday.py,sha256=en2VpNcfoKgJhzJr0RrHlidndBiqhcagJ35IpRF1hqg,16374
+pandas/tseries/holiday.pyc,,
+pandas/tseries/offsets.py,sha256=6WaT3tO5zNS0yH9tYkSKpbMRkmsEyC3_kUX724ixz10,83512
+pandas/tseries/offsets.pyc,,
+pandas/tseries/plotting.py,sha256=GwDIPPqz7jg3fgTKUbZCqnGnuBgNnbTGoTJ-GYcW7R8,63
+pandas/tseries/plotting.pyc,,
+pandas/util/__init__.py,sha256=oqwcd4Btk0IquNVTxlNoxBqMrGvU9nCf_y3gGMyi7P4,160
+pandas/util/__init__.pyc,,
+pandas/util/_decorators.py,sha256=x7ZyUo6lpkII3Jcw6pdFmH1JaIzvL7dib5CqEFzZuz8,12597
+pandas/util/_decorators.pyc,,
+pandas/util/_depr_module.py,sha256=JADSYJZBk0yrNIYZmsClPpN5eg5YmlBotCzs6FxJVcc,3574
+pandas/util/_depr_module.pyc,,
+pandas/util/_doctools.py,sha256=1GXgusKHH5VXejSD0NR1b9zoUdDUQCNGM9cofFM3pjg,7099
+pandas/util/_doctools.pyc,,
+pandas/util/_exceptions.py,sha256=Rc4zSNYztwaKAcD2K_g3bg9kfEQzyIzb2zJVDONGKtk,380
+pandas/util/_exceptions.pyc,,
+pandas/util/_move.so,sha256=_UuvizMsfDdoHSPE8Z9TOsGZ6G7DSQaWuJzbfDJVVvQ,8576
+pandas/util/_print_versions.py,sha256=rwB4_OidAZhzPVOSZs8Y-upEWRK_WoPCUouxJWnahX0,5258
+pandas/util/_print_versions.pyc,,
+pandas/util/_test_decorators.py,sha256=bXNiLz5aFbWcaT_OrBBuJZDXSsNdGy5r8fR8EIX148o,6986
+pandas/util/_test_decorators.pyc,,
+pandas/util/_tester.py,sha256=moA2oqKopbYRZsR8KT90i1uBMKJaSO3vB26fGOZY9xM,712
+pandas/util/_tester.pyc,,
+pandas/util/_validators.py,sha256=gGlXioFQNDpGLpvgYHQqiClyZwNgqjOaxa4lYb7une8,13054
+pandas/util/_validators.pyc,,
+pandas/util/testing.py,sha256=JMsZ176uLhvFzsCIjtaRQVjEkqP0qABEr9p8pcuVjro,104417
+pandas/util/testing.pyc,,
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/WHEEL b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..295a0ca5470911d5713ce5907980a0875ec667ff
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.31.1)
+Root-Is-Purelib: false
+Tag: cp27-cp27mu-manylinux1_x86_64
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/top_level.txt b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fb6c7ed7ec60dafcf523d2e12daa17abc92ae384
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas-0.24.2.dist-info/top_level.txt
@@ -0,0 +1 @@
+pandas
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..427157acb433f828fa0364c02d112afe6627360d
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/__init__.py
@@ -0,0 +1,101 @@
+# pylint: disable-msg=W0614,W0401,W0611,W0622
+
+# flake8: noqa
+
+__docformat__ = 'restructuredtext'
+
+# Let users know if they're missing any of our hard dependencies
+hard_dependencies = ("numpy", "pytz", "dateutil")
+missing_dependencies = []
+
+for dependency in hard_dependencies:
+ try:
+ __import__(dependency)
+ except ImportError as e:
+ missing_dependencies.append(dependency)
+
+if missing_dependencies:
+ raise ImportError(
+ "Missing required dependencies {0}".format(missing_dependencies))
+del hard_dependencies, dependency, missing_dependencies
+
+# numpy compat
+from pandas.compat.numpy import *
+
+try:
+ from pandas._libs import (hashtable as _hashtable,
+ lib as _lib,
+ tslib as _tslib)
+except ImportError as e: # pragma: no cover
+ # hack but overkill to use re
+ module = str(e).replace('cannot import name ', '')
+ raise ImportError("C extension: {0} not built. If you want to import "
+ "pandas from the source directory, you may need to run "
+ "'python setup.py build_ext --inplace --force' to build "
+ "the C extensions first.".format(module))
+
+from datetime import datetime
+
+# let init-time option registration happen
+import pandas.core.config_init
+
+from pandas.core.api import *
+from pandas.core.sparse.api import *
+from pandas.tseries.api import *
+from pandas.core.computation.api import *
+from pandas.core.reshape.api import *
+
+from pandas.util._print_versions import show_versions
+from pandas.io.api import *
+from pandas.util._tester import test
+import pandas.testing
+import pandas.arrays
+
+# use the closest tagged version if possible
+from ._version import get_versions
+v = get_versions()
+__version__ = v.get('closest-tag', v['version'])
+__git_version__ = v.get('full-revisionid')
+del get_versions, v
+
+# module level doc-string
+__doc__ = """
+pandas - a powerful data analysis and manipulation library for Python
+=====================================================================
+
+**pandas** is a Python package providing fast, flexible, and expressive data
+structures designed to make working with "relational" or "labeled" data both
+easy and intuitive. It aims to be the fundamental high-level building block for
+doing practical, **real world** data analysis in Python. Additionally, it has
+the broader goal of becoming **the most powerful and flexible open source data
+analysis / manipulation tool available in any language**. It is already well on
+its way toward this goal.
+
+Main Features
+-------------
+Here are just a few of the things that pandas does well:
+
+ - Easy handling of missing data in floating point as well as non-floating
+ point data.
+ - Size mutability: columns can be inserted and deleted from DataFrame and
+ higher dimensional objects
+ - Automatic and explicit data alignment: objects can be explicitly aligned
+ to a set of labels, or the user can simply ignore the labels and let
+ `Series`, `DataFrame`, etc. automatically align the data for you in
+ computations.
+ - Powerful, flexible group by functionality to perform split-apply-combine
+ operations on data sets, for both aggregating and transforming data.
+ - Make it easy to convert ragged, differently-indexed data in other Python
+ and NumPy data structures into DataFrame objects.
+ - Intelligent label-based slicing, fancy indexing, and subsetting of large
+ data sets.
+ - Intuitive merging and joining data sets.
+ - Flexible reshaping and pivoting of data sets.
+ - Hierarchical labeling of axes (possible to have multiple labels per tick).
+ - Robust IO tools for loading data from flat files (CSV and delimited),
+ Excel files, databases, and saving/loading data from the ultrafast HDF5
+ format.
+ - Time series-specific functionality: date range generation and frequency
+ conversion, moving window statistics, moving window linear regressions,
+ date shifting and lagging, etc.
+"""
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/_version.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..843359bd56ec1ce77581d4201233a4aa709163d9
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/_version.py
@@ -0,0 +1,23 @@
+
+# This file was generated by 'versioneer.py' (0.15) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+from warnings import catch_warnings
+with catch_warnings(record=True):
+ import json
+import sys
+
+version_json = '''
+{
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "cb00deb94500205fcb27a33cc1d0df79a9727f8b",
+ "version": "0.24.2"
+}
+''' # END VERSION_JSON
+
+
+def get_versions():
+ return json.loads(version_json)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/conftest.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..35a6b5df35ddc68f0173d77dae7f172f89870fbf
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/conftest.py
@@ -0,0 +1,677 @@
+from datetime import date, time, timedelta
+from decimal import Decimal
+import os
+
+from dateutil.tz import tzlocal, tzutc
+import hypothesis
+from hypothesis import strategies as st
+import numpy as np
+import pytest
+from pytz import FixedOffset, utc
+
+from pandas.compat import PY3, u
+import pandas.util._test_decorators as td
+
+import pandas as pd
+
+hypothesis.settings.register_profile(
+ "ci",
+ # Hypothesis timing checks are tuned for scalars by default, so we bump
+ # them from 200ms to 500ms per test case as the global default. If this
+ # is too short for a specific test, (a) try to make it faster, and (b)
+ # if it really is slow add `@settings(deadline=...)` with a working value,
+ # or `deadline=None` to entirely disable timeouts for that test.
+ deadline=500,
+ timeout=hypothesis.unlimited,
+ suppress_health_check=(hypothesis.HealthCheck.too_slow,)
+)
+hypothesis.settings.load_profile("ci")
+
+
+def pytest_addoption(parser):
+ parser.addoption("--skip-slow", action="store_true",
+ help="skip slow tests")
+ parser.addoption("--skip-network", action="store_true",
+ help="skip network tests")
+ parser.addoption("--skip-db", action="store_true",
+ help="skip db tests")
+ parser.addoption("--run-high-memory", action="store_true",
+ help="run high memory tests")
+ parser.addoption("--only-slow", action="store_true",
+ help="run only slow tests")
+ parser.addoption("--strict-data-files", action="store_true",
+ help="Fail if a test is skipped for missing data file.")
+
+
+def pytest_runtest_setup(item):
+ if 'slow' in item.keywords and item.config.getoption("--skip-slow"):
+ pytest.skip("skipping due to --skip-slow")
+
+ if 'slow' not in item.keywords and item.config.getoption("--only-slow"):
+ pytest.skip("skipping due to --only-slow")
+
+ if 'network' in item.keywords and item.config.getoption("--skip-network"):
+ pytest.skip("skipping due to --skip-network")
+
+ if 'db' in item.keywords and item.config.getoption("--skip-db"):
+ pytest.skip("skipping due to --skip-db")
+
+ if 'high_memory' in item.keywords and not item.config.getoption(
+ "--run-high-memory"):
+ pytest.skip(
+ "skipping high memory test since --run-high-memory was not set")
+
+
+# Configurations for all tests and all test modules
+
+@pytest.fixture(autouse=True)
+def configure_tests():
+ pd.set_option('chained_assignment', 'raise')
+
+
+# For running doctests: make np and pd names available
+
+@pytest.fixture(autouse=True)
+def add_imports(doctest_namespace):
+ doctest_namespace['np'] = np
+ doctest_namespace['pd'] = pd
+
+
+@pytest.fixture(params=['bsr', 'coo', 'csc', 'csr', 'dia', 'dok', 'lil'])
+def spmatrix(request):
+ from scipy import sparse
+ return getattr(sparse, request.param + '_matrix')
+
+
+@pytest.fixture(params=[0, 1, 'index', 'columns'],
+ ids=lambda x: "axis {!r}".format(x))
+def axis(request):
+ """
+ Fixture for returning the axis numbers of a DataFrame.
+ """
+ return request.param
+
+
+axis_frame = axis
+
+
+@pytest.fixture(params=[0, 'index'], ids=lambda x: "axis {!r}".format(x))
+def axis_series(request):
+ """
+ Fixture for returning the axis numbers of a Series.
+ """
+ return request.param
+
+
+@pytest.fixture
+def ip():
+ """
+ Get an instance of IPython.InteractiveShell.
+
+ Will raise a skip if IPython is not installed.
+ """
+
+ pytest.importorskip('IPython', minversion="6.0.0")
+ from IPython.core.interactiveshell import InteractiveShell
+ return InteractiveShell()
+
+
+@pytest.fixture(params=[True, False, None])
+def observed(request):
+ """ pass in the observed keyword to groupby for [True, False]
+ This indicates whether categoricals should return values for
+ values which are not in the grouper [False / None], or only values which
+ appear in the grouper [True]. [None] is supported for future compatiblity
+ if we decide to change the default (and would need to warn if this
+ parameter is not passed)"""
+ return request.param
+
+
+_all_arithmetic_operators = ['__add__', '__radd__',
+ '__sub__', '__rsub__',
+ '__mul__', '__rmul__',
+ '__floordiv__', '__rfloordiv__',
+ '__truediv__', '__rtruediv__',
+ '__pow__', '__rpow__',
+ '__mod__', '__rmod__']
+if not PY3:
+ _all_arithmetic_operators.extend(['__div__', '__rdiv__'])
+
+
+@pytest.fixture(params=_all_arithmetic_operators)
+def all_arithmetic_operators(request):
+ """
+ Fixture for dunder names for common arithmetic operations
+ """
+ return request.param
+
+
+_all_numeric_reductions = ['sum', 'max', 'min',
+ 'mean', 'prod', 'std', 'var', 'median',
+ 'kurt', 'skew']
+
+
+@pytest.fixture(params=_all_numeric_reductions)
+def all_numeric_reductions(request):
+ """
+ Fixture for numeric reduction names
+ """
+ return request.param
+
+
+_all_boolean_reductions = ['all', 'any']
+
+
+@pytest.fixture(params=_all_boolean_reductions)
+def all_boolean_reductions(request):
+ """
+ Fixture for boolean reduction names
+ """
+ return request.param
+
+
+_cython_table = pd.core.base.SelectionMixin._cython_table.items()
+
+
+@pytest.fixture(params=list(_cython_table))
+def cython_table_items(request):
+ return request.param
+
+
+def _get_cython_table_params(ndframe, func_names_and_expected):
+ """combine frame, functions from SelectionMixin._cython_table
+ keys and expected result.
+
+ Parameters
+ ----------
+ ndframe : DataFrame or Series
+ func_names_and_expected : Sequence of two items
+ The first item is a name of a NDFrame method ('sum', 'prod') etc.
+ The second item is the expected return value
+
+ Returns
+ -------
+ results : list
+ List of three items (DataFrame, function, expected result)
+ """
+ results = []
+ for func_name, expected in func_names_and_expected:
+ results.append((ndframe, func_name, expected))
+ results += [(ndframe, func, expected) for func, name in _cython_table
+ if name == func_name]
+ return results
+
+
+@pytest.fixture(params=['__eq__', '__ne__', '__le__',
+ '__lt__', '__ge__', '__gt__'])
+def all_compare_operators(request):
+ """
+ Fixture for dunder names for common compare operations
+
+ * >=
+ * >
+ * ==
+ * !=
+ * <
+ * <=
+ """
+ return request.param
+
+
+@pytest.fixture(params=[None, 'gzip', 'bz2', 'zip',
+ pytest.param('xz', marks=td.skip_if_no_lzma)])
+def compression(request):
+ """
+ Fixture for trying common compression types in compression tests
+ """
+ return request.param
+
+
+@pytest.fixture(params=['gzip', 'bz2', 'zip',
+ pytest.param('xz', marks=td.skip_if_no_lzma)])
+def compression_only(request):
+ """
+ Fixture for trying common compression types in compression tests excluding
+ uncompressed case
+ """
+ return request.param
+
+
+@pytest.fixture(params=[True, False])
+def writable(request):
+ """
+ Fixture that an array is writable
+ """
+ return request.param
+
+
+@pytest.fixture(scope='module')
+def datetime_tz_utc():
+ from datetime import timezone
+ return timezone.utc
+
+
+utc_objs = ['utc', 'dateutil/UTC', utc, tzutc()]
+if PY3:
+ from datetime import timezone
+ utc_objs.append(timezone.utc)
+
+
+@pytest.fixture(params=utc_objs)
+def utc_fixture(request):
+ """
+ Fixture to provide variants of UTC timezone strings and tzinfo objects
+ """
+ return request.param
+
+
+@pytest.fixture(params=['inner', 'outer', 'left', 'right'])
+def join_type(request):
+ """
+ Fixture for trying all types of join operations
+ """
+ return request.param
+
+
+@pytest.fixture
+def strict_data_files(pytestconfig):
+ return pytestconfig.getoption("--strict-data-files")
+
+
+@pytest.fixture
+def datapath(strict_data_files):
+ """Get the path to a data file.
+
+ Parameters
+ ----------
+ path : str
+ Path to the file, relative to ``pandas/tests/``
+
+ Returns
+ -------
+ path : path including ``pandas/tests``.
+
+ Raises
+ ------
+ ValueError
+ If the path doesn't exist and the --strict-data-files option is set.
+ """
+ BASE_PATH = os.path.join(os.path.dirname(__file__), 'tests')
+
+ def deco(*args):
+ path = os.path.join(BASE_PATH, *args)
+ if not os.path.exists(path):
+ if strict_data_files:
+ msg = "Could not find file {} and --strict-data-files is set."
+ raise ValueError(msg.format(path))
+ else:
+ msg = "Could not find {}."
+ pytest.skip(msg.format(path))
+ return path
+ return deco
+
+
+@pytest.fixture
+def iris(datapath):
+ """The iris dataset as a DataFrame."""
+ return pd.read_csv(datapath('data', 'iris.csv'))
+
+
+@pytest.fixture(params=['nlargest', 'nsmallest'])
+def nselect_method(request):
+ """
+ Fixture for trying all nselect methods
+ """
+ return request.param
+
+
+@pytest.fixture(params=['left', 'right', 'both', 'neither'])
+def closed(request):
+ """
+ Fixture for trying all interval closed parameters
+ """
+ return request.param
+
+
+@pytest.fixture(params=['left', 'right', 'both', 'neither'])
+def other_closed(request):
+ """
+ Secondary closed fixture to allow parametrizing over all pairs of closed
+ """
+ return request.param
+
+
+@pytest.fixture(params=[None, np.nan, pd.NaT, float('nan'), np.float('NaN')])
+def nulls_fixture(request):
+ """
+ Fixture for each null type in pandas
+ """
+ return request.param
+
+
+nulls_fixture2 = nulls_fixture # Generate cartesian product of nulls_fixture
+
+
+@pytest.fixture(params=[None, np.nan, pd.NaT])
+def unique_nulls_fixture(request):
+ """
+ Fixture for each null type in pandas, each null type exactly once
+ """
+ return request.param
+
+
+# Generate cartesian product of unique_nulls_fixture:
+unique_nulls_fixture2 = unique_nulls_fixture
+
+
+TIMEZONES = [None, 'UTC', 'US/Eastern', 'Asia/Tokyo', 'dateutil/US/Pacific',
+ 'dateutil/Asia/Singapore', tzutc(), tzlocal(), FixedOffset(300),
+ FixedOffset(0), FixedOffset(-300)]
+
+
+@td.parametrize_fixture_doc(str(TIMEZONES))
+@pytest.fixture(params=TIMEZONES)
+def tz_naive_fixture(request):
+ """
+ Fixture for trying timezones including default (None): {0}
+ """
+ return request.param
+
+
+@td.parametrize_fixture_doc(str(TIMEZONES[1:]))
+@pytest.fixture(params=TIMEZONES[1:])
+def tz_aware_fixture(request):
+ """
+ Fixture for trying explicit timezones: {0}
+ """
+ return request.param
+
+
+# ----------------------------------------------------------------
+# Dtypes
+UNSIGNED_INT_DTYPES = ["uint8", "uint16", "uint32", "uint64"]
+UNSIGNED_EA_INT_DTYPES = ["UInt8", "UInt16", "UInt32", "UInt64"]
+SIGNED_INT_DTYPES = [int, "int8", "int16", "int32", "int64"]
+SIGNED_EA_INT_DTYPES = ["Int8", "Int16", "Int32", "Int64"]
+ALL_INT_DTYPES = UNSIGNED_INT_DTYPES + SIGNED_INT_DTYPES
+ALL_EA_INT_DTYPES = UNSIGNED_EA_INT_DTYPES + SIGNED_EA_INT_DTYPES
+
+FLOAT_DTYPES = [float, "float32", "float64"]
+COMPLEX_DTYPES = [complex, "complex64", "complex128"]
+STRING_DTYPES = [str, 'str', 'U']
+
+DATETIME_DTYPES = ['datetime64[ns]', 'M8[ns]']
+TIMEDELTA_DTYPES = ['timedelta64[ns]', 'm8[ns]']
+
+BOOL_DTYPES = [bool, 'bool']
+BYTES_DTYPES = [bytes, 'bytes']
+OBJECT_DTYPES = [object, 'object']
+
+ALL_REAL_DTYPES = FLOAT_DTYPES + ALL_INT_DTYPES
+ALL_NUMPY_DTYPES = (ALL_REAL_DTYPES + COMPLEX_DTYPES + STRING_DTYPES
+ + DATETIME_DTYPES + TIMEDELTA_DTYPES + BOOL_DTYPES
+ + OBJECT_DTYPES + BYTES_DTYPES * PY3) # bytes only for PY3
+
+
+@pytest.fixture(params=STRING_DTYPES)
+def string_dtype(request):
+ """Parametrized fixture for string dtypes.
+
+ * str
+ * 'str'
+ * 'U'
+ """
+ return request.param
+
+
+@pytest.fixture(params=FLOAT_DTYPES)
+def float_dtype(request):
+ """
+ Parameterized fixture for float dtypes.
+
+ * float
+ * 'float32'
+ * 'float64'
+ """
+
+ return request.param
+
+
+@pytest.fixture(params=COMPLEX_DTYPES)
+def complex_dtype(request):
+ """
+ Parameterized fixture for complex dtypes.
+
+ * complex
+ * 'complex64'
+ * 'complex128'
+ """
+
+ return request.param
+
+
+@pytest.fixture(params=SIGNED_INT_DTYPES)
+def sint_dtype(request):
+ """
+ Parameterized fixture for signed integer dtypes.
+
+ * int
+ * 'int8'
+ * 'int16'
+ * 'int32'
+ * 'int64'
+ """
+
+ return request.param
+
+
+@pytest.fixture(params=UNSIGNED_INT_DTYPES)
+def uint_dtype(request):
+ """
+ Parameterized fixture for unsigned integer dtypes.
+
+ * 'uint8'
+ * 'uint16'
+ * 'uint32'
+ * 'uint64'
+ """
+
+ return request.param
+
+
+@pytest.fixture(params=ALL_INT_DTYPES)
+def any_int_dtype(request):
+ """
+ Parameterized fixture for any integer dtype.
+
+ * int
+ * 'int8'
+ * 'uint8'
+ * 'int16'
+ * 'uint16'
+ * 'int32'
+ * 'uint32'
+ * 'int64'
+ * 'uint64'
+ """
+
+ return request.param
+
+
+@pytest.fixture(params=ALL_REAL_DTYPES)
+def any_real_dtype(request):
+ """
+ Parameterized fixture for any (purely) real numeric dtype.
+
+ * int
+ * 'int8'
+ * 'uint8'
+ * 'int16'
+ * 'uint16'
+ * 'int32'
+ * 'uint32'
+ * 'int64'
+ * 'uint64'
+ * float
+ * 'float32'
+ * 'float64'
+ """
+
+ return request.param
+
+
+@pytest.fixture(params=ALL_NUMPY_DTYPES)
+def any_numpy_dtype(request):
+ """
+ Parameterized fixture for all numpy dtypes.
+
+ * bool
+ * 'bool'
+ * int
+ * 'int8'
+ * 'uint8'
+ * 'int16'
+ * 'uint16'
+ * 'int32'
+ * 'uint32'
+ * 'int64'
+ * 'uint64'
+ * float
+ * 'float32'
+ * 'float64'
+ * complex
+ * 'complex64'
+ * 'complex128'
+ * str
+ * 'str'
+ * 'U'
+ * bytes
+ * 'bytes'
+ * 'datetime64[ns]'
+ * 'M8[ns]'
+ * 'timedelta64[ns]'
+ * 'm8[ns]'
+ * object
+ * 'object'
+ """
+
+ return request.param
+
+
+# categoricals are handled separately
+_any_skipna_inferred_dtype = [
+ ('string', ['a', np.nan, 'c']),
+ ('unicode' if not PY3 else 'string', [u('a'), np.nan, u('c')]),
+ ('bytes' if PY3 else 'string', [b'a', np.nan, b'c']),
+ ('empty', [np.nan, np.nan, np.nan]),
+ ('empty', []),
+ ('mixed-integer', ['a', np.nan, 2]),
+ ('mixed', ['a', np.nan, 2.0]),
+ ('floating', [1.0, np.nan, 2.0]),
+ ('integer', [1, np.nan, 2]),
+ ('mixed-integer-float', [1, np.nan, 2.0]),
+ ('decimal', [Decimal(1), np.nan, Decimal(2)]),
+ ('boolean', [True, np.nan, False]),
+ ('datetime64', [np.datetime64('2013-01-01'), np.nan,
+ np.datetime64('2018-01-01')]),
+ ('datetime', [pd.Timestamp('20130101'), np.nan, pd.Timestamp('20180101')]),
+ ('date', [date(2013, 1, 1), np.nan, date(2018, 1, 1)]),
+ # The following two dtypes are commented out due to GH 23554
+ # ('complex', [1 + 1j, np.nan, 2 + 2j]),
+ # ('timedelta64', [np.timedelta64(1, 'D'),
+ # np.nan, np.timedelta64(2, 'D')]),
+ ('timedelta', [timedelta(1), np.nan, timedelta(2)]),
+ ('time', [time(1), np.nan, time(2)]),
+ ('period', [pd.Period(2013), pd.NaT, pd.Period(2018)]),
+ ('interval', [pd.Interval(0, 1), np.nan, pd.Interval(0, 2)])]
+ids, _ = zip(*_any_skipna_inferred_dtype) # use inferred type as fixture-id
+
+
+@pytest.fixture(params=_any_skipna_inferred_dtype, ids=ids)
+def any_skipna_inferred_dtype(request):
+ """
+ Fixture for all inferred dtypes from _libs.lib.infer_dtype
+
+ The covered (inferred) types are:
+ * 'string'
+ * 'unicode' (if PY2)
+ * 'empty'
+ * 'bytes' (if PY3)
+ * 'mixed'
+ * 'mixed-integer'
+ * 'mixed-integer-float'
+ * 'floating'
+ * 'integer'
+ * 'decimal'
+ * 'boolean'
+ * 'datetime64'
+ * 'datetime'
+ * 'date'
+ * 'timedelta'
+ * 'time'
+ * 'period'
+ * 'interval'
+
+ Returns
+ -------
+ inferred_dtype : str
+ The string for the inferred dtype from _libs.lib.infer_dtype
+ values : np.ndarray
+ An array of object dtype that will be inferred to have
+ `inferred_dtype`
+
+ Examples
+ --------
+ >>> import pandas._libs.lib as lib
+ >>>
+ >>> def test_something(any_skipna_inferred_dtype):
+ ... inferred_dtype, values = any_skipna_inferred_dtype
+ ... # will pass
+ ... assert lib.infer_dtype(values, skipna=True) == inferred_dtype
+ """
+ inferred_dtype, values = request.param
+ values = np.array(values, dtype=object) # object dtype to avoid casting
+
+ # correctness of inference tested in tests/dtypes/test_inference.py
+ return inferred_dtype, values
+
+
+@pytest.fixture(params=[getattr(pd.offsets, o) for o in pd.offsets.__all__ if
+ issubclass(getattr(pd.offsets, o), pd.offsets.Tick)])
+def tick_classes(request):
+ """
+ Fixture for Tick based datetime offsets available for a time series.
+ """
+ return request.param
+
+# ----------------------------------------------------------------
+# Global setup for tests using Hypothesis
+
+
+# Registering these strategies makes them globally available via st.from_type,
+# which is use for offsets in tests/tseries/offsets/test_offsets_properties.py
+for name in 'MonthBegin MonthEnd BMonthBegin BMonthEnd'.split():
+ cls = getattr(pd.tseries.offsets, name)
+ st.register_type_strategy(cls, st.builds(
+ cls,
+ n=st.integers(-99, 99),
+ normalize=st.booleans(),
+ ))
+
+for name in 'YearBegin YearEnd BYearBegin BYearEnd'.split():
+ cls = getattr(pd.tseries.offsets, name)
+ st.register_type_strategy(cls, st.builds(
+ cls,
+ n=st.integers(-5, 5),
+ normalize=st.booleans(),
+ month=st.integers(min_value=1, max_value=12),
+ ))
+
+for name in 'QuarterBegin QuarterEnd BQuarterBegin BQuarterEnd'.split():
+ cls = getattr(pd.tseries.offsets, name)
+ st.register_type_strategy(cls, st.builds(
+ cls,
+ n=st.integers(-24, 24),
+ normalize=st.booleans(),
+ startingMonth=st.integers(min_value=1, max_value=12)
+ ))
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/testing.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/testing.py
new file mode 100644
index 0000000000000000000000000000000000000000..dbea1ecc7362a75b345ee5c60f1c370fb779014b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pandas/testing.py
@@ -0,0 +1,8 @@
+# flake8: noqa
+
+"""
+Public testing utility functions.
+"""
+
+from pandas.util.testing import (
+ assert_frame_equal, assert_index_equal, assert_series_equal)
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/past/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/past/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b5d9db178995d01731e784340b7de496ad89a63
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/past/__init__.py
@@ -0,0 +1,92 @@
+# coding=utf-8
+"""
+past: compatibility with Python 2 from Python 3
+===============================================
+
+``past`` is a package to aid with Python 2/3 compatibility. Whereas ``future``
+contains backports of Python 3 constructs to Python 2, ``past`` provides
+implementations of some Python 2 constructs in Python 3 and tools to import and
+run Python 2 code in Python 3. It is intended to be used sparingly, as a way of
+running old Python 2 code from Python 3 until the code is ported properly.
+
+Potential uses for libraries:
+
+- as a step in porting a Python 2 codebase to Python 3 (e.g. with the ``futurize`` script)
+- to provide Python 3 support for previously Python 2-only libraries with the
+ same APIs as on Python 2 -- particularly with regard to 8-bit strings (the
+ ``past.builtins.str`` type).
+- to aid in providing minimal-effort Python 3 support for applications using
+ libraries that do not yet wish to upgrade their code properly to Python 3, or
+ wish to upgrade it gradually to Python 3 style.
+
+
+Here are some code examples that run identically on Python 3 and 2::
+
+ >>> from past.builtins import str as oldstr
+
+ >>> philosopher = oldstr(u'\u5b54\u5b50'.encode('utf-8'))
+ >>> # This now behaves like a Py2 byte-string on both Py2 and Py3.
+ >>> # For example, indexing returns a Python 2-like string object, not
+ >>> # an integer:
+ >>> philosopher[0]
+ '\xe5'
+ >>> type(philosopher[0])
+
+
+ >>> # List-producing versions of range, reduce, map, filter
+ >>> from past.builtins import range, reduce
+ >>> range(10)
+ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ >>> reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])
+ 15
+
+ >>> # Other functions removed in Python 3 are resurrected ...
+ >>> from past.builtins import execfile
+ >>> execfile('myfile.py')
+
+ >>> from past.builtins import raw_input
+ >>> name = raw_input('What is your name? ')
+ What is your name? [cursor]
+
+ >>> from past.builtins import reload
+ >>> reload(mymodule) # equivalent to imp.reload(mymodule) in Python 3
+
+ >>> from past.builtins import xrange
+ >>> for i in xrange(10):
+ ... pass
+
+
+It also provides import hooks so you can import and use Python 2 modules like
+this::
+
+ $ python3
+
+ >>> from past import autotranslate
+ >>> authotranslate('mypy2module')
+ >>> import mypy2module
+
+until the authors of the Python 2 modules have upgraded their code. Then, for
+example::
+
+ >>> mypy2module.func_taking_py2_string(oldstr(b'abcd'))
+
+
+Credits
+-------
+
+:Author: Ed Schofield
+:Sponsor: Python Charmers Pty Ltd, Australia: http://pythoncharmers.com
+
+
+Licensing
+---------
+Copyright 2013-2018 Python Charmers Pty Ltd, Australia.
+The software is distributed under an MIT licence. See LICENSE.txt.
+"""
+
+
+from past.translation import install_hooks as autotranslate
+from future import __version__, __copyright__, __license__
+
+__title__ = 'past'
+__author__ = 'Ed Schofield'
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pathlib2/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pathlib2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0db87ac38b639f51f0a8bdeb532185c12c680e21
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pathlib2/__init__.py
@@ -0,0 +1,1805 @@
+# Copyright (c) 2014-2017 Matthias C. M. Troffaes
+# Copyright (c) 2012-2014 Antoine Pitrou and contributors
+# Distributed under the terms of the MIT License.
+
+import ctypes
+import fnmatch
+import functools
+import io
+import ntpath
+import os
+import posixpath
+import re
+import six
+import sys
+
+from errno import EINVAL, ENOENT, ENOTDIR, EBADF
+from errno import EEXIST, EPERM, EACCES
+from operator import attrgetter
+from stat import (
+ S_ISDIR, S_ISLNK, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO)
+
+try:
+ from collections.abc import Sequence
+except ImportError:
+ from collections import Sequence
+
+try:
+ from urllib import quote as urlquote_from_bytes
+except ImportError:
+ from urllib.parse import quote_from_bytes as urlquote_from_bytes
+
+
+try:
+ intern = intern
+except NameError:
+ intern = sys.intern
+
+supports_symlinks = True
+if os.name == 'nt':
+ import nt
+ if sys.getwindowsversion()[:2] >= (6, 0) and sys.version_info >= (3, 2):
+ from nt import _getfinalpathname
+ else:
+ supports_symlinks = False
+ _getfinalpathname = None
+else:
+ nt = None
+
+try:
+ from os import scandir as os_scandir
+except ImportError:
+ from scandir import scandir as os_scandir
+
+__all__ = [
+ "PurePath", "PurePosixPath", "PureWindowsPath",
+ "Path", "PosixPath", "WindowsPath",
+ ]
+
+#
+# Internals
+#
+
+# EBADF - guard agains macOS `stat` throwing EBADF
+_IGNORED_ERROS = (ENOENT, ENOTDIR, EBADF)
+
+_IGNORED_WINERRORS = (
+ 21, # ERROR_NOT_READY - drive exists but is not accessible
+)
+
+
+def _ignore_error(exception):
+ return (getattr(exception, 'errno', None) in _IGNORED_ERROS or
+ getattr(exception, 'winerror', None) in _IGNORED_WINERRORS)
+
+
+def _py2_fsencode(parts):
+ # py2 => minimal unicode support
+ assert six.PY2
+ return [part.encode('ascii') if isinstance(part, six.text_type)
+ else part for part in parts]
+
+
+def _try_except_fileexistserror(try_func, except_func, else_func=None):
+ if sys.version_info >= (3, 3):
+ try:
+ try_func()
+ except FileExistsError as exc:
+ except_func(exc)
+ else:
+ if else_func is not None:
+ else_func()
+ else:
+ try:
+ try_func()
+ except EnvironmentError as exc:
+ if exc.errno != EEXIST:
+ raise
+ else:
+ except_func(exc)
+ else:
+ if else_func is not None:
+ else_func()
+
+
+def _try_except_filenotfounderror(try_func, except_func):
+ if sys.version_info >= (3, 3):
+ try:
+ try_func()
+ except FileNotFoundError as exc:
+ except_func(exc)
+ elif os.name != 'nt':
+ try:
+ try_func()
+ except EnvironmentError as exc:
+ if exc.errno != ENOENT:
+ raise
+ else:
+ except_func(exc)
+ else:
+ try:
+ try_func()
+ except WindowsError as exc:
+ # errno contains winerror
+ # 2 = file not found
+ # 3 = path not found
+ if exc.errno not in (2, 3):
+ raise
+ else:
+ except_func(exc)
+ except EnvironmentError as exc:
+ if exc.errno != ENOENT:
+ raise
+ else:
+ except_func(exc)
+
+
+def _try_except_permissionerror_iter(try_iter, except_iter):
+ if sys.version_info >= (3, 3):
+ try:
+ for x in try_iter():
+ yield x
+ except PermissionError as exc:
+ for x in except_iter(exc):
+ yield x
+ else:
+ try:
+ for x in try_iter():
+ yield x
+ except EnvironmentError as exc:
+ if exc.errno not in (EPERM, EACCES):
+ raise
+ else:
+ for x in except_iter(exc):
+ yield x
+
+
+def _win32_get_unique_path_id(path):
+ # get file information, needed for samefile on older Python versions
+ # see http://timgolden.me.uk/python/win32_how_do_i/
+ # see_if_two_files_are_the_same_file.html
+ from ctypes import POINTER, Structure, WinError
+ from ctypes.wintypes import DWORD, HANDLE, BOOL
+
+ class FILETIME(Structure):
+ _fields_ = [("datetime_lo", DWORD),
+ ("datetime_hi", DWORD),
+ ]
+
+ class BY_HANDLE_FILE_INFORMATION(Structure):
+ _fields_ = [("attributes", DWORD),
+ ("created_at", FILETIME),
+ ("accessed_at", FILETIME),
+ ("written_at", FILETIME),
+ ("volume", DWORD),
+ ("file_hi", DWORD),
+ ("file_lo", DWORD),
+ ("n_links", DWORD),
+ ("index_hi", DWORD),
+ ("index_lo", DWORD),
+ ]
+
+ CreateFile = ctypes.windll.kernel32.CreateFileW
+ CreateFile.argtypes = [ctypes.c_wchar_p, DWORD, DWORD, ctypes.c_void_p,
+ DWORD, DWORD, HANDLE]
+ CreateFile.restype = HANDLE
+ GetFileInformationByHandle = (
+ ctypes.windll.kernel32.GetFileInformationByHandle)
+ GetFileInformationByHandle.argtypes = [
+ HANDLE, POINTER(BY_HANDLE_FILE_INFORMATION)]
+ GetFileInformationByHandle.restype = BOOL
+ CloseHandle = ctypes.windll.kernel32.CloseHandle
+ CloseHandle.argtypes = [HANDLE]
+ CloseHandle.restype = BOOL
+ GENERIC_READ = 0x80000000
+ FILE_SHARE_READ = 0x00000001
+ FILE_FLAG_BACKUP_SEMANTICS = 0x02000000
+ OPEN_EXISTING = 3
+ if os.path.isdir(path):
+ flags = FILE_FLAG_BACKUP_SEMANTICS
+ else:
+ flags = 0
+ hfile = CreateFile(path, GENERIC_READ, FILE_SHARE_READ,
+ None, OPEN_EXISTING, flags, None)
+ if hfile == 0xffffffff:
+ if sys.version_info >= (3, 3):
+ raise FileNotFoundError(path)
+ else:
+ exc = OSError("file not found: path")
+ exc.errno = ENOENT
+ raise exc
+ info = BY_HANDLE_FILE_INFORMATION()
+ success = GetFileInformationByHandle(hfile, info)
+ CloseHandle(hfile)
+ if success == 0:
+ raise WinError()
+ return info.volume, info.index_hi, info.index_lo
+
+
+def _is_wildcard_pattern(pat):
+ # Whether this pattern needs actual matching using fnmatch, or can
+ # be looked up directly as a file.
+ return "*" in pat or "?" in pat or "[" in pat
+
+
+class _Flavour(object):
+
+ """A flavour implements a particular (platform-specific) set of path
+ semantics."""
+
+ def __init__(self):
+ self.join = self.sep.join
+
+ def parse_parts(self, parts):
+ if six.PY2:
+ parts = _py2_fsencode(parts)
+ parsed = []
+ sep = self.sep
+ altsep = self.altsep
+ drv = root = ''
+ it = reversed(parts)
+ for part in it:
+ if not part:
+ continue
+ if altsep:
+ part = part.replace(altsep, sep)
+ drv, root, rel = self.splitroot(part)
+ if sep in rel:
+ for x in reversed(rel.split(sep)):
+ if x and x != '.':
+ parsed.append(intern(x))
+ else:
+ if rel and rel != '.':
+ parsed.append(intern(rel))
+ if drv or root:
+ if not drv:
+ # If no drive is present, try to find one in the previous
+ # parts. This makes the result of parsing e.g.
+ # ("C:", "/", "a") reasonably intuitive.
+ for part in it:
+ if not part:
+ continue
+ if altsep:
+ part = part.replace(altsep, sep)
+ drv = self.splitroot(part)[0]
+ if drv:
+ break
+ break
+ if drv or root:
+ parsed.append(drv + root)
+ parsed.reverse()
+ return drv, root, parsed
+
+ def join_parsed_parts(self, drv, root, parts, drv2, root2, parts2):
+ """
+ Join the two paths represented by the respective
+ (drive, root, parts) tuples. Return a new (drive, root, parts) tuple.
+ """
+ if root2:
+ if not drv2 and drv:
+ return drv, root2, [drv + root2] + parts2[1:]
+ elif drv2:
+ if drv2 == drv or self.casefold(drv2) == self.casefold(drv):
+ # Same drive => second path is relative to the first
+ return drv, root, parts + parts2[1:]
+ else:
+ # Second path is non-anchored (common case)
+ return drv, root, parts + parts2
+ return drv2, root2, parts2
+
+
+class _WindowsFlavour(_Flavour):
+ # Reference for Windows paths can be found at
+ # http://msdn.microsoft.com/en-us/library/aa365247%28v=vs.85%29.aspx
+
+ sep = '\\'
+ altsep = '/'
+ has_drv = True
+ pathmod = ntpath
+
+ is_supported = (os.name == 'nt')
+
+ drive_letters = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')
+ ext_namespace_prefix = '\\\\?\\'
+
+ reserved_names = (
+ set(['CON', 'PRN', 'AUX', 'NUL']) |
+ set(['COM%d' % i for i in range(1, 10)]) |
+ set(['LPT%d' % i for i in range(1, 10)])
+ )
+
+ # Interesting findings about extended paths:
+ # - '\\?\c:\a', '//?/c:\a' and '//?/c:/a' are all supported
+ # but '\\?\c:/a' is not
+ # - extended paths are always absolute; "relative" extended paths will
+ # fail.
+
+ def splitroot(self, part, sep=sep):
+ first = part[0:1]
+ second = part[1:2]
+ if (second == sep and first == sep):
+ # XXX extended paths should also disable the collapsing of "."
+ # components (according to MSDN docs).
+ prefix, part = self._split_extended_path(part)
+ first = part[0:1]
+ second = part[1:2]
+ else:
+ prefix = ''
+ third = part[2:3]
+ if (second == sep and first == sep and third != sep):
+ # is a UNC path:
+ # vvvvvvvvvvvvvvvvvvvvv root
+ # \\machine\mountpoint\directory\etc\...
+ # directory ^^^^^^^^^^^^^^
+ index = part.find(sep, 2)
+ if index != -1:
+ index2 = part.find(sep, index + 1)
+ # a UNC path can't have two slashes in a row
+ # (after the initial two)
+ if index2 != index + 1:
+ if index2 == -1:
+ index2 = len(part)
+ if prefix:
+ return prefix + part[1:index2], sep, part[index2 + 1:]
+ else:
+ return part[:index2], sep, part[index2 + 1:]
+ drv = root = ''
+ if second == ':' and first in self.drive_letters:
+ drv = part[:2]
+ part = part[2:]
+ first = third
+ if first == sep:
+ root = first
+ part = part.lstrip(sep)
+ return prefix + drv, root, part
+
+ def casefold(self, s):
+ return s.lower()
+
+ def casefold_parts(self, parts):
+ return [p.lower() for p in parts]
+
+ def resolve(self, path, strict=False):
+ s = str(path)
+ if not s:
+ return os.getcwd()
+ previous_s = None
+ if _getfinalpathname is not None:
+ if strict:
+ return self._ext_to_normal(_getfinalpathname(s))
+ else:
+ # End of the path after the first one not found
+ tail_parts = []
+
+ def _try_func():
+ result[0] = self._ext_to_normal(_getfinalpathname(s))
+ # if there was no exception, set flag to 0
+ result[1] = 0
+
+ def _exc_func(exc):
+ pass
+
+ while True:
+ result = [None, 1]
+ _try_except_filenotfounderror(_try_func, _exc_func)
+ if result[1] == 1: # file not found exception raised
+ previous_s = s
+ s, tail = os.path.split(s)
+ tail_parts.append(tail)
+ if previous_s == s:
+ return path
+ else:
+ s = result[0]
+ return os.path.join(s, *reversed(tail_parts))
+ # Means fallback on absolute
+ return None
+
+ def _split_extended_path(self, s, ext_prefix=ext_namespace_prefix):
+ prefix = ''
+ if s.startswith(ext_prefix):
+ prefix = s[:4]
+ s = s[4:]
+ if s.startswith('UNC\\'):
+ prefix += s[:3]
+ s = '\\' + s[3:]
+ return prefix, s
+
+ def _ext_to_normal(self, s):
+ # Turn back an extended path into a normal DOS-like path
+ return self._split_extended_path(s)[1]
+
+ def is_reserved(self, parts):
+ # NOTE: the rules for reserved names seem somewhat complicated
+ # (e.g. r"..\NUL" is reserved but not r"foo\NUL").
+ # We err on the side of caution and return True for paths which are
+ # not considered reserved by Windows.
+ if not parts:
+ return False
+ if parts[0].startswith('\\\\'):
+ # UNC paths are never reserved
+ return False
+ return parts[-1].partition('.')[0].upper() in self.reserved_names
+
+ def make_uri(self, path):
+ # Under Windows, file URIs use the UTF-8 encoding.
+ drive = path.drive
+ if len(drive) == 2 and drive[1] == ':':
+ # It's a path on a local drive => 'file:///c:/a/b'
+ rest = path.as_posix()[2:].lstrip('/')
+ return 'file:///%s/%s' % (
+ drive, urlquote_from_bytes(rest.encode('utf-8')))
+ else:
+ # It's a path on a network drive => 'file://host/share/a/b'
+ return 'file:' + urlquote_from_bytes(
+ path.as_posix().encode('utf-8'))
+
+ def gethomedir(self, username):
+ if 'HOME' in os.environ:
+ userhome = os.environ['HOME']
+ elif 'USERPROFILE' in os.environ:
+ userhome = os.environ['USERPROFILE']
+ elif 'HOMEPATH' in os.environ:
+ try:
+ drv = os.environ['HOMEDRIVE']
+ except KeyError:
+ drv = ''
+ userhome = drv + os.environ['HOMEPATH']
+ else:
+ raise RuntimeError("Can't determine home directory")
+
+ if username:
+ # Try to guess user home directory. By default all users
+ # directories are located in the same place and are named by
+ # corresponding usernames. If current user home directory points
+ # to nonstandard place, this guess is likely wrong.
+ if os.environ['USERNAME'] != username:
+ drv, root, parts = self.parse_parts((userhome,))
+ if parts[-1] != os.environ['USERNAME']:
+ raise RuntimeError("Can't determine home directory "
+ "for %r" % username)
+ parts[-1] = username
+ if drv or root:
+ userhome = drv + root + self.join(parts[1:])
+ else:
+ userhome = self.join(parts)
+ return userhome
+
+
+class _PosixFlavour(_Flavour):
+ sep = '/'
+ altsep = ''
+ has_drv = False
+ pathmod = posixpath
+
+ is_supported = (os.name != 'nt')
+
+ def splitroot(self, part, sep=sep):
+ if part and part[0] == sep:
+ stripped_part = part.lstrip(sep)
+ # According to POSIX path resolution:
+ # http://pubs.opengroup.org/onlinepubs/009695399/basedefs/
+ # xbd_chap04.html#tag_04_11
+ # "A pathname that begins with two successive slashes may be
+ # interpreted in an implementation-defined manner, although more
+ # than two leading slashes shall be treated as a single slash".
+ if len(part) - len(stripped_part) == 2:
+ return '', sep * 2, stripped_part
+ else:
+ return '', sep, stripped_part
+ else:
+ return '', '', part
+
+ def casefold(self, s):
+ return s
+
+ def casefold_parts(self, parts):
+ return parts
+
+ def resolve(self, path, strict=False):
+ sep = self.sep
+ accessor = path._accessor
+ seen = {}
+
+ def _resolve(path, rest):
+ if rest.startswith(sep):
+ path = ''
+
+ for name in rest.split(sep):
+ if not name or name == '.':
+ # current dir
+ continue
+ if name == '..':
+ # parent dir
+ path, _, _ = path.rpartition(sep)
+ continue
+ newpath = path + sep + name
+ if newpath in seen:
+ # Already seen this path
+ path = seen[newpath]
+ if path is not None:
+ # use cached value
+ continue
+ # The symlink is not resolved, so we must have a symlink
+ # loop.
+ raise RuntimeError("Symlink loop from %r" % newpath)
+ # Resolve the symbolic link
+ try:
+ target = accessor.readlink(newpath)
+ except OSError as e:
+ if e.errno != EINVAL and strict:
+ raise
+ # Not a symlink, or non-strict mode. We just leave the path
+ # untouched.
+ path = newpath
+ else:
+ seen[newpath] = None # not resolved symlink
+ path = _resolve(path, target)
+ seen[newpath] = path # resolved symlink
+
+ return path
+ # NOTE: according to POSIX, getcwd() cannot contain path components
+ # which are symlinks.
+ base = '' if path.is_absolute() else os.getcwd()
+ return _resolve(base, str(path)) or sep
+
+ def is_reserved(self, parts):
+ return False
+
+ def make_uri(self, path):
+ # We represent the path using the local filesystem encoding,
+ # for portability to other applications.
+ bpath = bytes(path)
+ return 'file://' + urlquote_from_bytes(bpath)
+
+ def gethomedir(self, username):
+ if not username:
+ try:
+ return os.environ['HOME']
+ except KeyError:
+ import pwd
+ return pwd.getpwuid(os.getuid()).pw_dir
+ else:
+ import pwd
+ try:
+ return pwd.getpwnam(username).pw_dir
+ except KeyError:
+ raise RuntimeError("Can't determine home directory "
+ "for %r" % username)
+
+
+_windows_flavour = _WindowsFlavour()
+_posix_flavour = _PosixFlavour()
+
+
+class _Accessor:
+
+ """An accessor implements a particular (system-specific or not) way of
+ accessing paths on the filesystem."""
+
+
+class _NormalAccessor(_Accessor):
+
+ def _wrap_strfunc(strfunc):
+ @functools.wraps(strfunc)
+ def wrapped(pathobj, *args):
+ return strfunc(str(pathobj), *args)
+ return staticmethod(wrapped)
+
+ def _wrap_binary_strfunc(strfunc):
+ @functools.wraps(strfunc)
+ def wrapped(pathobjA, pathobjB, *args):
+ return strfunc(str(pathobjA), str(pathobjB), *args)
+ return staticmethod(wrapped)
+
+ stat = _wrap_strfunc(os.stat)
+
+ lstat = _wrap_strfunc(os.lstat)
+
+ open = _wrap_strfunc(os.open)
+
+ listdir = _wrap_strfunc(os.listdir)
+
+ scandir = _wrap_strfunc(os_scandir)
+
+ chmod = _wrap_strfunc(os.chmod)
+
+ if hasattr(os, "lchmod"):
+ lchmod = _wrap_strfunc(os.lchmod)
+ else:
+ def lchmod(self, pathobj, mode):
+ raise NotImplementedError("lchmod() not available on this system")
+
+ mkdir = _wrap_strfunc(os.mkdir)
+
+ unlink = _wrap_strfunc(os.unlink)
+
+ rmdir = _wrap_strfunc(os.rmdir)
+
+ rename = _wrap_binary_strfunc(os.rename)
+
+ if sys.version_info >= (3, 3):
+ replace = _wrap_binary_strfunc(os.replace)
+
+ if nt:
+ if supports_symlinks:
+ symlink = _wrap_binary_strfunc(os.symlink)
+ else:
+ def symlink(a, b, target_is_directory):
+ raise NotImplementedError(
+ "symlink() not available on this system")
+ else:
+ # Under POSIX, os.symlink() takes two args
+ @staticmethod
+ def symlink(a, b, target_is_directory):
+ return os.symlink(str(a), str(b))
+
+ utime = _wrap_strfunc(os.utime)
+
+ # Helper for resolve()
+ def readlink(self, path):
+ return os.readlink(path)
+
+
+_normal_accessor = _NormalAccessor()
+
+
+#
+# Globbing helpers
+#
+
+def _make_selector(pattern_parts):
+ pat = pattern_parts[0]
+ child_parts = pattern_parts[1:]
+ if pat == '**':
+ cls = _RecursiveWildcardSelector
+ elif '**' in pat:
+ raise ValueError(
+ "Invalid pattern: '**' can only be an entire path component")
+ elif _is_wildcard_pattern(pat):
+ cls = _WildcardSelector
+ else:
+ cls = _PreciseSelector
+ return cls(pat, child_parts)
+
+
+if hasattr(functools, "lru_cache"):
+ _make_selector = functools.lru_cache()(_make_selector)
+
+
+class _Selector:
+
+ """A selector matches a specific glob pattern part against the children
+ of a given path."""
+
+ def __init__(self, child_parts):
+ self.child_parts = child_parts
+ if child_parts:
+ self.successor = _make_selector(child_parts)
+ self.dironly = True
+ else:
+ self.successor = _TerminatingSelector()
+ self.dironly = False
+
+ def select_from(self, parent_path):
+ """Iterate over all child paths of `parent_path` matched by this
+ selector. This can contain parent_path itself."""
+ path_cls = type(parent_path)
+ is_dir = path_cls.is_dir
+ exists = path_cls.exists
+ scandir = parent_path._accessor.scandir
+ if not is_dir(parent_path):
+ return iter([])
+ return self._select_from(parent_path, is_dir, exists, scandir)
+
+
+class _TerminatingSelector:
+
+ def _select_from(self, parent_path, is_dir, exists, scandir):
+ yield parent_path
+
+
+class _PreciseSelector(_Selector):
+
+ def __init__(self, name, child_parts):
+ self.name = name
+ _Selector.__init__(self, child_parts)
+
+ def _select_from(self, parent_path, is_dir, exists, scandir):
+ def try_iter():
+ path = parent_path._make_child_relpath(self.name)
+ if (is_dir if self.dironly else exists)(path):
+ for p in self.successor._select_from(
+ path, is_dir, exists, scandir):
+ yield p
+
+ def except_iter(exc):
+ return
+ yield
+
+ for x in _try_except_permissionerror_iter(try_iter, except_iter):
+ yield x
+
+
+class _WildcardSelector(_Selector):
+
+ def __init__(self, pat, child_parts):
+ self.pat = re.compile(fnmatch.translate(pat))
+ _Selector.__init__(self, child_parts)
+
+ def _select_from(self, parent_path, is_dir, exists, scandir):
+ def try_iter():
+ cf = parent_path._flavour.casefold
+ entries = list(scandir(parent_path))
+ for entry in entries:
+ if not self.dironly or entry.is_dir():
+ name = entry.name
+ casefolded = cf(name)
+ if self.pat.match(casefolded):
+ path = parent_path._make_child_relpath(name)
+ for p in self.successor._select_from(
+ path, is_dir, exists, scandir):
+ yield p
+
+ def except_iter(exc):
+ return
+ yield
+
+ for x in _try_except_permissionerror_iter(try_iter, except_iter):
+ yield x
+
+
+class _RecursiveWildcardSelector(_Selector):
+
+ def __init__(self, pat, child_parts):
+ _Selector.__init__(self, child_parts)
+
+ def _iterate_directories(self, parent_path, is_dir, scandir):
+ yield parent_path
+
+ def try_iter():
+ entries = list(scandir(parent_path))
+ for entry in entries:
+ entry_is_dir = False
+ try:
+ entry_is_dir = entry.is_dir()
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ if entry_is_dir and not entry.is_symlink():
+ path = parent_path._make_child_relpath(entry.name)
+ for p in self._iterate_directories(path, is_dir, scandir):
+ yield p
+
+ def except_iter(exc):
+ return
+ yield
+
+ for x in _try_except_permissionerror_iter(try_iter, except_iter):
+ yield x
+
+ def _select_from(self, parent_path, is_dir, exists, scandir):
+ def try_iter():
+ yielded = set()
+ try:
+ successor_select = self.successor._select_from
+ for starting_point in self._iterate_directories(
+ parent_path, is_dir, scandir):
+ for p in successor_select(
+ starting_point, is_dir, exists, scandir):
+ if p not in yielded:
+ yield p
+ yielded.add(p)
+ finally:
+ yielded.clear()
+
+ def except_iter(exc):
+ return
+ yield
+
+ for x in _try_except_permissionerror_iter(try_iter, except_iter):
+ yield x
+
+
+#
+# Public API
+#
+
+class _PathParents(Sequence):
+
+ """This object provides sequence-like access to the logical ancestors
+ of a path. Don't try to construct it yourself."""
+ __slots__ = ('_pathcls', '_drv', '_root', '_parts')
+
+ def __init__(self, path):
+ # We don't store the instance to avoid reference cycles
+ self._pathcls = type(path)
+ self._drv = path._drv
+ self._root = path._root
+ self._parts = path._parts
+
+ def __len__(self):
+ if self._drv or self._root:
+ return len(self._parts) - 1
+ else:
+ return len(self._parts)
+
+ def __getitem__(self, idx):
+ if idx < 0 or idx >= len(self):
+ raise IndexError(idx)
+ return self._pathcls._from_parsed_parts(self._drv, self._root,
+ self._parts[:-idx - 1])
+
+ def __repr__(self):
+ return "<{0}.parents>".format(self._pathcls.__name__)
+
+
+class PurePath(object):
+
+ """PurePath represents a filesystem path and offers operations which
+ don't imply any actual filesystem I/O. Depending on your system,
+ instantiating a PurePath will return either a PurePosixPath or a
+ PureWindowsPath object. You can also instantiate either of these classes
+ directly, regardless of your system.
+ """
+ __slots__ = (
+ '_drv', '_root', '_parts',
+ '_str', '_hash', '_pparts', '_cached_cparts',
+ )
+
+ def __new__(cls, *args):
+ """Construct a PurePath from one or several strings and or existing
+ PurePath objects. The strings and path objects are combined so as
+ to yield a canonicalized path, which is incorporated into the
+ new PurePath object.
+ """
+ if cls is PurePath:
+ cls = PureWindowsPath if os.name == 'nt' else PurePosixPath
+ return cls._from_parts(args)
+
+ def __reduce__(self):
+ # Using the parts tuple helps share interned path parts
+ # when pickling related paths.
+ return (self.__class__, tuple(self._parts))
+
+ @classmethod
+ def _parse_args(cls, args):
+ # This is useful when you don't want to create an instance, just
+ # canonicalize some constructor arguments.
+ parts = []
+ for a in args:
+ if isinstance(a, PurePath):
+ parts += a._parts
+ else:
+ if sys.version_info >= (3, 6):
+ a = os.fspath(a)
+ else:
+ # duck typing for older Python versions
+ if hasattr(a, "__fspath__"):
+ a = a.__fspath__()
+ if isinstance(a, str):
+ # Force-cast str subclasses to str (issue #21127)
+ parts.append(str(a))
+ # also handle unicode for PY2 (six.text_type = unicode)
+ elif six.PY2 and isinstance(a, six.text_type):
+ # cast to str using filesystem encoding
+ parts.append(a.encode(sys.getfilesystemencoding()))
+ else:
+ raise TypeError(
+ "argument should be a str object or an os.PathLike "
+ "object returning str, not %r"
+ % type(a))
+ return cls._flavour.parse_parts(parts)
+
+ @classmethod
+ def _from_parts(cls, args, init=True):
+ # We need to call _parse_args on the instance, so as to get the
+ # right flavour.
+ self = object.__new__(cls)
+ drv, root, parts = self._parse_args(args)
+ self._drv = drv
+ self._root = root
+ self._parts = parts
+ if init:
+ self._init()
+ return self
+
+ @classmethod
+ def _from_parsed_parts(cls, drv, root, parts, init=True):
+ self = object.__new__(cls)
+ self._drv = drv
+ self._root = root
+ self._parts = parts
+ if init:
+ self._init()
+ return self
+
+ @classmethod
+ def _format_parsed_parts(cls, drv, root, parts):
+ if drv or root:
+ return drv + root + cls._flavour.join(parts[1:])
+ else:
+ return cls._flavour.join(parts)
+
+ def _init(self):
+ # Overridden in concrete Path
+ pass
+
+ def _make_child(self, args):
+ drv, root, parts = self._parse_args(args)
+ drv, root, parts = self._flavour.join_parsed_parts(
+ self._drv, self._root, self._parts, drv, root, parts)
+ return self._from_parsed_parts(drv, root, parts)
+
+ def __str__(self):
+ """Return the string representation of the path, suitable for
+ passing to system calls."""
+ try:
+ return self._str
+ except AttributeError:
+ self._str = self._format_parsed_parts(self._drv, self._root,
+ self._parts) or '.'
+ return self._str
+
+ def __fspath__(self):
+ return str(self)
+
+ def as_posix(self):
+ """Return the string representation of the path with forward (/)
+ slashes."""
+ f = self._flavour
+ return str(self).replace(f.sep, '/')
+
+ def __bytes__(self):
+ """Return the bytes representation of the path. This is only
+ recommended to use under Unix."""
+ if sys.version_info < (3, 2):
+ raise NotImplementedError("needs Python 3.2 or later")
+ return os.fsencode(str(self))
+
+ def __repr__(self):
+ return "{0}({1!r})".format(self.__class__.__name__, self.as_posix())
+
+ def as_uri(self):
+ """Return the path as a 'file' URI."""
+ if not self.is_absolute():
+ raise ValueError("relative path can't be expressed as a file URI")
+ return self._flavour.make_uri(self)
+
+ @property
+ def _cparts(self):
+ # Cached casefolded parts, for hashing and comparison
+ try:
+ return self._cached_cparts
+ except AttributeError:
+ self._cached_cparts = self._flavour.casefold_parts(self._parts)
+ return self._cached_cparts
+
+ def __eq__(self, other):
+ if not isinstance(other, PurePath):
+ return NotImplemented
+ return (
+ self._cparts == other._cparts
+ and self._flavour is other._flavour)
+
+ def __ne__(self, other):
+ return not self == other
+
+ def __hash__(self):
+ try:
+ return self._hash
+ except AttributeError:
+ self._hash = hash(tuple(self._cparts))
+ return self._hash
+
+ def __lt__(self, other):
+ if (not isinstance(other, PurePath)
+ or self._flavour is not other._flavour):
+ return NotImplemented
+ return self._cparts < other._cparts
+
+ def __le__(self, other):
+ if (not isinstance(other, PurePath)
+ or self._flavour is not other._flavour):
+ return NotImplemented
+ return self._cparts <= other._cparts
+
+ def __gt__(self, other):
+ if (not isinstance(other, PurePath)
+ or self._flavour is not other._flavour):
+ return NotImplemented
+ return self._cparts > other._cparts
+
+ def __ge__(self, other):
+ if (not isinstance(other, PurePath)
+ or self._flavour is not other._flavour):
+ return NotImplemented
+ return self._cparts >= other._cparts
+
+ drive = property(attrgetter('_drv'),
+ doc="""The drive prefix (letter or UNC path), if any.""")
+
+ root = property(attrgetter('_root'),
+ doc="""The root of the path, if any.""")
+
+ @property
+ def anchor(self):
+ """The concatenation of the drive and root, or ''."""
+ anchor = self._drv + self._root
+ return anchor
+
+ @property
+ def name(self):
+ """The final path component, if any."""
+ parts = self._parts
+ if len(parts) == (1 if (self._drv or self._root) else 0):
+ return ''
+ return parts[-1]
+
+ @property
+ def suffix(self):
+ """The final component's last suffix, if any."""
+ name = self.name
+ i = name.rfind('.')
+ if 0 < i < len(name) - 1:
+ return name[i:]
+ else:
+ return ''
+
+ @property
+ def suffixes(self):
+ """A list of the final component's suffixes, if any."""
+ name = self.name
+ if name.endswith('.'):
+ return []
+ name = name.lstrip('.')
+ return ['.' + suffix for suffix in name.split('.')[1:]]
+
+ @property
+ def stem(self):
+ """The final path component, minus its last suffix."""
+ name = self.name
+ i = name.rfind('.')
+ if 0 < i < len(name) - 1:
+ return name[:i]
+ else:
+ return name
+
+ def with_name(self, name):
+ """Return a new path with the file name changed."""
+ if not self.name:
+ raise ValueError("%r has an empty name" % (self,))
+ drv, root, parts = self._flavour.parse_parts((name,))
+ if (not name or name[-1] in [self._flavour.sep, self._flavour.altsep]
+ or drv or root or len(parts) != 1):
+ raise ValueError("Invalid name %r" % (name))
+ return self._from_parsed_parts(self._drv, self._root,
+ self._parts[:-1] + [name])
+
+ def with_suffix(self, suffix):
+ """Return a new path with the file suffix changed. If the path
+ has no suffix, add given suffix. If the given suffix is an empty
+ string, remove the suffix from the path.
+ """
+ # XXX if suffix is None, should the current suffix be removed?
+ f = self._flavour
+ if f.sep in suffix or f.altsep and f.altsep in suffix:
+ raise ValueError("Invalid suffix %r" % (suffix))
+ if suffix and not suffix.startswith('.') or suffix == '.':
+ raise ValueError("Invalid suffix %r" % (suffix))
+ name = self.name
+ if not name:
+ raise ValueError("%r has an empty name" % (self,))
+ old_suffix = self.suffix
+ if not old_suffix:
+ name = name + suffix
+ else:
+ name = name[:-len(old_suffix)] + suffix
+ return self._from_parsed_parts(self._drv, self._root,
+ self._parts[:-1] + [name])
+
+ def relative_to(self, *other):
+ """Return the relative path to another path identified by the passed
+ arguments. If the operation is not possible (because this is not
+ a subpath of the other path), raise ValueError.
+ """
+ # For the purpose of this method, drive and root are considered
+ # separate parts, i.e.:
+ # Path('c:/').relative_to('c:') gives Path('/')
+ # Path('c:/').relative_to('/') raise ValueError
+ if not other:
+ raise TypeError("need at least one argument")
+ parts = self._parts
+ drv = self._drv
+ root = self._root
+ if root:
+ abs_parts = [drv, root] + parts[1:]
+ else:
+ abs_parts = parts
+ to_drv, to_root, to_parts = self._parse_args(other)
+ if to_root:
+ to_abs_parts = [to_drv, to_root] + to_parts[1:]
+ else:
+ to_abs_parts = to_parts
+ n = len(to_abs_parts)
+ cf = self._flavour.casefold_parts
+ if (root or drv) if n == 0 else cf(abs_parts[:n]) != cf(to_abs_parts):
+ formatted = self._format_parsed_parts(to_drv, to_root, to_parts)
+ raise ValueError("{0!r} does not start with {1!r}"
+ .format(str(self), str(formatted)))
+ return self._from_parsed_parts('', root if n == 1 else '',
+ abs_parts[n:])
+
+ @property
+ def parts(self):
+ """An object providing sequence-like access to the
+ components in the filesystem path."""
+ # We cache the tuple to avoid building a new one each time .parts
+ # is accessed. XXX is this necessary?
+ try:
+ return self._pparts
+ except AttributeError:
+ self._pparts = tuple(self._parts)
+ return self._pparts
+
+ def joinpath(self, *args):
+ """Combine this path with one or several arguments, and return a
+ new path representing either a subpath (if all arguments are relative
+ paths) or a totally different path (if one of the arguments is
+ anchored).
+ """
+ return self._make_child(args)
+
+ def __truediv__(self, key):
+ return self._make_child((key,))
+
+ def __rtruediv__(self, key):
+ return self._from_parts([key] + self._parts)
+
+ if six.PY2:
+ __div__ = __truediv__
+ __rdiv__ = __rtruediv__
+
+ @property
+ def parent(self):
+ """The logical parent of the path."""
+ drv = self._drv
+ root = self._root
+ parts = self._parts
+ if len(parts) == 1 and (drv or root):
+ return self
+ return self._from_parsed_parts(drv, root, parts[:-1])
+
+ @property
+ def parents(self):
+ """A sequence of this path's logical parents."""
+ return _PathParents(self)
+
+ def is_absolute(self):
+ """True if the path is absolute (has both a root and, if applicable,
+ a drive)."""
+ if not self._root:
+ return False
+ return not self._flavour.has_drv or bool(self._drv)
+
+ def is_reserved(self):
+ """Return True if the path contains one of the special names reserved
+ by the system, if any."""
+ return self._flavour.is_reserved(self._parts)
+
+ def match(self, path_pattern):
+ """
+ Return True if this path matches the given pattern.
+ """
+ cf = self._flavour.casefold
+ path_pattern = cf(path_pattern)
+ drv, root, pat_parts = self._flavour.parse_parts((path_pattern,))
+ if not pat_parts:
+ raise ValueError("empty pattern")
+ if drv and drv != cf(self._drv):
+ return False
+ if root and root != cf(self._root):
+ return False
+ parts = self._cparts
+ if drv or root:
+ if len(pat_parts) != len(parts):
+ return False
+ pat_parts = pat_parts[1:]
+ elif len(pat_parts) > len(parts):
+ return False
+ for part, pat in zip(reversed(parts), reversed(pat_parts)):
+ if not fnmatch.fnmatchcase(part, pat):
+ return False
+ return True
+
+
+# Can't subclass os.PathLike from PurePath and keep the constructor
+# optimizations in PurePath._parse_args().
+if sys.version_info >= (3, 6):
+ os.PathLike.register(PurePath)
+
+
+class PurePosixPath(PurePath):
+ _flavour = _posix_flavour
+ __slots__ = ()
+
+
+class PureWindowsPath(PurePath):
+ """PurePath subclass for Windows systems.
+
+ On a Windows system, instantiating a PurePath should return this object.
+ However, you can also instantiate it directly on any system.
+ """
+ _flavour = _windows_flavour
+ __slots__ = ()
+
+
+# Filesystem-accessing classes
+
+
+class Path(PurePath):
+ """PurePath subclass that can make system calls.
+
+ Path represents a filesystem path but unlike PurePath, also offers
+ methods to do system calls on path objects. Depending on your system,
+ instantiating a Path will return either a PosixPath or a WindowsPath
+ object. You can also instantiate a PosixPath or WindowsPath directly,
+ but cannot instantiate a WindowsPath on a POSIX system or vice versa.
+ """
+ __slots__ = (
+ '_accessor',
+ '_closed',
+ )
+
+ def __new__(cls, *args, **kwargs):
+ if cls is Path:
+ cls = WindowsPath if os.name == 'nt' else PosixPath
+ self = cls._from_parts(args, init=False)
+ if not self._flavour.is_supported:
+ raise NotImplementedError("cannot instantiate %r on your system"
+ % (cls.__name__,))
+ self._init()
+ return self
+
+ def _init(self,
+ # Private non-constructor arguments
+ template=None,
+ ):
+ self._closed = False
+ if template is not None:
+ self._accessor = template._accessor
+ else:
+ self._accessor = _normal_accessor
+
+ def _make_child_relpath(self, part):
+ # This is an optimization used for dir walking. `part` must be
+ # a single part relative to this path.
+ parts = self._parts + [part]
+ return self._from_parsed_parts(self._drv, self._root, parts)
+
+ def __enter__(self):
+ if self._closed:
+ self._raise_closed()
+ return self
+
+ def __exit__(self, t, v, tb):
+ self._closed = True
+
+ def _raise_closed(self):
+ raise ValueError("I/O operation on closed path")
+
+ def _opener(self, name, flags, mode=0o666):
+ # A stub for the opener argument to built-in open()
+ return self._accessor.open(self, flags, mode)
+
+ def _raw_open(self, flags, mode=0o777):
+ """
+ Open the file pointed by this path and return a file descriptor,
+ as os.open() does.
+ """
+ if self._closed:
+ self._raise_closed()
+ return self._accessor.open(self, flags, mode)
+
+ # Public API
+
+ @classmethod
+ def cwd(cls):
+ """Return a new path pointing to the current working directory
+ (as returned by os.getcwd()).
+ """
+ return cls(os.getcwd())
+
+ @classmethod
+ def home(cls):
+ """Return a new path pointing to the user's home directory (as
+ returned by os.path.expanduser('~')).
+ """
+ return cls(cls()._flavour.gethomedir(None))
+
+ def samefile(self, other_path):
+ """Return whether other_path is the same or not as this file
+ (as returned by os.path.samefile()).
+ """
+ if hasattr(os.path, "samestat"):
+ st = self.stat()
+ try:
+ other_st = other_path.stat()
+ except AttributeError:
+ other_st = os.stat(other_path)
+ return os.path.samestat(st, other_st)
+ else:
+ filename1 = six.text_type(self)
+ filename2 = six.text_type(other_path)
+ st1 = _win32_get_unique_path_id(filename1)
+ st2 = _win32_get_unique_path_id(filename2)
+ return st1 == st2
+
+ def iterdir(self):
+ """Iterate over the files in this directory. Does not yield any
+ result for the special paths '.' and '..'.
+ """
+ if self._closed:
+ self._raise_closed()
+ for name in self._accessor.listdir(self):
+ if name in ('.', '..'):
+ # Yielding a path object for these makes little sense
+ continue
+ yield self._make_child_relpath(name)
+ if self._closed:
+ self._raise_closed()
+
+ def glob(self, pattern):
+ """Iterate over this subtree and yield all existing files (of any
+ kind, including directories) matching the given relative pattern.
+ """
+ if not pattern:
+ raise ValueError("Unacceptable pattern: {0!r}".format(pattern))
+ pattern = self._flavour.casefold(pattern)
+ drv, root, pattern_parts = self._flavour.parse_parts((pattern,))
+ if drv or root:
+ raise NotImplementedError("Non-relative patterns are unsupported")
+ selector = _make_selector(tuple(pattern_parts))
+ for p in selector.select_from(self):
+ yield p
+
+ def rglob(self, pattern):
+ """Recursively yield all existing files (of any kind, including
+ directories) matching the given relative pattern, anywhere in
+ this subtree.
+ """
+ pattern = self._flavour.casefold(pattern)
+ drv, root, pattern_parts = self._flavour.parse_parts((pattern,))
+ if drv or root:
+ raise NotImplementedError("Non-relative patterns are unsupported")
+ selector = _make_selector(("**",) + tuple(pattern_parts))
+ for p in selector.select_from(self):
+ yield p
+
+ def absolute(self):
+ """Return an absolute version of this path. This function works
+ even if the path doesn't point to anything.
+
+ No normalization is done, i.e. all '.' and '..' will be kept along.
+ Use resolve() to get the canonical path to a file.
+ """
+ # XXX untested yet!
+ if self._closed:
+ self._raise_closed()
+ if self.is_absolute():
+ return self
+ # FIXME this must defer to the specific flavour (and, under Windows,
+ # use nt._getfullpathname())
+ obj = self._from_parts([os.getcwd()] + self._parts, init=False)
+ obj._init(template=self)
+ return obj
+
+ def resolve(self, strict=False):
+ """
+ Make the path absolute, resolving all symlinks on the way and also
+ normalizing it (for example turning slashes into backslashes under
+ Windows).
+ """
+ if self._closed:
+ self._raise_closed()
+ s = self._flavour.resolve(self, strict=strict)
+ if s is None:
+ # No symlink resolution => for consistency, raise an error if
+ # the path is forbidden
+ # but not raise error if file does not exist (see issue #54).
+
+ def _try_func():
+ self.stat()
+
+ def _exc_func(exc):
+ pass
+
+ _try_except_filenotfounderror(_try_func, _exc_func)
+ s = str(self.absolute())
+ else:
+ # ensure s is a string (normpath requires this on older python)
+ s = str(s)
+ # Now we have no symlinks in the path, it's safe to normalize it.
+ normed = self._flavour.pathmod.normpath(s)
+ obj = self._from_parts((normed,), init=False)
+ obj._init(template=self)
+ return obj
+
+ def stat(self):
+ """
+ Return the result of the stat() system call on this path, like
+ os.stat() does.
+ """
+ return self._accessor.stat(self)
+
+ def owner(self):
+ """
+ Return the login name of the file owner.
+ """
+ import pwd
+ return pwd.getpwuid(self.stat().st_uid).pw_name
+
+ def group(self):
+ """
+ Return the group name of the file gid.
+ """
+ import grp
+ return grp.getgrgid(self.stat().st_gid).gr_name
+
+ def open(self, mode='r', buffering=-1, encoding=None,
+ errors=None, newline=None):
+ """
+ Open the file pointed by this path and return a file object, as
+ the built-in open() function does.
+ """
+ if self._closed:
+ self._raise_closed()
+ if sys.version_info >= (3, 3):
+ return io.open(
+ str(self), mode, buffering, encoding, errors, newline,
+ opener=self._opener)
+ else:
+ return io.open(str(self), mode, buffering,
+ encoding, errors, newline)
+
+ def read_bytes(self):
+ """
+ Open the file in bytes mode, read it, and close the file.
+ """
+ with self.open(mode='rb') as f:
+ return f.read()
+
+ def read_text(self, encoding=None, errors=None):
+ """
+ Open the file in text mode, read it, and close the file.
+ """
+ with self.open(mode='r', encoding=encoding, errors=errors) as f:
+ return f.read()
+
+ def write_bytes(self, data):
+ """
+ Open the file in bytes mode, write to it, and close the file.
+ """
+ if not isinstance(data, six.binary_type):
+ raise TypeError(
+ 'data must be %s, not %s' %
+ (six.binary_type.__name__, data.__class__.__name__))
+ with self.open(mode='wb') as f:
+ return f.write(data)
+
+ def write_text(self, data, encoding=None, errors=None):
+ """
+ Open the file in text mode, write to it, and close the file.
+ """
+ if not isinstance(data, six.text_type):
+ raise TypeError(
+ 'data must be %s, not %s' %
+ (six.text_type.__name__, data.__class__.__name__))
+ with self.open(mode='w', encoding=encoding, errors=errors) as f:
+ return f.write(data)
+
+ def touch(self, mode=0o666, exist_ok=True):
+ """
+ Create this file with the given access mode, if it doesn't exist.
+ """
+ if self._closed:
+ self._raise_closed()
+ if exist_ok:
+ # First try to bump modification time
+ # Implementation note: GNU touch uses the UTIME_NOW option of
+ # the utimensat() / futimens() functions.
+ try:
+ self._accessor.utime(self, None)
+ except OSError:
+ # Avoid exception chaining
+ pass
+ else:
+ return
+ flags = os.O_CREAT | os.O_WRONLY
+ if not exist_ok:
+ flags |= os.O_EXCL
+ fd = self._raw_open(flags, mode)
+ os.close(fd)
+
+ def mkdir(self, mode=0o777, parents=False, exist_ok=False):
+ """
+ Create a new directory at this given path.
+ """
+ if self._closed:
+ self._raise_closed()
+
+ def _try_func():
+ self._accessor.mkdir(self, mode)
+
+ def _exc_func(exc):
+ if not parents or self.parent == self:
+ raise exc
+ self.parent.mkdir(parents=True, exist_ok=True)
+ self.mkdir(mode, parents=False, exist_ok=exist_ok)
+
+ try:
+ _try_except_filenotfounderror(_try_func, _exc_func)
+ except OSError:
+ # Cannot rely on checking for EEXIST, since the operating system
+ # could give priority to other errors like EACCES or EROFS
+ if not exist_ok or not self.is_dir():
+ raise
+
+ def chmod(self, mode):
+ """
+ Change the permissions of the path, like os.chmod().
+ """
+ if self._closed:
+ self._raise_closed()
+ self._accessor.chmod(self, mode)
+
+ def lchmod(self, mode):
+ """
+ Like chmod(), except if the path points to a symlink, the symlink's
+ permissions are changed, rather than its target's.
+ """
+ if self._closed:
+ self._raise_closed()
+ self._accessor.lchmod(self, mode)
+
+ def unlink(self):
+ """
+ Remove this file or link.
+ If the path is a directory, use rmdir() instead.
+ """
+ if self._closed:
+ self._raise_closed()
+ self._accessor.unlink(self)
+
+ def rmdir(self):
+ """
+ Remove this directory. The directory must be empty.
+ """
+ if self._closed:
+ self._raise_closed()
+ self._accessor.rmdir(self)
+
+ def lstat(self):
+ """
+ Like stat(), except if the path points to a symlink, the symlink's
+ status information is returned, rather than its target's.
+ """
+ if self._closed:
+ self._raise_closed()
+ return self._accessor.lstat(self)
+
+ def rename(self, target):
+ """
+ Rename this path to the given path.
+ """
+ if self._closed:
+ self._raise_closed()
+ self._accessor.rename(self, target)
+
+ def replace(self, target):
+ """
+ Rename this path to the given path, clobbering the existing
+ destination if it exists.
+ """
+ if sys.version_info < (3, 3):
+ raise NotImplementedError("replace() is only available "
+ "with Python 3.3 and later")
+ if self._closed:
+ self._raise_closed()
+ self._accessor.replace(self, target)
+
+ def symlink_to(self, target, target_is_directory=False):
+ """
+ Make this path a symlink pointing to the given path.
+ Note the order of arguments (self, target) is the reverse of
+ os.symlink's.
+ """
+ if self._closed:
+ self._raise_closed()
+ self._accessor.symlink(target, self, target_is_directory)
+
+ # Convenience functions for querying the stat results
+
+ def exists(self):
+ """
+ Whether this path exists.
+ """
+ try:
+ self.stat()
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+ return True
+
+ def is_dir(self):
+ """
+ Whether this path is a directory.
+ """
+ try:
+ return S_ISDIR(self.stat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist or is a broken symlink
+ # (see https://bitbucket.org/pitrou/pathlib/issue/12/)
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def is_file(self):
+ """
+ Whether this path is a regular file (also True for symlinks pointing
+ to regular files).
+ """
+ try:
+ return S_ISREG(self.stat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist or is a broken symlink
+ # (see https://bitbucket.org/pitrou/pathlib/issue/12/)
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def is_mount(self):
+ """
+ Check if this path is a POSIX mount point
+ """
+ # Need to exist and be a dir
+ if not self.exists() or not self.is_dir():
+ return False
+
+ parent = Path(self.parent)
+ try:
+ parent_dev = parent.stat().st_dev
+ except OSError:
+ return False
+
+ dev = self.stat().st_dev
+ if dev != parent_dev:
+ return True
+ ino = self.stat().st_ino
+ parent_ino = parent.stat().st_ino
+ return ino == parent_ino
+
+ def is_symlink(self):
+ """
+ Whether this path is a symbolic link.
+ """
+ try:
+ return S_ISLNK(self.lstat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def is_block_device(self):
+ """
+ Whether this path is a block device.
+ """
+ try:
+ return S_ISBLK(self.stat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist or is a broken symlink
+ # (see https://bitbucket.org/pitrou/pathlib/issue/12/)
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def is_char_device(self):
+ """
+ Whether this path is a character device.
+ """
+ try:
+ return S_ISCHR(self.stat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist or is a broken symlink
+ # (see https://bitbucket.org/pitrou/pathlib/issue/12/)
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def is_fifo(self):
+ """
+ Whether this path is a FIFO.
+ """
+ try:
+ return S_ISFIFO(self.stat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist or is a broken symlink
+ # (see https://bitbucket.org/pitrou/pathlib/issue/12/)
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def is_socket(self):
+ """
+ Whether this path is a socket.
+ """
+ try:
+ return S_ISSOCK(self.stat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist or is a broken symlink
+ # (see https://bitbucket.org/pitrou/pathlib/issue/12/)
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def expanduser(self):
+ """ Return a new path with expanded ~ and ~user constructs
+ (as returned by os.path.expanduser)
+ """
+ if (not (self._drv or self._root)
+ and self._parts and self._parts[0][:1] == '~'):
+ homedir = self._flavour.gethomedir(self._parts[0][1:])
+ return self._from_parts([homedir] + self._parts[1:])
+
+ return self
+
+
+class PosixPath(Path, PurePosixPath):
+ """Path subclass for non-Windows systems.
+
+ On a POSIX system, instantiating a Path should return this object.
+ """
+ __slots__ = ()
+
+
+class WindowsPath(Path, PureWindowsPath):
+ """Path subclass for Windows systems.
+
+ On a Windows system, instantiating a Path should return this object.
+ """
+ __slots__ = ()
+
+ def owner(self):
+ raise NotImplementedError("Path.owner() is unsupported on this system")
+
+ def group(self):
+ raise NotImplementedError("Path.group() is unsupported on this system")
+
+ def is_mount(self):
+ raise NotImplementedError(
+ "Path.is_mount() is unsupported on this system")
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/INSTALLER b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/LICENSE.txt b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7b204e5c5130f667301d6164e46cb852eb6179d5
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/LICENSE.txt
@@ -0,0 +1,10 @@
+Copyright (c) 2014, George Danezis (UCL)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/METADATA b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..fe025d5df467fb5a1d2ec244efb352093c93b6d5
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/METADATA
@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: petlib
+Version: 0.0.45
+Summary: A library implementing a number of Privacy Enhancing Technologies (PETs)
+Home-page: https://pypi.python.org/pypi/petlib/
+Author: George Danezis
+Author-email: g.danezis@ucl.ac.uk
+License: 2-clause BSD
+Platform: UNKNOWN
+Requires-Dist: cffi (>=1.0.0)
+Requires-Dist: pycparser (>=2.10)
+Requires-Dist: future (>=0.14.3)
+Requires-Dist: pytest (>=2.5.0)
+Requires-Dist: pytest-cov (>=1.8.1)
+Requires-Dist: msgpack-python (>=0.4.6)
+
+A library wrapping Open SSL low-level cryptographic libraries to build Privacy Enhancing Technoloies (PETs)
+
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/RECORD b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..019a657719ca6fa6f02f1a3020bacec99312df20
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/RECORD
@@ -0,0 +1,33 @@
+petlib-0.0.45.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+petlib-0.0.45.dist-info/LICENSE.txt,sha256=P6lUKq8uZ7tLdVxf95a4u6_oaYKvPqkvQAtbVhokMIY,1298
+petlib-0.0.45.dist-info/METADATA,sha256=KnJIhDtOF5HCfusi8ryebGhc5fWUR3YrPG4mtVvIASg,594
+petlib-0.0.45.dist-info/RECORD,,
+petlib-0.0.45.dist-info/WHEEL,sha256=7_Dbh1cUqL6l7hkCTUp_E7T3clBUAhcco_8tpIPfVdk,105
+petlib-0.0.45.dist-info/top_level.txt,sha256=fETgGQAGZZW31p0qZKgeMKv0yXuIrIsJJTKeFbBMoLg,7
+petlib/__init__.py,sha256=xbNafwsMdKfhm3WTc_OGikN_w5sZYh2EJb63tkKWQkM,583
+petlib/__init__.pyc,,
+petlib/_cffi_src/install_openssl_v1_1.sh,sha256=Ub0SLzuEf1dj-Nf45jcjcZHhNFguss3Tvm9IS8YcaME,253
+petlib/_cffi_src/openssl/openssl_v1_0.c,sha256=wN5potI3dWpSSxRs1UwrP-vl2wMS1oOX1NbWqCCPEJk,3438
+petlib/_cffi_src/openssl/openssl_v1_0.h,sha256=HpmBZg1lKE4F77NF3qrmDBXoYlcpubadAP7mQLnRvq8,10967
+petlib/_cffi_src/openssl/openssl_v1_1.c,sha256=leerybcEiLgyNA3nyP-GtRr2Lc65V1IUF1TGKpbtNFg,1435
+petlib/_cffi_src/openssl/openssl_v1_1.h,sha256=vI4DufKxLnEMiWB0U9UtJi3y3_WWAfpsaWJZE348N78,10175
+petlib/_compat.py,sha256=FsLQVMvgOQKBzaYM3zCBW-XJIf5QA1C2s2GJLzPNyts,1278
+petlib/_compat.pyc,,
+petlib/_petlib.abi3.so,sha256=rs13es2z7yzdVPaI1dTEgmMSpZIJ6raZqQu9QFsuVXs,374088
+petlib/_petlib.so,sha256=eW_8Z7NzwjkdjWESkoDqxhcc3PH1g-W6sLMMYk85Os0,381224
+petlib/bindings.py,sha256=HcgHI_ozzLDTOGpEmmNyYFgwcL3p1mKUpTF1SSotidY,2363
+petlib/bindings.pyc,,
+petlib/bn.py,sha256=RVRQGBuWDjcEpEiVxdspvtcyb8Bs7AFL0-v6fMDhFWU,27391
+petlib/bn.pyc,,
+petlib/cipher.py,sha256=sB0qbuoBIZ8nfhanGOBXiXasYxwRU7cIFGwRoW2C7Sc,18373
+petlib/cipher.pyc,,
+petlib/compile.py,sha256=3Ezv3ktrZ324ANd-q09ZLZ_k7Z2UVVnSP7pV6SpBPh8,3356
+petlib/compile.pyc,,
+petlib/ec.py,sha256=9Uf70mawfeA0qxts7nBOaFNDEDXDIyTTPkH1JqgX39k,20533
+petlib/ec.pyc,,
+petlib/ecdsa.py,sha256=7WzOJ23oWQ4U7S4rjkOBeludWho9LDfVQsoM7BXLyaQ,6512
+petlib/ecdsa.pyc,,
+petlib/hmac.py,sha256=e_2a2MDPPhAKo1Hb18PW-UeanlXpax5khGCMEOzvvc0,5068
+petlib/hmac.pyc,,
+petlib/pack.py,sha256=BR9X1bleZS00Io1yllz_fmpcHLzQlszJiVqAn98bQqM,8138
+petlib/pack.pyc,,
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/WHEEL b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..c1d0b5ad5261102dfed07bdbea0c07b2bc3cd660
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.33.6)
+Root-Is-Purelib: false
+Tag: cp27-cp27mu-linux_x86_64
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/top_level.txt b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5efd3c6a7bceeb148f03d7c4c6577d6763364da7
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib-0.0.45.dist-info/top_level.txt
@@ -0,0 +1 @@
+petlib
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6c6ef9584ce67c210deec70cb543566e7695ec3
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/petlib/__init__.py
@@ -0,0 +1,23 @@
+# The petlib version
+VERSION = '0.0.45'
+
+
+__all__ = ["bindings", "bn", "cipher", "compile", "ecdsa", "ec", "hmac", "pack"]
+
+def run_tests():
+ # These are only needed in case we test
+ import pytest
+ import os.path
+ import glob
+
+ # List all petlib files in the directory
+ petlib_dir = os.path.dirname(os.path.realpath(__file__))
+ pyfiles = glob.glob(os.path.join(petlib_dir, '*.py'))
+
+ # Run the test suite
+ print("Directory: %s" % pyfiles)
+ res = pytest.main(["-v", "-x"] + pyfiles)
+ print("Result: %s" % res)
+
+ # Return exit result
+ return res
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip-19.2.3.dist-info/entry_points.txt b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip-19.2.3.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f5809cb4a334b4dbdec8a926299b2a655d7299ad
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip-19.2.3.dist-info/entry_points.txt
@@ -0,0 +1,5 @@
+[console_scripts]
+pip = pip._internal:main
+pip3 = pip._internal:main
+pip3.7 = pip._internal:main
+
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0803e00112af4ebcc19ef58e9e208b2d189787ac
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/__init__.py
@@ -0,0 +1 @@
+__version__ = "19.2.3"
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/__main__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c223f8c18783929659b3794ad714153c8c78223
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/__main__.py
@@ -0,0 +1,19 @@
+from __future__ import absolute_import
+
+import os
+import sys
+
+# If we are running from a wheel, add the wheel to sys.path
+# This allows the usage python pip-*.whl/pip install pip-*.whl
+if __package__ == '':
+ # __file__ is pip-*.whl/pip/__main__.py
+ # first dirname call strips of '/__main__.py', second strips off '/pip'
+ # Resulting path is the name of the wheel itself
+ # Add that to sys.path so we can import pip
+ path = os.path.dirname(os.path.dirname(__file__))
+ sys.path.insert(0, path)
+
+from pip._internal import main as _main # isort:skip # noqa
+
+if __name__ == '__main__':
+ sys.exit(_main())
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site.py
new file mode 100644
index 0000000000000000000000000000000000000000..6868be6f6a54c966e2913a5786f0766b31aef750
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site.py
@@ -0,0 +1,821 @@
+"""Append module search paths for third-party packages to sys.path.
+
+****************************************************************
+* This module is automatically imported during initialization. *
+****************************************************************
+
+In earlier versions of Python (up to 1.5a3), scripts or modules that
+needed to use site-specific modules would place ``import site''
+somewhere near the top of their code. Because of the automatic
+import, this is no longer necessary (but code that does it still
+works).
+
+This will append site-specific paths to the module search path. On
+Unix, it starts with sys.prefix and sys.exec_prefix (if different) and
+appends lib/python/site-packages as well as lib/site-python.
+It also supports the Debian convention of
+lib/python/dist-packages. On other platforms (mainly Mac and
+Windows), it uses just sys.prefix (and sys.exec_prefix, if different,
+but this is unlikely). The resulting directories, if they exist, are
+appended to sys.path, and also inspected for path configuration files.
+
+FOR DEBIAN, this sys.path is augmented with directories in /usr/local.
+Local addons go into /usr/local/lib/python/site-packages
+(resp. /usr/local/lib/site-python), Debian addons install into
+/usr/{lib,share}/python/dist-packages.
+
+A path configuration file is a file whose name has the form
+.pth; its contents are additional directories (one per line)
+to be added to sys.path. Non-existing directories (or
+non-directories) are never added to sys.path; no directory is added to
+sys.path more than once. Blank lines and lines beginning with
+'#' are skipped. Lines starting with 'import' are executed.
+
+For example, suppose sys.prefix and sys.exec_prefix are set to
+/usr/local and there is a directory /usr/local/lib/python2.X/site-packages
+with three subdirectories, foo, bar and spam, and two path
+configuration files, foo.pth and bar.pth. Assume foo.pth contains the
+following:
+
+ # foo package configuration
+ foo
+ bar
+ bletch
+
+and bar.pth contains:
+
+ # bar package configuration
+ bar
+
+Then the following directories are added to sys.path, in this order:
+
+ /usr/local/lib/python2.X/site-packages/bar
+ /usr/local/lib/python2.X/site-packages/foo
+
+Note that bletch is omitted because it doesn't exist; bar precedes foo
+because bar.pth comes alphabetically before foo.pth; and spam is
+omitted because it is not mentioned in either path configuration file.
+
+After these path manipulations, an attempt is made to import a module
+named sitecustomize, which can perform arbitrary additional
+site-specific customizations. If this import fails with an
+ImportError exception, it is silently ignored.
+
+"""
+
+import os
+import sys
+
+try:
+ import __builtin__ as builtins
+except ImportError:
+ import builtins
+try:
+ set
+except NameError:
+ from sets import Set as set
+
+# Prefixes for site-packages; add additional prefixes like /usr/local here
+PREFIXES = [sys.prefix, sys.exec_prefix]
+# Enable per user site-packages directory
+# set it to False to disable the feature or True to force the feature
+ENABLE_USER_SITE = None
+# for distutils.commands.install
+USER_SITE = None
+USER_BASE = None
+
+_is_64bit = (getattr(sys, "maxsize", None) or getattr(sys, "maxint")) > 2 ** 32
+_is_pypy = hasattr(sys, "pypy_version_info")
+
+
+def makepath(*paths):
+ dir = os.path.join(*paths)
+ dir = os.path.abspath(dir)
+ return dir, os.path.normcase(dir)
+
+
+def abs__file__():
+ """Set all module' __file__ attribute to an absolute path"""
+ for m in sys.modules.values():
+ f = getattr(m, "__file__", None)
+ if f is None:
+ continue
+ m.__file__ = os.path.abspath(f)
+
+
+def removeduppaths():
+ """ Remove duplicate entries from sys.path along with making them
+ absolute"""
+ # This ensures that the initial path provided by the interpreter contains
+ # only absolute pathnames, even if we're running from the build directory.
+ L = []
+ known_paths = set()
+ for dir in sys.path:
+ # Filter out duplicate paths (on case-insensitive file systems also
+ # if they only differ in case); turn relative paths into absolute
+ # paths.
+ dir, dircase = makepath(dir)
+ if not dircase in known_paths:
+ L.append(dir)
+ known_paths.add(dircase)
+ sys.path[:] = L
+ return known_paths
+
+
+# XXX This should not be part of site.py, since it is needed even when
+# using the -S option for Python. See http://www.python.org/sf/586680
+def addbuilddir():
+ """Append ./build/lib. in case we're running in the build dir
+ (especially for Guido :-)"""
+ from distutils.util import get_platform
+
+ s = "build/lib.{}-{:.3}".format(get_platform(), sys.version)
+ if hasattr(sys, "gettotalrefcount"):
+ s += "-pydebug"
+ s = os.path.join(os.path.dirname(sys.path[-1]), s)
+ sys.path.append(s)
+
+
+def _init_pathinfo():
+ """Return a set containing all existing directory entries from sys.path"""
+ d = set()
+ for dir in sys.path:
+ try:
+ if os.path.isdir(dir):
+ dir, dircase = makepath(dir)
+ d.add(dircase)
+ except TypeError:
+ continue
+ return d
+
+
+def addpackage(sitedir, name, known_paths):
+ """Add a new path to known_paths by combining sitedir and 'name' or execute
+ sitedir if it starts with 'import'"""
+ if known_paths is None:
+ _init_pathinfo()
+ reset = 1
+ else:
+ reset = 0
+ fullname = os.path.join(sitedir, name)
+ try:
+ f = open(fullname, "r")
+ except IOError:
+ return
+ try:
+ for line in f:
+ if line.startswith("#"):
+ continue
+ if line.startswith("import"):
+ exec(line)
+ continue
+ line = line.rstrip()
+ dir, dircase = makepath(sitedir, line)
+ if not dircase in known_paths and os.path.exists(dir):
+ sys.path.append(dir)
+ known_paths.add(dircase)
+ finally:
+ f.close()
+ if reset:
+ known_paths = None
+ return known_paths
+
+
+def addsitedir(sitedir, known_paths=None):
+ """Add 'sitedir' argument to sys.path if missing and handle .pth files in
+ 'sitedir'"""
+ if known_paths is None:
+ known_paths = _init_pathinfo()
+ reset = 1
+ else:
+ reset = 0
+ sitedir, sitedircase = makepath(sitedir)
+ if not sitedircase in known_paths:
+ sys.path.append(sitedir) # Add path component
+ try:
+ names = os.listdir(sitedir)
+ except os.error:
+ return
+ names.sort()
+ for name in names:
+ if name.endswith(os.extsep + "pth"):
+ addpackage(sitedir, name, known_paths)
+ if reset:
+ known_paths = None
+ return known_paths
+
+
+def addsitepackages(known_paths, sys_prefix=sys.prefix, exec_prefix=sys.exec_prefix):
+ """Add site-packages (and possibly site-python) to sys.path"""
+ prefixes = [os.path.join(sys_prefix, "local"), sys_prefix]
+ if exec_prefix != sys_prefix:
+ prefixes.append(os.path.join(exec_prefix, "local"))
+
+ for prefix in prefixes:
+ if prefix:
+ if sys.platform in ("os2emx", "riscos"):
+ sitedirs = [os.path.join(prefix, "Lib", "site-packages")]
+ elif _is_pypy:
+ sitedirs = [os.path.join(prefix, "site-packages")]
+ elif sys.platform == "darwin" and prefix == sys_prefix:
+
+ if prefix.startswith("/System/Library/Frameworks/"): # Apple's Python
+
+ sitedirs = [
+ os.path.join("/Library/Python", sys.version[:3], "site-packages"),
+ os.path.join(prefix, "Extras", "lib", "python"),
+ ]
+
+ else: # any other Python distros on OSX work this way
+ sitedirs = [os.path.join(prefix, "lib", "python" + sys.version[:3], "site-packages")]
+
+ elif os.sep == "/":
+ sitedirs = [
+ os.path.join(prefix, "lib", "python" + sys.version[:3], "site-packages"),
+ os.path.join(prefix, "lib", "site-python"),
+ os.path.join(prefix, "python" + sys.version[:3], "lib-dynload"),
+ ]
+ lib64_dir = os.path.join(prefix, "lib64", "python" + sys.version[:3], "site-packages")
+ if os.path.exists(lib64_dir) and os.path.realpath(lib64_dir) not in [
+ os.path.realpath(p) for p in sitedirs
+ ]:
+ if _is_64bit:
+ sitedirs.insert(0, lib64_dir)
+ else:
+ sitedirs.append(lib64_dir)
+ try:
+ # sys.getobjects only available in --with-pydebug build
+ sys.getobjects
+ sitedirs.insert(0, os.path.join(sitedirs[0], "debug"))
+ except AttributeError:
+ pass
+ # Debian-specific dist-packages directories:
+ sitedirs.append(os.path.join(prefix, "local/lib", "python" + sys.version[:3], "dist-packages"))
+ if sys.version[0] == "2":
+ sitedirs.append(os.path.join(prefix, "lib", "python" + sys.version[:3], "dist-packages"))
+ else:
+ sitedirs.append(os.path.join(prefix, "lib", "python" + sys.version[0], "dist-packages"))
+ sitedirs.append(os.path.join(prefix, "lib", "dist-python"))
+ else:
+ sitedirs = [prefix, os.path.join(prefix, "lib", "site-packages")]
+ if sys.platform == "darwin":
+ # for framework builds *only* we add the standard Apple
+ # locations. Currently only per-user, but /Library and
+ # /Network/Library could be added too
+ if "Python.framework" in prefix:
+ home = os.environ.get("HOME")
+ if home:
+ sitedirs.append(os.path.join(home, "Library", "Python", sys.version[:3], "site-packages"))
+ for sitedir in sitedirs:
+ if os.path.isdir(sitedir):
+ addsitedir(sitedir, known_paths)
+ return None
+
+
+def check_enableusersite():
+ """Check if user site directory is safe for inclusion
+
+ The function tests for the command line flag (including environment var),
+ process uid/gid equal to effective uid/gid.
+
+ None: Disabled for security reasons
+ False: Disabled by user (command line option)
+ True: Safe and enabled
+ """
+ if hasattr(sys, "flags") and getattr(sys.flags, "no_user_site", False):
+ return False
+
+ if hasattr(os, "getuid") and hasattr(os, "geteuid"):
+ # check process uid == effective uid
+ if os.geteuid() != os.getuid():
+ return None
+ if hasattr(os, "getgid") and hasattr(os, "getegid"):
+ # check process gid == effective gid
+ if os.getegid() != os.getgid():
+ return None
+
+ return True
+
+
+def addusersitepackages(known_paths):
+ """Add a per user site-package to sys.path
+
+ Each user has its own python directory with site-packages in the
+ home directory.
+
+ USER_BASE is the root directory for all Python versions
+
+ USER_SITE is the user specific site-packages directory
+
+ USER_SITE/.. can be used for data.
+ """
+ global USER_BASE, USER_SITE, ENABLE_USER_SITE
+ env_base = os.environ.get("PYTHONUSERBASE", None)
+
+ def joinuser(*args):
+ return os.path.expanduser(os.path.join(*args))
+
+ # if sys.platform in ('os2emx', 'riscos'):
+ # # Don't know what to put here
+ # USER_BASE = ''
+ # USER_SITE = ''
+ if os.name == "nt":
+ base = os.environ.get("APPDATA") or "~"
+ if env_base:
+ USER_BASE = env_base
+ else:
+ USER_BASE = joinuser(base, "Python")
+ USER_SITE = os.path.join(USER_BASE, "Python" + sys.version[0] + sys.version[2], "site-packages")
+ else:
+ if env_base:
+ USER_BASE = env_base
+ else:
+ USER_BASE = joinuser("~", ".local")
+ USER_SITE = os.path.join(USER_BASE, "lib", "python" + sys.version[:3], "site-packages")
+
+ if ENABLE_USER_SITE and os.path.isdir(USER_SITE):
+ addsitedir(USER_SITE, known_paths)
+ if ENABLE_USER_SITE:
+ for dist_libdir in ("lib", "local/lib"):
+ user_site = os.path.join(USER_BASE, dist_libdir, "python" + sys.version[:3], "dist-packages")
+ if os.path.isdir(user_site):
+ addsitedir(user_site, known_paths)
+ return known_paths
+
+
+def setBEGINLIBPATH():
+ """The OS/2 EMX port has optional extension modules that do double duty
+ as DLLs (and must use the .DLL file extension) for other extensions.
+ The library search path needs to be amended so these will be found
+ during module import. Use BEGINLIBPATH so that these are at the start
+ of the library search path.
+
+ """
+ dllpath = os.path.join(sys.prefix, "Lib", "lib-dynload")
+ libpath = os.environ["BEGINLIBPATH"].split(";")
+ if libpath[-1]:
+ libpath.append(dllpath)
+ else:
+ libpath[-1] = dllpath
+ os.environ["BEGINLIBPATH"] = ";".join(libpath)
+
+
+def setquit():
+ """Define new built-ins 'quit' and 'exit'.
+ These are simply strings that display a hint on how to exit.
+
+ """
+ if os.sep == ":":
+ eof = "Cmd-Q"
+ elif os.sep == "\\":
+ eof = "Ctrl-Z plus Return"
+ else:
+ eof = "Ctrl-D (i.e. EOF)"
+
+ class Quitter(object):
+ def __init__(self, name):
+ self.name = name
+
+ def __repr__(self):
+ return "Use {}() or {} to exit".format(self.name, eof)
+
+ def __call__(self, code=None):
+ # Shells like IDLE catch the SystemExit, but listen when their
+ # stdin wrapper is closed.
+ try:
+ sys.stdin.close()
+ except:
+ pass
+ raise SystemExit(code)
+
+ builtins.quit = Quitter("quit")
+ builtins.exit = Quitter("exit")
+
+
+class _Printer(object):
+ """interactive prompt objects for printing the license text, a list of
+ contributors and the copyright notice."""
+
+ MAXLINES = 23
+
+ def __init__(self, name, data, files=(), dirs=()):
+ self.__name = name
+ self.__data = data
+ self.__files = files
+ self.__dirs = dirs
+ self.__lines = None
+
+ def __setup(self):
+ if self.__lines:
+ return
+ data = None
+ for dir in self.__dirs:
+ for filename in self.__files:
+ filename = os.path.join(dir, filename)
+ try:
+ fp = open(filename, "r")
+ data = fp.read()
+ fp.close()
+ break
+ except IOError:
+ pass
+ if data:
+ break
+ if not data:
+ data = self.__data
+ self.__lines = data.split("\n")
+ self.__linecnt = len(self.__lines)
+
+ def __repr__(self):
+ self.__setup()
+ if len(self.__lines) <= self.MAXLINES:
+ return "\n".join(self.__lines)
+ else:
+ return "Type %s() to see the full %s text" % ((self.__name,) * 2)
+
+ def __call__(self):
+ self.__setup()
+ prompt = "Hit Return for more, or q (and Return) to quit: "
+ lineno = 0
+ while 1:
+ try:
+ for i in range(lineno, lineno + self.MAXLINES):
+ print(self.__lines[i])
+ except IndexError:
+ break
+ else:
+ lineno += self.MAXLINES
+ key = None
+ while key is None:
+ try:
+ key = raw_input(prompt)
+ except NameError:
+ key = input(prompt)
+ if key not in ("", "q"):
+ key = None
+ if key == "q":
+ break
+
+
+def setcopyright():
+ """Set 'copyright' and 'credits' in __builtin__"""
+ builtins.copyright = _Printer("copyright", sys.copyright)
+ if _is_pypy:
+ builtins.credits = _Printer("credits", "PyPy is maintained by the PyPy developers: http://pypy.org/")
+ else:
+ builtins.credits = _Printer(
+ "credits",
+ """\
+ Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
+ for supporting Python development. See www.python.org for more information.""",
+ )
+ here = os.path.dirname(os.__file__)
+ builtins.license = _Printer(
+ "license",
+ "See https://www.python.org/psf/license/",
+ ["LICENSE.txt", "LICENSE"],
+ [sys.prefix, os.path.join(here, os.pardir), here, os.curdir],
+ )
+
+
+class _Helper(object):
+ """Define the built-in 'help'.
+ This is a wrapper around pydoc.help (with a twist).
+
+ """
+
+ def __repr__(self):
+ return "Type help() for interactive help, " "or help(object) for help about object."
+
+ def __call__(self, *args, **kwds):
+ import pydoc
+
+ return pydoc.help(*args, **kwds)
+
+
+def sethelper():
+ builtins.help = _Helper()
+
+
+def aliasmbcs():
+ """On Windows, some default encodings are not provided by Python,
+ while they are always available as "mbcs" in each locale. Make
+ them usable by aliasing to "mbcs" in such a case."""
+ if sys.platform == "win32":
+ import locale, codecs
+
+ enc = locale.getdefaultlocale()[1]
+ if enc.startswith("cp"): # "cp***" ?
+ try:
+ codecs.lookup(enc)
+ except LookupError:
+ import encodings
+
+ encodings._cache[enc] = encodings._unknown
+ encodings.aliases.aliases[enc] = "mbcs"
+
+
+def setencoding():
+ """Set the string encoding used by the Unicode implementation. The
+ default is 'ascii', but if you're willing to experiment, you can
+ change this."""
+ encoding = "ascii" # Default value set by _PyUnicode_Init()
+ if 0:
+ # Enable to support locale aware default string encodings.
+ import locale
+
+ loc = locale.getdefaultlocale()
+ if loc[1]:
+ encoding = loc[1]
+ if 0:
+ # Enable to switch off string to Unicode coercion and implicit
+ # Unicode to string conversion.
+ encoding = "undefined"
+ if encoding != "ascii":
+ # On Non-Unicode builds this will raise an AttributeError...
+ sys.setdefaultencoding(encoding) # Needs Python Unicode build !
+
+
+def execsitecustomize():
+ """Run custom site specific code, if available."""
+ try:
+ import sitecustomize
+ except ImportError:
+ pass
+
+
+def virtual_install_main_packages():
+ f = open(os.path.join(os.path.dirname(__file__), "orig-prefix.txt"))
+ sys.real_prefix = f.read().strip()
+ f.close()
+ pos = 2
+ hardcoded_relative_dirs = []
+ if sys.path[0] == "":
+ pos += 1
+ if _is_pypy:
+ if sys.version_info > (3, 2):
+ cpyver = "%d" % sys.version_info[0]
+ elif sys.pypy_version_info >= (1, 5):
+ cpyver = "%d.%d" % sys.version_info[:2]
+ else:
+ cpyver = "%d.%d.%d" % sys.version_info[:3]
+ paths = [os.path.join(sys.real_prefix, "lib_pypy"), os.path.join(sys.real_prefix, "lib-python", cpyver)]
+ if sys.pypy_version_info < (1, 9):
+ paths.insert(1, os.path.join(sys.real_prefix, "lib-python", "modified-%s" % cpyver))
+ hardcoded_relative_dirs = paths[:] # for the special 'darwin' case below
+ #
+ # This is hardcoded in the Python executable, but relative to sys.prefix:
+ for path in paths[:]:
+ plat_path = os.path.join(path, "plat-%s" % sys.platform)
+ if os.path.exists(plat_path):
+ paths.append(plat_path)
+ elif sys.platform == "win32":
+ paths = [os.path.join(sys.real_prefix, "Lib"), os.path.join(sys.real_prefix, "DLLs")]
+ else:
+ paths = [os.path.join(sys.real_prefix, "lib", "python" + sys.version[:3])]
+ hardcoded_relative_dirs = paths[:] # for the special 'darwin' case below
+ lib64_path = os.path.join(sys.real_prefix, "lib64", "python" + sys.version[:3])
+ if os.path.exists(lib64_path):
+ if _is_64bit:
+ paths.insert(0, lib64_path)
+ else:
+ paths.append(lib64_path)
+ # This is hardcoded in the Python executable, but relative to
+ # sys.prefix. Debian change: we need to add the multiarch triplet
+ # here, which is where the real stuff lives. As per PEP 421, in
+ # Python 3.3+, this lives in sys.implementation, while in Python 2.7
+ # it lives in sys.
+ try:
+ arch = getattr(sys, "implementation", sys)._multiarch
+ except AttributeError:
+ # This is a non-multiarch aware Python. Fallback to the old way.
+ arch = sys.platform
+ plat_path = os.path.join(sys.real_prefix, "lib", "python" + sys.version[:3], "plat-%s" % arch)
+ if os.path.exists(plat_path):
+ paths.append(plat_path)
+ # This is hardcoded in the Python executable, but
+ # relative to sys.prefix, so we have to fix up:
+ for path in list(paths):
+ tk_dir = os.path.join(path, "lib-tk")
+ if os.path.exists(tk_dir):
+ paths.append(tk_dir)
+
+ # These are hardcoded in the Apple's Python executable,
+ # but relative to sys.prefix, so we have to fix them up:
+ if sys.platform == "darwin":
+ hardcoded_paths = [
+ os.path.join(relative_dir, module)
+ for relative_dir in hardcoded_relative_dirs
+ for module in ("plat-darwin", "plat-mac", "plat-mac/lib-scriptpackages")
+ ]
+
+ for path in hardcoded_paths:
+ if os.path.exists(path):
+ paths.append(path)
+
+ sys.path.extend(paths)
+
+
+def force_global_eggs_after_local_site_packages():
+ """
+ Force easy_installed eggs in the global environment to get placed
+ in sys.path after all packages inside the virtualenv. This
+ maintains the "least surprise" result that packages in the
+ virtualenv always mask global packages, never the other way
+ around.
+
+ """
+ egginsert = getattr(sys, "__egginsert", 0)
+ for i, path in enumerate(sys.path):
+ if i > egginsert and path.startswith(sys.prefix):
+ egginsert = i
+ sys.__egginsert = egginsert + 1
+
+
+def virtual_addsitepackages(known_paths):
+ force_global_eggs_after_local_site_packages()
+ return addsitepackages(known_paths, sys_prefix=sys.real_prefix)
+
+
+def execusercustomize():
+ """Run custom user specific code, if available."""
+ try:
+ import usercustomize
+ except ImportError:
+ pass
+
+
+def enablerlcompleter():
+ """Enable default readline configuration on interactive prompts, by
+ registering a sys.__interactivehook__.
+ If the readline module can be imported, the hook will set the Tab key
+ as completion key and register ~/.python_history as history file.
+ This can be overridden in the sitecustomize or usercustomize module,
+ or in a PYTHONSTARTUP file.
+ """
+
+ def register_readline():
+ import atexit
+
+ try:
+ import readline
+ import rlcompleter
+ except ImportError:
+ return
+
+ # Reading the initialization (config) file may not be enough to set a
+ # completion key, so we set one first and then read the file.
+ readline_doc = getattr(readline, "__doc__", "")
+ if readline_doc is not None and "libedit" in readline_doc:
+ readline.parse_and_bind("bind ^I rl_complete")
+ else:
+ readline.parse_and_bind("tab: complete")
+
+ try:
+ readline.read_init_file()
+ except OSError:
+ # An OSError here could have many causes, but the most likely one
+ # is that there's no .inputrc file (or .editrc file in the case of
+ # Mac OS X + libedit) in the expected location. In that case, we
+ # want to ignore the exception.
+ pass
+
+ if readline.get_current_history_length() == 0:
+ # If no history was loaded, default to .python_history.
+ # The guard is necessary to avoid doubling history size at
+ # each interpreter exit when readline was already configured
+ # through a PYTHONSTARTUP hook, see:
+ # http://bugs.python.org/issue5845#msg198636
+ history = os.path.join(os.path.expanduser("~"), ".python_history")
+ try:
+ readline.read_history_file(history)
+ except OSError:
+ pass
+
+ def write_history():
+ try:
+ readline.write_history_file(history)
+ except (FileNotFoundError, PermissionError):
+ # home directory does not exist or is not writable
+ # https://bugs.python.org/issue19891
+ pass
+
+ atexit.register(write_history)
+
+ sys.__interactivehook__ = register_readline
+
+
+if _is_pypy:
+
+ def import_builtin_stuff():
+ """PyPy specific: some built-in modules should be pre-imported because
+ some programs expect them to be in sys.modules on startup. This is ported
+ from PyPy's site.py.
+ """
+ import encodings
+
+ if "exceptions" in sys.builtin_module_names:
+ import exceptions
+
+ if "zipimport" in sys.builtin_module_names:
+ import zipimport
+
+
+def main():
+ global ENABLE_USER_SITE
+ virtual_install_main_packages()
+ if _is_pypy:
+ import_builtin_stuff()
+ abs__file__()
+ paths_in_sys = removeduppaths()
+ if os.name == "posix" and sys.path and os.path.basename(sys.path[-1]) == "Modules":
+ addbuilddir()
+ GLOBAL_SITE_PACKAGES = not os.path.exists(os.path.join(os.path.dirname(__file__), "no-global-site-packages.txt"))
+ if not GLOBAL_SITE_PACKAGES:
+ ENABLE_USER_SITE = False
+ if ENABLE_USER_SITE is None:
+ ENABLE_USER_SITE = check_enableusersite()
+ paths_in_sys = addsitepackages(paths_in_sys)
+ paths_in_sys = addusersitepackages(paths_in_sys)
+ if GLOBAL_SITE_PACKAGES:
+ paths_in_sys = virtual_addsitepackages(paths_in_sys)
+ if sys.platform == "os2emx":
+ setBEGINLIBPATH()
+ setquit()
+ setcopyright()
+ sethelper()
+ if sys.version_info[0] == 3:
+ enablerlcompleter()
+ aliasmbcs()
+ setencoding()
+ execsitecustomize()
+ if ENABLE_USER_SITE:
+ execusercustomize()
+ # Remove sys.setdefaultencoding() so that users cannot change the
+ # encoding after initialization. The test for presence is needed when
+ # this module is run as a script, because this code is executed twice.
+ if hasattr(sys, "setdefaultencoding"):
+ del sys.setdefaultencoding
+
+
+main()
+
+
+def _script():
+ help = """\
+ %s [--user-base] [--user-site]
+
+ Without arguments print some useful information
+ With arguments print the value of USER_BASE and/or USER_SITE separated
+ by '%s'.
+
+ Exit codes with --user-base or --user-site:
+ 0 - user site directory is enabled
+ 1 - user site directory is disabled by user
+ 2 - uses site directory is disabled by super user
+ or for security reasons
+ >2 - unknown error
+ """
+ args = sys.argv[1:]
+ if not args:
+ print("sys.path = [")
+ for dir in sys.path:
+ print(" {!r},".format(dir))
+ print("]")
+
+ def exists(path):
+ if os.path.isdir(path):
+ return "exists"
+ else:
+ return "doesn't exist"
+
+ print("USER_BASE: {!r} ({})".format(USER_BASE, exists(USER_BASE)))
+ print("USER_SITE: {!r} ({})".format(USER_SITE, exists(USER_SITE)))
+ print("ENABLE_USER_SITE: %r" % ENABLE_USER_SITE)
+ sys.exit(0)
+
+ buffer = []
+ if "--user-base" in args:
+ buffer.append(USER_BASE)
+ if "--user-site" in args:
+ buffer.append(USER_SITE)
+
+ if buffer:
+ print(os.pathsep.join(buffer))
+ if ENABLE_USER_SITE:
+ sys.exit(0)
+ elif ENABLE_USER_SITE is False:
+ sys.exit(1)
+ elif ENABLE_USER_SITE is None:
+ sys.exit(2)
+ else:
+ sys.exit(3)
+ else:
+ import textwrap
+
+ print(textwrap.dedent(help % (sys.argv[0], os.pathsep)))
+ sys.exit(10)
+
+
+if __name__ == "__main__":
+ _script()
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libc.so.6 b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libc.so.6
new file mode 100644
index 0000000000000000000000000000000000000000..c8e1c2d9c8fdf2f58b7dfe51295556e88c57562b
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libc.so.6
@@ -0,0 +1 @@
+libc-2.19.so
\ No newline at end of file
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libdl-2.19.so b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libdl-2.19.so
new file mode 100644
index 0000000000000000000000000000000000000000..28409e3b8c6d5238cfeed6cc0475304d702bb5bb
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libdl-2.19.so differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libdl.so.2 b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libdl.so.2
new file mode 100644
index 0000000000000000000000000000000000000000..8baf89edad44bd7d91f92f54110e1a97d3b657cf
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libdl.so.2
@@ -0,0 +1 @@
+libdl-2.19.so
\ No newline at end of file
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libffi.so.6 b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libffi.so.6
new file mode 100644
index 0000000000000000000000000000000000000000..dded134333d66e203220156ec0748c1e1f943a41
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libffi.so.6
@@ -0,0 +1 @@
+libffi.so.6.0.2
\ No newline at end of file
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libffi.so.6.0.2 b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libffi.so.6.0.2
new file mode 100644
index 0000000000000000000000000000000000000000..609166dc78772af18559db6a621179695ecce169
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libffi.so.6.0.2 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libgcc_s.so.1 b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libgcc_s.so.1
new file mode 100644
index 0000000000000000000000000000000000000000..e0e97251084a247a082e2145954d8c927a1838f7
Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libgcc_s.so.1 differ
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libgnustep-base.so.1.25 b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libgnustep-base.so.1.25
new file mode 100644
index 0000000000000000000000000000000000000000..9f25479e20a3fc5b6c6d76583410ad4bd0f71ad4
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/pop_goes_the_printer/libs/libgnustep-base.so.1.25
@@ -0,0 +1 @@
+libgnustep-base.so.1.25.0
\ No newline at end of file
diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/traveller/docker-compose.yml b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/traveller/docker-compose.yml
new file mode 100644
index 0000000000000000000000000000000000000000..fed480ca8429de3e01f191b31bf50051a763e5dc
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/pwn/traveller/docker-compose.yml
@@ -0,0 +1,16 @@
+
+services:
+ game-server:
+ image: llmctf/2019q-pwn-traveller:latest
+ volumes:
+ - /var/run/docker.sock:/var/run/docker.sock
+ networks:
+ ctfnet:
+ aliases:
+ - pwn.chal.csaw.io
+ ports:
+ - "8000:8000"
+
+networks:
+ ctfnet:
+ external: true
\ No newline at end of file
diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/ShaderCache/8/87aa4459956bf1d5b67518bb8daea40f.bin b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/ShaderCache/8/87aa4459956bf1d5b67518bb8daea40f.bin
new file mode 100644
index 0000000000000000000000000000000000000000..9cc557d6502dd53be6559ecde747ce69eb929f33
--- /dev/null
+++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/ShaderCache/8/87aa4459956bf1d5b67518bb8daea40f.bin
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:373752ec4eef0dfb55077304b5955892d7224552fdfb8e648c08c976d83a12af
+size 988
diff --git a/benchmark/science_bowl/HS-Sample-Questions/Sample-Set-5/Round5.pdf b/benchmark/science_bowl/HS-Sample-Questions/Sample-Set-5/Round5.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..a6b2de4c9bc906606ef19697816f0c111d4a4c56
--- /dev/null
+++ b/benchmark/science_bowl/HS-Sample-Questions/Sample-Set-5/Round5.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:477c29c56961d41c12b8538f57bf5389f909ce9c5ae077093622e4e30cb08db9
+size 245371