signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _name_value(self, s):
|
parts = s.split(b'<STR_LIT:U+0020>', <NUM_LIT:2>)<EOL>name = parts[<NUM_LIT:0>]<EOL>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>value = None<EOL><DEDENT>else:<EOL><INDENT>size = int(parts[<NUM_LIT:1>])<EOL>value = parts[<NUM_LIT:2>]<EOL>still_to_read = size - len(value)<EOL>if still_to_read > <NUM_LIT:0>:<EOL><INDENT>read_bytes = self.read_bytes(still_to_read)<EOL>value += b'<STR_LIT:\n>' + read_bytes[:still_to_read - <NUM_LIT:1>]<EOL><DEDENT><DEDENT>return (name, value)<EOL>
|
Parse a (name,value) tuple from 'name value-length value'.
|
f11391:c1:m17
|
def _path(self, s):
|
if s.startswith(b'<STR_LIT:">'):<EOL><INDENT>if not s.endswith(b'<STR_LIT:">'):<EOL><INDENT>self.abort(errors.BadFormat, '<STR_LIT:?>', '<STR_LIT:?>', s)<EOL><DEDENT>else:<EOL><INDENT>return _unquote_c_string(s[<NUM_LIT:1>:-<NUM_LIT:1>])<EOL><DEDENT><DEDENT>return s<EOL>
|
Parse a path.
|
f11391:c1:m18
|
def _path_pair(self, s):
|
<EOL>if s.startswith(b'<STR_LIT:">'):<EOL><INDENT>parts = s[<NUM_LIT:1>:].split(b'<STR_LIT>', <NUM_LIT:1>)<EOL><DEDENT>else:<EOL><INDENT>parts = s.split(b'<STR_LIT:U+0020>', <NUM_LIT:1>)<EOL><DEDENT>if len(parts) != <NUM_LIT:2>:<EOL><INDENT>self.abort(errors.BadFormat, '<STR_LIT:?>', '<STR_LIT:?>', s)<EOL><DEDENT>elif parts[<NUM_LIT:1>].startswith(b'<STR_LIT:">') and parts[<NUM_LIT:1>].endswith(b'<STR_LIT:">'):<EOL><INDENT>parts[<NUM_LIT:1>] = parts[<NUM_LIT:1>][<NUM_LIT:1>:-<NUM_LIT:1>]<EOL><DEDENT>elif parts[<NUM_LIT:1>].startswith(b'<STR_LIT:">') or parts[<NUM_LIT:1>].endswith(b'<STR_LIT:">'):<EOL><INDENT>self.abort(errors.BadFormat, '<STR_LIT:?>', '<STR_LIT:?>', s)<EOL><DEDENT>return [_unquote_c_string(s) for s in parts]<EOL>
|
Parse two paths separated by a space.
|
f11391:c1:m19
|
def _mode(self, s):
|
<EOL>if s in [b'<STR_LIT>', b'<STR_LIT>', b'<STR_LIT>']:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>elif s in [b'<STR_LIT>', b'<STR_LIT>', b'<STR_LIT>']:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>elif s in [b'<STR_LIT>', b'<STR_LIT>']:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>elif s in [b'<STR_LIT>', b'<STR_LIT>']:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>elif s in [b'<STR_LIT>', b'<STR_LIT>']:<EOL><INDENT>return <NUM_LIT><EOL><DEDENT>else:<EOL><INDENT>self.abort(errors.BadFormat, '<STR_LIT>', '<STR_LIT>', s)<EOL><DEDENT>
|
Check file mode format and parse into an int.
:return: mode as integer
|
f11391:c1:m20
|
def parse_raw(s, lineno=<NUM_LIT:0>):
|
timestamp_str, timezone_str = s.split(b'<STR_LIT:U+0020>', <NUM_LIT:1>)<EOL>timestamp = float(timestamp_str)<EOL>try:<EOL><INDENT>timezone = parse_tz(timezone_str)<EOL><DEDENT>except ValueError:<EOL><INDENT>raise errors.InvalidTimezone(lineno, timezone_str)<EOL><DEDENT>return timestamp, timezone<EOL>
|
Parse a date from a raw string.
The format must be exactly "seconds-since-epoch offset-utc".
See the spec for details.
|
f11400:m0
|
def parse_tz(tz):
|
<EOL>sign_byte = tz[<NUM_LIT:0>:<NUM_LIT:1>]<EOL>if sign_byte not in (b'<STR_LIT:+>', b'<STR_LIT:->'):<EOL><INDENT>raise ValueError(tz)<EOL><DEDENT>sign = {b'<STR_LIT:+>': +<NUM_LIT:1>, b'<STR_LIT:->': -<NUM_LIT:1>}[sign_byte]<EOL>hours = int(tz[<NUM_LIT:1>:-<NUM_LIT:2>])<EOL>minutes = int(tz[-<NUM_LIT:2>:])<EOL>return sign * <NUM_LIT> * (<NUM_LIT> * hours + minutes)<EOL>
|
Parse a timezone specification in the [+|-]HHMM format.
:return: the timezone offset in seconds.
|
f11400:m1
|
def parse_rfc2822(s, lineno=<NUM_LIT:0>):
|
raise NotImplementedError(parse_rfc2822)<EOL>
|
Parse a date from a rfc2822 string.
See the spec for details.
|
f11400:m2
|
def parse_now(s, lineno=<NUM_LIT:0>):
|
return time.time(), <NUM_LIT:0><EOL>
|
Parse a date from a string.
The format must be exactly "now".
See the spec for details.
|
f11400:m3
|
def track_heads(self, cmd):
|
<EOL>if cmd.from_ is not None:<EOL><INDENT>parents = [cmd.from_]<EOL><DEDENT>else:<EOL><INDENT>last_id = self.last_ids.get(cmd.ref)<EOL>if last_id is not None:<EOL><INDENT>parents = [last_id]<EOL><DEDENT>else:<EOL><INDENT>parents = []<EOL><DEDENT><DEDENT>parents.extend(cmd.merges)<EOL>self.track_heads_for_ref(cmd.ref, cmd.id, parents)<EOL>return parents<EOL>
|
Track the repository heads given a CommitCommand.
:param cmd: the CommitCommand
:return: the list of parents in terms of commit-ids
|
f11401:c0:m3
|
def pre_handler(self, cmd):
|
if self._finished:<EOL><INDENT>return<EOL><DEDENT>if self.interesting_commit and cmd.name == '<STR_LIT>':<EOL><INDENT>if cmd.mark == self.interesting_commit:<EOL><INDENT>print(cmd.to_string())<EOL>self._finished = True<EOL><DEDENT>return<EOL><DEDENT>if cmd.name in self.parsed_params:<EOL><INDENT>fields = self.parsed_params[cmd.name]<EOL>str = cmd.dump_str(fields, self.parsed_params, self.verbose)<EOL>print("<STR_LIT:%s>" % (str,))<EOL><DEDENT>
|
Hook for logic before each handler starts.
|
f11402:c0:m1
|
def progress_handler(self, cmd):
|
pass<EOL>
|
Process a ProgressCommand.
|
f11402:c0:m2
|
def blob_handler(self, cmd):
|
pass<EOL>
|
Process a BlobCommand.
|
f11402:c0:m3
|
def checkpoint_handler(self, cmd):
|
pass<EOL>
|
Process a CheckpointCommand.
|
f11402:c0:m4
|
def commit_handler(self, cmd):
|
pass<EOL>
|
Process a CommitCommand.
|
f11402:c0:m5
|
def reset_handler(self, cmd):
|
pass<EOL>
|
Process a ResetCommand.
|
f11402:c0:m6
|
def tag_handler(self, cmd):
|
pass<EOL>
|
Process a TagCommand.
|
f11402:c0:m7
|
def feature_handler(self, cmd):
|
feature = cmd.feature_name<EOL>if feature not in commands.FEATURE_NAMES:<EOL><INDENT>self.warning("<STR_LIT>"<EOL>% (feature,))<EOL><DEDENT>
|
Process a FeatureCommand.
|
f11402:c0:m8
|
def progress_handler(self, cmd):
|
<EOL>self.keep = True<EOL>
|
Process a ProgressCommand.
|
f11403:c0:m3
|
def blob_handler(self, cmd):
|
<EOL>self.blobs[cmd.id] = cmd<EOL>self.keep = False<EOL>
|
Process a BlobCommand.
|
f11403:c0:m4
|
def checkpoint_handler(self, cmd):
|
<EOL>self.keep = True<EOL>
|
Process a CheckpointCommand.
|
f11403:c0:m5
|
def commit_handler(self, cmd):
|
<EOL>interesting_filecmds = self._filter_filecommands(cmd.iter_files)<EOL>if interesting_filecmds or not self.squash_empty_commits:<EOL><INDENT>if len(interesting_filecmds) == <NUM_LIT:1> and isinstance(<EOL>interesting_filecmds[<NUM_LIT:0>], commands.FileDeleteAllCommand):<EOL><INDENT>pass<EOL><DEDENT>else:<EOL><INDENT>self.keep = True<EOL>cmd.file_iter = iter(interesting_filecmds)<EOL>for fc in interesting_filecmds:<EOL><INDENT>if isinstance(fc, commands.FileModifyCommand):<EOL><INDENT>if (fc.dataref is not None and<EOL>not stat.S_ISDIR(fc.mode)):<EOL><INDENT>self.referenced_blobs.append(fc.dataref)<EOL><DEDENT><DEDENT><DEDENT>cmd.from_ = self._find_interesting_from(cmd.from_)<EOL>cmd.merges = self._find_interesting_merges(cmd.merges)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.squashed_commits.add(cmd.id)<EOL><DEDENT>if cmd.from_ and cmd.merges:<EOL><INDENT>parents = [cmd.from_] + cmd.merges<EOL><DEDENT>elif cmd.from_:<EOL><INDENT>parents = [cmd.from_]<EOL><DEDENT>else:<EOL><INDENT>parents = None<EOL><DEDENT>if cmd.mark is not None:<EOL><INDENT>self.parents[b'<STR_LIT::>' + cmd.mark] = parents<EOL><DEDENT>
|
Process a CommitCommand.
|
f11403:c0:m6
|
def reset_handler(self, cmd):
|
if cmd.from_ is None:<EOL><INDENT>self.keep = True<EOL><DEDENT>else:<EOL><INDENT>cmd.from_ = self._find_interesting_from(cmd.from_)<EOL>self.keep = cmd.from_ is not None<EOL><DEDENT>
|
Process a ResetCommand.
|
f11403:c0:m7
|
def tag_handler(self, cmd):
|
<EOL>cmd.from_ = self._find_interesting_from(cmd.from_)<EOL>self.keep = cmd.from_ is not None<EOL>
|
Process a TagCommand.
|
f11403:c0:m8
|
def feature_handler(self, cmd):
|
feature = cmd.feature_name<EOL>if feature not in commands.FEATURE_NAMES:<EOL><INDENT>self.warning("<STR_LIT>"<EOL>% (feature,))<EOL><DEDENT>self.keep = True<EOL>
|
Process a FeatureCommand.
|
f11403:c0:m9
|
def _print_command(self, cmd):
|
text = helpers.repr_bytes(cmd)<EOL>self.outf.write(text)<EOL>if not text.endswith(b'<STR_LIT:\n>'):<EOL><INDENT>self.outf.write(b'<STR_LIT:\n>')<EOL><DEDENT>
|
Wrapper to avoid adding unnecessary blank lines.
|
f11403:c0:m10
|
def _filter_filecommands(self, filecmd_iter):
|
if self.includes is None and self.excludes is None:<EOL><INDENT>return list(filecmd_iter())<EOL><DEDENT>result = []<EOL>for fc in filecmd_iter():<EOL><INDENT>if (isinstance(fc, commands.FileModifyCommand) or<EOL>isinstance(fc, commands.FileDeleteCommand)):<EOL><INDENT>if self._path_to_be_kept(fc.path):<EOL><INDENT>fc.path = self._adjust_for_new_root(fc.path)<EOL><DEDENT>else:<EOL><INDENT>continue<EOL><DEDENT><DEDENT>elif isinstance(fc, commands.FileDeleteAllCommand):<EOL><INDENT>pass<EOL><DEDENT>elif isinstance(fc, commands.FileRenameCommand):<EOL><INDENT>fc = self._convert_rename(fc)<EOL><DEDENT>elif isinstance(fc, commands.FileCopyCommand):<EOL><INDENT>fc = self._convert_copy(fc)<EOL><DEDENT>else:<EOL><INDENT>self.warning("<STR_LIT>",<EOL>fc.__class__)<EOL>continue<EOL><DEDENT>if fc is not None:<EOL><INDENT>result.append(fc)<EOL><DEDENT><DEDENT>return result<EOL>
|
Return the filecommands filtered by includes & excludes.
:return: a list of FileCommand objects
|
f11403:c0:m11
|
def _path_to_be_kept(self, path):
|
if self.excludes and (path in self.excludes<EOL>or helpers.is_inside_any(self.excludes, path)):<EOL><INDENT>return False<EOL><DEDENT>if self.includes:<EOL><INDENT>return (path in self.includes<EOL>or helpers.is_inside_any(self.includes, path))<EOL><DEDENT>return True<EOL>
|
Does the given path pass the filtering criteria?
|
f11403:c0:m12
|
def _adjust_for_new_root(self, path):
|
if self.new_root is None:<EOL><INDENT>return path<EOL><DEDENT>elif path.startswith(self.new_root):<EOL><INDENT>return path[len(self.new_root):]<EOL><DEDENT>else:<EOL><INDENT>return path<EOL><DEDENT>
|
Adjust a path given the new root directory of the output.
|
f11403:c0:m13
|
def _convert_rename(self, fc):
|
old = fc.old_path<EOL>new = fc.new_path<EOL>keep_old = self._path_to_be_kept(old)<EOL>keep_new = self._path_to_be_kept(new)<EOL>if keep_old and keep_new:<EOL><INDENT>fc.old_path = self._adjust_for_new_root(old)<EOL>fc.new_path = self._adjust_for_new_root(new)<EOL>return fc<EOL><DEDENT>elif keep_old:<EOL><INDENT>old = self._adjust_for_new_root(old)<EOL>return commands.FileDeleteCommand(old)<EOL><DEDENT>elif keep_new:<EOL><INDENT>self.warning("<STR_LIT>" %<EOL>(old, new))<EOL><DEDENT>return None<EOL>
|
Convert a FileRenameCommand into a new FileCommand.
:return: None if the rename is being ignored, otherwise a
new FileCommand based on the whether the old and new paths
are inside or outside of the interesting locations.
|
f11403:c0:m17
|
def _convert_copy(self, fc):
|
src = fc.src_path<EOL>dest = fc.dest_path<EOL>keep_src = self._path_to_be_kept(src)<EOL>keep_dest = self._path_to_be_kept(dest)<EOL>if keep_src and keep_dest:<EOL><INDENT>fc.src_path = self._adjust_for_new_root(src)<EOL>fc.dest_path = self._adjust_for_new_root(dest)<EOL>return fc<EOL><DEDENT>elif keep_src:<EOL><INDENT>return None<EOL><DEDENT>elif keep_dest:<EOL><INDENT>self.warning("<STR_LIT>" %<EOL>(src, dest))<EOL><DEDENT>return None<EOL>
|
Convert a FileCopyCommand into a new FileCommand.
:return: None if the copy is being ignored, otherwise a
new FileCommand based on the whether the source and destination
paths are inside or outside of the interesting locations.
|
f11403:c0:m18
|
def _found(b):
|
return ['<STR_LIT>', '<STR_LIT>'][b]<EOL>
|
Format a found boolean as a string.
|
f11404:m0
|
def _iterable_as_config_list(s):
|
items = sorted(s)<EOL>if len(items) == <NUM_LIT:1>:<EOL><INDENT>return "<STR_LIT>" % (items[<NUM_LIT:0>],)<EOL><DEDENT>else:<EOL><INDENT>return "<STR_LIT:U+002CU+0020>".join(items)<EOL><DEDENT>
|
Format an iterable as a sequence of comma-separated strings.
To match what ConfigObj expects, a single item list has a trailing comma.
|
f11404:m1
|
def _dump_stats_group(self, title, items, normal_formatter=None,<EOL>verbose_formatter=None):
|
if self.verbose:<EOL><INDENT>self.outf.write("<STR_LIT>" % (title,))<EOL>for name, value in items:<EOL><INDENT>if verbose_formatter is not None:<EOL><INDENT>value = verbose_formatter(value)<EOL><DEDENT>if type(name) == str:<EOL><INDENT>name = name.replace('<STR_LIT:U+0020>', '<STR_LIT:->')<EOL><DEDENT>self.outf.write("<STR_LIT>" % (name, value))<EOL><DEDENT>self.outf.write("<STR_LIT:\n>")<EOL><DEDENT>else:<EOL><INDENT>self.outf.write("<STR_LIT>" % (title,))<EOL>for name, value in items:<EOL><INDENT>if normal_formatter is not None:<EOL><INDENT>value = normal_formatter(value)<EOL><DEDENT>self.outf.write("<STR_LIT>" % (value, name))<EOL><DEDENT><DEDENT>
|
Dump a statistics group.
In verbose mode, do so as a config file so
that other processors can load the information if they want to.
:param normal_formatter: the callable to apply to the value
before displaying it in normal mode
:param verbose_formatter: the callable to apply to the value
before displaying it in verbose mode
|
f11404:c0:m3
|
def progress_handler(self, cmd):
|
self.cmd_counts[cmd.name] += <NUM_LIT:1><EOL>
|
Process a ProgressCommand.
|
f11404:c0:m4
|
def blob_handler(self, cmd):
|
self.cmd_counts[cmd.name] += <NUM_LIT:1><EOL>if cmd.mark is None:<EOL><INDENT>self.blobs['<STR_LIT>'].add(cmd.id)<EOL><DEDENT>else:<EOL><INDENT>self.blobs['<STR_LIT>'].add(cmd.id)<EOL>try:<EOL><INDENT>self.blobs['<STR_LIT>'].remove(cmd.id)<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>
|
Process a BlobCommand.
|
f11404:c0:m5
|
def checkpoint_handler(self, cmd):
|
self.cmd_counts[cmd.name] += <NUM_LIT:1><EOL>
|
Process a CheckpointCommand.
|
f11404:c0:m6
|
def commit_handler(self, cmd):
|
self.cmd_counts[cmd.name] += <NUM_LIT:1><EOL>self.committers.add(cmd.committer)<EOL>if cmd.author is not None:<EOL><INDENT>self.separate_authors_found = True<EOL><DEDENT>for fc in cmd.iter_files():<EOL><INDENT>self.file_cmd_counts[fc.name] += <NUM_LIT:1><EOL>if isinstance(fc, commands.FileModifyCommand):<EOL><INDENT>if fc.mode & <NUM_LIT>:<EOL><INDENT>self.executables_found = True<EOL><DEDENT>if stat.S_ISLNK(fc.mode):<EOL><INDENT>self.symlinks_found = True<EOL><DEDENT>if fc.dataref is not None:<EOL><INDENT>if fc.dataref[<NUM_LIT:0>] == '<STR_LIT::>':<EOL><INDENT>self._track_blob(fc.dataref)<EOL><DEDENT>else:<EOL><INDENT>self.sha_blob_references = True<EOL><DEDENT><DEDENT><DEDENT>elif isinstance(fc, commands.FileRenameCommand):<EOL><INDENT>self.rename_old_paths.setdefault(cmd.id, set()).add(fc.old_path)<EOL><DEDENT>elif isinstance(fc, commands.FileCopyCommand):<EOL><INDENT>self.copy_source_paths.setdefault(cmd.id, set()).add(fc.src_path)<EOL><DEDENT><DEDENT>parents = self.reftracker.track_heads(cmd)<EOL>parent_count = len(parents)<EOL>try:<EOL><INDENT>self.parent_counts[parent_count] += <NUM_LIT:1><EOL><DEDENT>except KeyError:<EOL><INDENT>self.parent_counts[parent_count] = <NUM_LIT:1><EOL>if parent_count > self.max_parent_count:<EOL><INDENT>self.max_parent_count = parent_count<EOL><DEDENT><DEDENT>if cmd.merges:<EOL><INDENT>for merge in cmd.merges:<EOL><INDENT>if merge in self.merges:<EOL><INDENT>self.merges[merge] += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>self.merges[merge] = <NUM_LIT:1><EOL><DEDENT><DEDENT><DEDENT>
|
Process a CommitCommand.
|
f11404:c0:m7
|
def reset_handler(self, cmd):
|
self.cmd_counts[cmd.name] += <NUM_LIT:1><EOL>if cmd.ref.startswith('<STR_LIT>'):<EOL><INDENT>self.lightweight_tags += <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if cmd.from_ is not None:<EOL><INDENT>self.reftracker.track_heads_for_ref(<EOL>cmd.ref, cmd.from_)<EOL><DEDENT><DEDENT>
|
Process a ResetCommand.
|
f11404:c0:m8
|
def tag_handler(self, cmd):
|
self.cmd_counts[cmd.name] += <NUM_LIT:1><EOL>
|
Process a TagCommand.
|
f11404:c0:m9
|
def feature_handler(self, cmd):
|
self.cmd_counts[cmd.name] += <NUM_LIT:1><EOL>feature = cmd.feature_name<EOL>if feature not in commands.FEATURE_NAMES:<EOL><INDENT>self.warning("<STR_LIT>"<EOL>% (feature,))<EOL><DEDENT>
|
Process a FeatureCommand.
|
f11404:c0:m10
|
def check_path(path):
|
if path is None or path == b'<STR_LIT>' or path.startswith(b'<STR_LIT:/>'):<EOL><INDENT>raise ValueError("<STR_LIT>" % path)<EOL><DEDENT>if (<EOL>(sys.version_info[<NUM_LIT:0>] >= <NUM_LIT:3> and not isinstance(path, bytes)) and<EOL>(sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2> and not isinstance(path, str))<EOL>):<EOL><INDENT>raise TypeError("<STR_LIT>" % path)<EOL><DEDENT>return path<EOL>
|
Check that a path is legal.
:return: the path if all is OK
:raise ValueError: if the path is illegal
|
f11405:m0
|
def format_path(p, quote_spaces=False):
|
if b'<STR_LIT:\n>' in p:<EOL><INDENT>p = re.sub(b'<STR_LIT:\n>', b'<STR_LIT>', p)<EOL>quote = True<EOL><DEDENT>else:<EOL><INDENT>quote = p[<NUM_LIT:0>] == b'<STR_LIT:">' or (quote_spaces and b'<STR_LIT:U+0020>' in p)<EOL><DEDENT>if quote:<EOL><INDENT>extra = GIT_FAST_IMPORT_NEEDS_EXTRA_SPACE_AFTER_QUOTE and b'<STR_LIT:U+0020>' or b'<STR_LIT>'<EOL>p = b'<STR_LIT:">' + p + b'<STR_LIT:">' + extra<EOL><DEDENT>return p<EOL>
|
Format a path in utf8, quoting it if necessary.
|
f11405:m1
|
def format_who_when(fields):
|
offset = fields[<NUM_LIT:3>]<EOL>if offset < <NUM_LIT:0>:<EOL><INDENT>offset_sign = b'<STR_LIT:->'<EOL>offset = abs(offset)<EOL><DEDENT>else:<EOL><INDENT>offset_sign = b'<STR_LIT:+>'<EOL><DEDENT>offset_hours = offset // <NUM_LIT><EOL>offset_minutes = offset // <NUM_LIT> - offset_hours * <NUM_LIT><EOL>offset_str = offset_sign + ('<STR_LIT>' % (offset_hours, offset_minutes)).encode('<STR_LIT:ascii>')<EOL>name = fields[<NUM_LIT:0>]<EOL>if name == b'<STR_LIT>':<EOL><INDENT>sep = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>sep = b'<STR_LIT:U+0020>'<EOL><DEDENT>name = utf8_bytes_string(name)<EOL>email = fields[<NUM_LIT:1>]<EOL>email = utf8_bytes_string(email)<EOL>return b'<STR_LIT>'.join((name, sep, b'<STR_LIT:<>', email, b'<STR_LIT>', ("<STR_LIT>" % fields[<NUM_LIT:2>]).encode('<STR_LIT:ascii>'), b'<STR_LIT:U+0020>', offset_str))<EOL>
|
Format a tuple of name,email,secs-since-epoch,utc-offset-secs as a string.
|
f11405:m2
|
def format_property(name, value):
|
result = b'<STR_LIT>'<EOL>utf8_name = utf8_bytes_string(name)<EOL>result = b'<STR_LIT>' + utf8_name<EOL>if value is not None:<EOL><INDENT>utf8_value = utf8_bytes_string(value)<EOL>result += b'<STR_LIT:U+0020>' + ('<STR_LIT>' % len(utf8_value)).encode('<STR_LIT:ascii>') + b'<STR_LIT:U+0020>' + utf8_value<EOL><DEDENT>return result<EOL>
|
Format the name and value (both unicode) of a property as a string.
|
f11405:m3
|
def dump_str(self, names=None, child_lists=None, verbose=False):
|
interesting = {}<EOL>if names is None:<EOL><INDENT>fields = [<EOL>k for k in list(self.__dict__.keys())<EOL>if not k.startswith(b'<STR_LIT:_>')<EOL>]<EOL><DEDENT>else:<EOL><INDENT>fields = names<EOL><DEDENT>for field in fields:<EOL><INDENT>value = self.__dict__.get(field)<EOL>if field in self._binary and value is not None:<EOL><INDENT>value = b'<STR_LIT>'<EOL><DEDENT>interesting[field] = value<EOL><DEDENT>if verbose:<EOL><INDENT>return "<STR_LIT>" % (self.__class__.__name__, interesting)<EOL><DEDENT>else:<EOL><INDENT>return "<STR_LIT:\t>".join([repr(interesting[k]) for k in fields])<EOL><DEDENT>
|
Dump fields as a string.
For debugging.
:param names: the list of fields to include or
None for all public fields
:param child_lists: dictionary of child command names to
fields for that child command to include
:param verbose: if True, prefix each line with the command class and
display fields as a dictionary; if False, dump just the field
values with tabs between them
|
f11405:c0:m4
|
def to_string(self, use_features=True, include_file_contents=False):
|
if self.mark is None:<EOL><INDENT>mark_line = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if isinstance(self.mark, (int)):<EOL><INDENT>mark_line = b'<STR_LIT>' + str(self.mark).encode('<STR_LIT:utf-8>')<EOL><DEDENT>else:<EOL><INDENT>mark_line = b'<STR_LIT>' + self.mark<EOL><DEDENT><DEDENT>if self.author is None:<EOL><INDENT>author_section = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>author_section = b'<STR_LIT>' + format_who_when(self.author)<EOL>if use_features and self.more_authors:<EOL><INDENT>for author in self.more_authors:<EOL><INDENT>author_section += b'<STR_LIT>' + format_who_when(author)<EOL><DEDENT><DEDENT><DEDENT>committer = b'<STR_LIT>' + format_who_when(self.committer)<EOL>if self.message is None:<EOL><INDENT>msg_section = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>msg = self.message<EOL>msg_section = ('<STR_LIT>' % len(msg)).encode('<STR_LIT:ascii>') + msg<EOL><DEDENT>if self.from_ is None:<EOL><INDENT>from_line = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>from_line = b'<STR_LIT>' + self.from_<EOL><DEDENT>if self.merges is None:<EOL><INDENT>merge_lines = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>merge_lines = b'<STR_LIT>'.join([b'<STR_LIT>' + m<EOL>for m in self.merges])<EOL><DEDENT>if use_features and self.properties:<EOL><INDENT>property_lines = []<EOL>for name in sorted(self.properties):<EOL><INDENT>value = self.properties[name]<EOL>property_lines.append(b'<STR_LIT:\n>' + format_property(name, value))<EOL><DEDENT>properties_section = b'<STR_LIT>'.join(property_lines)<EOL><DEDENT>else:<EOL><INDENT>properties_section = b'<STR_LIT>'<EOL><DEDENT>if self.file_iter is None:<EOL><INDENT>filecommands = b'<STR_LIT>'<EOL><DEDENT>else:<EOL><INDENT>if include_file_contents:<EOL><INDENT>filecommands = b'<STR_LIT>'.join([b'<STR_LIT:\n>' + repr_bytes(c)<EOL>for c in self.iter_files()])<EOL><DEDENT>else:<EOL><INDENT>filecommands = b'<STR_LIT>'.join([b'<STR_LIT:\n>' + str(c)<EOL>for c in self.iter_files()])<EOL><DEDENT><DEDENT>return b'<STR_LIT>'.join([<EOL>b'<STR_LIT>',<EOL>self.ref,<EOL>mark_line,<EOL>author_section + b'<STR_LIT:\n>',<EOL>committer,<EOL>msg_section,<EOL>from_line,<EOL>merge_lines,<EOL>properties_section,<EOL>filecommands])<EOL>
|
@todo the name to_string is ambiguous since the method actually
returns bytes.
|
f11405:c3:m3
|
def iter_files(self):
|
<EOL>if callable(self.file_iter):<EOL><INDENT>return self.file_iter()<EOL><DEDENT>return iter(self.file_iter)<EOL>
|
Iterate over files.
|
f11405:c3:m5
|
def common_path(path1, path2):
|
return b'<STR_LIT>'.join(_common_path_and_rest(path1, path2)[<NUM_LIT:0>])<EOL>
|
Find the common bit of 2 paths.
|
f11407:m1
|
def common_directory(paths):
|
import posixpath<EOL>def get_dir_with_slash(path):<EOL><INDENT>if path == b'<STR_LIT>' or path.endswith(b'<STR_LIT:/>'):<EOL><INDENT>return path<EOL><DEDENT>else:<EOL><INDENT>dirname, basename = posixpath.split(path)<EOL>if dirname == b'<STR_LIT>':<EOL><INDENT>return dirname<EOL><DEDENT>else:<EOL><INDENT>return dirname + b'<STR_LIT:/>'<EOL><DEDENT><DEDENT><DEDENT>if not paths:<EOL><INDENT>return None<EOL><DEDENT>elif len(paths) == <NUM_LIT:1>:<EOL><INDENT>return get_dir_with_slash(paths[<NUM_LIT:0>])<EOL><DEDENT>else:<EOL><INDENT>common = common_path(paths[<NUM_LIT:0>], paths[<NUM_LIT:1>])<EOL>for path in paths[<NUM_LIT:2>:]:<EOL><INDENT>common = common_path(common, path)<EOL><DEDENT>return get_dir_with_slash(common)<EOL><DEDENT>
|
Find the deepest common directory of a list of paths.
:return: if no paths are provided, None is returned;
if there is no common directory, '' is returned;
otherwise the common directory with a trailing / is returned.
|
f11407:m2
|
def is_inside(directory, fname):
|
<EOL>if directory == fname:<EOL><INDENT>return True<EOL><DEDENT>if directory == b'<STR_LIT>':<EOL><INDENT>return True<EOL><DEDENT>if not directory.endswith(b'<STR_LIT:/>'):<EOL><INDENT>directory += b'<STR_LIT:/>'<EOL><DEDENT>return fname.startswith(directory)<EOL>
|
True if fname is inside directory.
The parameters should typically be passed to osutils.normpath first, so
that . and .. and repeated slashes are eliminated, and the separators
are canonical for the platform.
The empty string as a dir name is taken as top-of-tree and matches
everything.
|
f11407:m3
|
def is_inside_any(dir_list, fname):
|
for dirname in dir_list:<EOL><INDENT>if is_inside(dirname, fname):<EOL><INDENT>return True<EOL><DEDENT><DEDENT>return False<EOL>
|
True if fname is inside any of given dirs.
|
f11407:m4
|
def utf8_bytes_string(s):
|
if sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2>:<EOL><INDENT>if isinstance(s, str):<EOL><INDENT>return s<EOL><DEDENT>else:<EOL><INDENT>return s.encode('<STR_LIT:utf8>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if isinstance(s, str):<EOL><INDENT>return bytes(s, encoding='<STR_LIT:utf8>')<EOL><DEDENT>else:<EOL><INDENT>return s<EOL><DEDENT><DEDENT>
|
Convert a string to a bytes string (if necessary, encode in utf8)
|
f11407:m5
|
def repr_bytes(obj):
|
if sys.version_info[<NUM_LIT:0>] == <NUM_LIT:2>:<EOL><INDENT>return repr(obj)<EOL><DEDENT>else:<EOL><INDENT>return bytes(obj)<EOL><DEDENT>
|
Return a bytes representation of the object
|
f11407:m6
|
def binary_stream(stream):
|
try:<EOL><INDENT>import os<EOL>if os.name == '<STR_LIT>':<EOL><INDENT>fileno = getattr(stream, '<STR_LIT>', None)<EOL>if fileno:<EOL><INDENT>no = fileno()<EOL>if no >= <NUM_LIT:0>: <EOL><INDENT>import msvcrt<EOL>msvcrt.setmode(no, os.O_BINARY)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>except ImportError:<EOL><INDENT>pass<EOL><DEDENT>return stream<EOL>
|
Ensure a stream is binary on Windows.
:return: the stream
|
f11407:m7
|
def invert_dictset(d):
|
<EOL>result = {}<EOL>for k, c in d.items():<EOL><INDENT>for v in c:<EOL><INDENT>keys = result.setdefault(v, [])<EOL>keys.append(k)<EOL><DEDENT><DEDENT>return result<EOL>
|
Invert a dictionary with keys matching a set of values, turned into lists.
|
f11407:m8
|
def invert_dict(d):
|
<EOL>result = {}<EOL>for k, v in d.items():<EOL><INDENT>keys = result.setdefault(v, [])<EOL>keys.append(k)<EOL><DEDENT>return result<EOL>
|
Invert a dictionary with keys matching each value turned into a list.
|
f11407:m9
|
def defines_to_dict(defines):
|
if defines is None:<EOL><INDENT>return None<EOL><DEDENT>result = {}<EOL>for define in defines:<EOL><INDENT>kv = define.split('<STR_LIT:=>', <NUM_LIT:1>)<EOL>if len(kv) == <NUM_LIT:1>:<EOL><INDENT>result[define.strip()] = <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>result[kv[<NUM_LIT:0>].strip()] = kv[<NUM_LIT:1>].strip()<EOL><DEDENT><DEDENT>return result<EOL>
|
Convert a list of definition strings to a dictionary.
|
f11407:m10
|
def __native__(self):
|
return object(self)<EOL>
|
Hook for the future.utils.native() function
|
f11407:c0:m4
|
def validate_parameters(self):
|
for p in self.params:<EOL><INDENT>if p not in self.known_params:<EOL><INDENT>raise errors.UnknownParameter(p, self.known_params)<EOL><DEDENT><DEDENT>
|
Validate that the parameters are correctly specified.
|
f11408:c0:m1
|
def process(self, command_iter):
|
self._process(command_iter)<EOL>
|
Import data into Bazaar by processing a stream of commands.
:param command_iter: an iterator providing commands
|
f11408:c0:m2
|
def warning(self, msg, *args):
|
pass<EOL>
|
Output a warning but timestamp it.
|
f11408:c0:m4
|
def debug(self, mgs, *args):
|
pass<EOL>
|
Output a debug message.
|
f11408:c0:m5
|
def _time_of_day(self):
|
<EOL>return time.strftime("<STR_LIT>")<EOL>
|
Time of day as a string.
|
f11408:c0:m6
|
def pre_process(self):
|
pass<EOL>
|
Hook for logic at start of processing.
|
f11408:c0:m7
|
def post_process(self):
|
pass<EOL>
|
Hook for logic at end of processing.
|
f11408:c0:m8
|
def pre_handler(self, cmd):
|
pass<EOL>
|
Hook for logic before each handler starts.
|
f11408:c0:m9
|
def post_handler(self, cmd):
|
pass<EOL>
|
Hook for logic after each handler finishes.
|
f11408:c0:m10
|
def progress_handler(self, cmd):
|
raise NotImplementedError(self.progress_handler)<EOL>
|
Process a ProgressCommand.
|
f11408:c0:m11
|
def blob_handler(self, cmd):
|
raise NotImplementedError(self.blob_handler)<EOL>
|
Process a BlobCommand.
|
f11408:c0:m12
|
def checkpoint_handler(self, cmd):
|
raise NotImplementedError(self.checkpoint_handler)<EOL>
|
Process a CheckpointCommand.
|
f11408:c0:m13
|
def commit_handler(self, cmd):
|
raise NotImplementedError(self.commit_handler)<EOL>
|
Process a CommitCommand.
|
f11408:c0:m14
|
def reset_handler(self, cmd):
|
raise NotImplementedError(self.reset_handler)<EOL>
|
Process a ResetCommand.
|
f11408:c0:m15
|
def tag_handler(self, cmd):
|
raise NotImplementedError(self.tag_handler)<EOL>
|
Process a TagCommand.
|
f11408:c0:m16
|
def feature_handler(self, cmd):
|
raise NotImplementedError(self.feature_handler)<EOL>
|
Process a FeatureCommand.
|
f11408:c0:m17
|
def warning(self, msg, *args):
|
pass<EOL>
|
Output a warning but add context.
|
f11408:c1:m2
|
def pre_process_files(self):
|
pass<EOL>
|
Prepare for committing.
|
f11408:c1:m3
|
def post_process_files(self):
|
pass<EOL>
|
Save the revision.
|
f11408:c1:m4
|
def modify_handler(self, filecmd):
|
raise NotImplementedError(self.modify_handler)<EOL>
|
Handle a filemodify command.
|
f11408:c1:m5
|
def delete_handler(self, filecmd):
|
raise NotImplementedError(self.delete_handler)<EOL>
|
Handle a filedelete command.
|
f11408:c1:m6
|
def copy_handler(self, filecmd):
|
raise NotImplementedError(self.copy_handler)<EOL>
|
Handle a filecopy command.
|
f11408:c1:m7
|
def rename_handler(self, filecmd):
|
raise NotImplementedError(self.rename_handler)<EOL>
|
Handle a filerename command.
|
f11408:c1:m8
|
def deleteall_handler(self, filecmd):
|
raise NotImplementedError(self.deleteall_handler)<EOL>
|
Handle a filedeleteall command.
|
f11408:c1:m9
|
def modular_sqrt(a, p):
|
<EOL>if legendre_symbol(a, p) != <NUM_LIT:1>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>elif a == <NUM_LIT:0>:<EOL><INDENT>return <NUM_LIT:0><EOL><DEDENT>elif p == <NUM_LIT:2>:<EOL><INDENT>return p<EOL><DEDENT>elif p % <NUM_LIT:4> == <NUM_LIT:3>:<EOL><INDENT>return pow(a, (p + <NUM_LIT:1>) / <NUM_LIT:4>, p)<EOL><DEDENT>s = p - <NUM_LIT:1><EOL>e = <NUM_LIT:0><EOL>while s % <NUM_LIT:2> == <NUM_LIT:0>:<EOL><INDENT>s /= <NUM_LIT:2><EOL>e += <NUM_LIT:1><EOL><DEDENT>n = <NUM_LIT:2><EOL>while legendre_symbol(n, p) != -<NUM_LIT:1>:<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT>x = pow(a, (s + <NUM_LIT:1>) / <NUM_LIT:2>, p)<EOL>b = pow(a, s, p)<EOL>g = pow(n, s, p)<EOL>r = e<EOL>while True:<EOL><INDENT>t = b<EOL>m = <NUM_LIT:0><EOL>for m in xrange(r):<EOL><INDENT>if t == <NUM_LIT:1>:<EOL><INDENT>break<EOL><DEDENT>t = pow(t, <NUM_LIT:2>, p)<EOL><DEDENT>if m == <NUM_LIT:0>:<EOL><INDENT>return x<EOL><DEDENT>gs = pow(g, <NUM_LIT:2> ** (r - m - <NUM_LIT:1>), p)<EOL>g = (gs * gs) % p<EOL>x = (x * gs) % p<EOL>b = (b * g) % p<EOL>r = m<EOL><DEDENT>
|
Find a quadratic residue (mod p) of 'a'. p
must be an odd prime.
Solve the congruence of the form:
x^2 = a (mod p)
And returns x. Note that p - x is also a root.
0 is returned is no square root exists for
these a and p.
The Tonelli-Shanks algorithm is used (except
for some simple cases in which the solution
is known from an identity). This algorithm
runs in polynomial time (unless the
generalized Riemann hypothesis is false).
|
f11423:m0
|
def legendre_symbol(a, p):
|
ls = pow(a, (p - <NUM_LIT:1>) / <NUM_LIT:2>, p)<EOL>return -<NUM_LIT:1> if ls == p - <NUM_LIT:1> else ls<EOL>
|
Compute the Legendre symbol a|p using
Euler's criterion. p is a prime, a is
relatively prime to p (if p divides
a, then a|p = 0)
Returns 1 if a has a square root modulo
p, -1 otherwise.
|
f11423:m1
|
@classmethod<EOL><INDENT>def from_signature(klass, sig, recid, h, curve):<DEDENT>
|
from ecdsa import util, numbertheory<EOL>import msqr<EOL>curveFp = curve.curve<EOL>G = curve.generator<EOL>order = G.order()<EOL>r, s = util.sigdecode_string(sig, order)<EOL>x = r + (recid/<NUM_LIT:2>) * order<EOL>alpha = ( x * x * x + curveFp.a() * x + curveFp.b() ) % curveFp.p()<EOL>beta = msqr.modular_sqrt(alpha, curveFp.p())<EOL>y = beta if (beta - recid) % <NUM_LIT:2> == <NUM_LIT:0> else curveFp.p() - beta<EOL>R = Point(curveFp, x, y, order)<EOL>e = string_to_number(h)<EOL>minus_e = -e % order<EOL>inv_r = numbertheory.inverse_mod(r,order)<EOL>Q = inv_r * ( s * R + minus_e * G )<EOL>return klass.from_public_point( Q, curve )<EOL>
|
See http://www.secg.org/download/aid-780/sec1-v2.pdf, chapter 4.1.6
|
f11424:c0:m0
|
def run(self):
|
try:<EOL><INDENT>import unittest2 as unittest<EOL><DEDENT>except ImportError:<EOL><INDENT>import unittest<EOL><DEDENT>if self.verbose:<EOL><INDENT>verbosity=<NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>verbosity=<NUM_LIT:0><EOL><DEDENT>loader = unittest.defaultTestLoader<EOL>suite = unittest.TestSuite()<EOL>if self.test_suite == self.DEFAULT_TEST_SUITE:<EOL><INDENT>for test_module in loader.discover('<STR_LIT:.>'):<EOL><INDENT>suite.addTest(test_module)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>suite.addTest(loader.loadTestsFromName(self.test_suite))<EOL><DEDENT>result = unittest.TextTestRunner(verbosity=verbosity).run(suite)<EOL>if not result.wasSuccessful():<EOL><INDENT>sys.exit(<NUM_LIT:1>)<EOL><DEDENT>
|
Run the test suite.
|
f11442:c0:m2
|
@property<EOL><INDENT>def cache(self):<DEDENT>
|
if self._cache is None:<EOL><INDENT>self._cache = django_cache.get_cache(self.cache_name)<EOL><DEDENT>return self._cache<EOL>
|
Memoize access to the cache backend.
|
f11445:c0:m1
|
def get(self, key, default=None):
|
raise NotImplementedError()<EOL>
|
Retrieve the current value for a key.
Args:
key (str): the key whose value should be retrieved
default (object): the value to use when no value exist for the key
|
f11446:c0:m0
|
def set(self, key, value):
|
raise NotImplementedError()<EOL>
|
Set a new value for a given key.
|
f11446:c0:m1
|
def mget(self, *keys, **kwargs):
|
default = kwargs.get('<STR_LIT:default>')<EOL>coherent = kwargs.get('<STR_LIT>', False)<EOL>for key in keys:<EOL><INDENT>yield self.get(key, default=default)<EOL><DEDENT>
|
Retrieve values for a set of keys.
Args:
keys (str list): the list of keys whose value should be retrieved
Keyword arguements:
default (object): the value to use for non-existent keys
coherent (bool): whether all fetched values should be "coherent",
i.e no other update was performed on any of those values while
fetching from the database.
Yields:
object: values for the keys, in the order they were passed
|
f11446:c0:m2
|
def mset(self, values):
|
for key, value in values.items():<EOL><INDENT>self.set(key, value)<EOL><DEDENT>
|
Set the value of several keys at once.
Args:
values (dict): maps a key to its value.
|
f11446:c0:m3
|
def incr(self, key, amount, default=<NUM_LIT:0>):
|
old_value = self.get(key, default)<EOL>self.set(key, old_value + amount)<EOL>return old_value + amount<EOL>
|
Increment the value of a key by a given amount.
Also works for decrementing it.
Args:
key (str): the key whose value should be incremented
amount (int): the amount by which the value should be incremented
default (int): the default value to use if the key was never set
Returns:
int, the updated value
|
f11446:c0:m4
|
@property<EOL><INDENT>def key_amount(self):<DEDENT>
|
return '<STR_LIT>' % (self.key, '<STR_LIT>')<EOL>
|
Name of the key used to store the current amount.
|
f11447:c0:m1
|
@property<EOL><INDENT>def key_last_leak(self):<DEDENT>
|
return '<STR_LIT>' % (self.key, '<STR_LIT>')<EOL>
|
Name of the key used to store the time of the last leak.
|
f11447:c0:m2
|
def leak(self):
|
capacity, last_leak = self.storage.mget(self.key_amount, self.key_last_leak,<EOL>coherent=True)<EOL>now = time.time()<EOL>if last_leak:<EOL><INDENT>elapsed = now - last_leak<EOL>decrement = elapsed * self.rate<EOL>new_capacity = max(int(capacity - decrement), <NUM_LIT:0>)<EOL><DEDENT>else:<EOL><INDENT>new_capacity = <NUM_LIT:0><EOL><DEDENT>self.storage.mset({<EOL>self.key_amount: new_capacity,<EOL>self.key_last_leak: now,<EOL>})<EOL>return new_capacity<EOL>
|
Leak the adequate amount of data from the bucket.
This should be called before any consumption takes place.
Returns:
int: the new capacity of the bucket
|
f11447:c0:m3
|
def _incr(self, amount):
|
self.storage.incr(self.key_amount, amount)<EOL>
|
Handle an atomic increment to the bucket.
|
f11447:c0:m4
|
def consume(self, amount=<NUM_LIT:1>):
|
<EOL>current = self.leak()<EOL>if current + amount > self.capacity:<EOL><INDENT>return False<EOL><DEDENT>self._incr(amount)<EOL>return True<EOL>
|
Consume one or more units from the bucket.
|
f11447:c0:m5
|
def get_bucket(self, key, rate=None, capacity=None, **kwargs):
|
return buckets.Bucket(<EOL>key=key,<EOL>rate=rate or self.rate,<EOL>capacity=capacity or self.capacity,<EOL>storate=self.storate,<EOL>**kwargs)<EOL>
|
Fetch a Bucket for the given key.
rate and capacity might be overridden from the Throttler defaults.
Args:
rate (float): Units regenerated by second, or None to keep
Throttler defaults
capacity (int): Maximum units available, or None to keep Throttler
defaults
|
f11448:c1:m1
|
def consume(self, key, amount=<NUM_LIT:1>, rate=None, capacity=None, **kwargs):
|
bucket = self.get_bucket(key, rate, capacity, **kwargs)<EOL>return bucket.consume(amount)<EOL>
|
Consume an amount for a given key.
Non-default rate/capacity can be given to override Throttler defaults.
Returns:
bool: whether the units could be consumed
|
f11448:c1:m2
|
def throttle(self, key, amount=<NUM_LIT:1>, rate=None, capacity=None,<EOL>exc_class=Throttled, **kwargs):
|
if not self.consume(key, amount, rate, capacity, **kwargs):<EOL><INDENT>raise exc_class("<STR_LIT>"<EOL>% (amount, key))<EOL><DEDENT>
|
Consume an amount for a given key, or raise a Throttled exception.
|
f11448:c1:m3
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.