signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def init_config(self, app): | for k in dir(config):<EOL><INDENT>if k.startswith('<STR_LIT>'):<EOL><INDENT>app.config.setdefault(k, getattr(config, k))<EOL><DEDENT><DEDENT> | Initialize configuration. | f11242:c0:m2 |
def cached_unless_authenticated(timeout=<NUM_LIT:50>, key_prefix='<STR_LIT:default>'): | def caching(f):<EOL><INDENT>@wraps(f)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>cache_fun = current_cache.cached(<EOL>timeout=timeout, key_prefix=key_prefix,<EOL>unless=lambda: current_cache_ext.is_authenticated_callback())<EOL>return cache_fun(f)(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>return cachi... | Cache anonymous traffic. | f11246:m0 |
def is_hashable(obj): | try:<EOL><INDENT>hash(obj)<EOL><DEDENT>except Exception:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT> | Determine if obj is hashable. | f11249:m0 |
def assert_hashable_or_dict(name, obj): | if isinstance(obj, dict):<EOL><INDENT>for val in obj.values():<EOL><INDENT>assert_hashable_or_dict(name, val)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert is_hashable(obj), "<STR_LIT>" + name + "<STR_LIT>"<EOL><DEDENT> | Assert obj is hashable, or for dicts apply recursively to values. | f11249:m1 |
def is_importable(name): | try:<EOL><INDENT>import_module(name)<EOL><DEDENT>except ImportError:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT> | Determine if name can be imported. | f11249:m2 |
def main(args=None): | if args is None:<EOL><INDENT>args = sys.argv[<NUM_LIT:1>:]<EOL><DEDENT>print("<STR_LIT>" % args)<EOL>comp_all(args, expect_retcode=<NUM_LIT:0> if "<STR_LIT>" not in args else None)<EOL> | Compile everything with given arguments. | f11250:m0 |
def escape(inputstring): | if WINDOWS:<EOL><INDENT>return inputstring.replace("<STR_LIT:<>", "<STR_LIT>").replace("<STR_LIT:>>", "<STR_LIT>")<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:">' + inputstring.replace("<STR_LIT:$>", "<STR_LIT>").replace("<STR_LIT>", "<STR_LIT>") + '<STR_LIT:">'<EOL><DEDENT> | Performs basic shell escaping.
Not by any means complete, should only be used on coconut_snip. | f11251:m0 |
def call(cmd, assert_output=False, check_mypy=False, check_errors=True, stderr_first=False, expect_retcode=<NUM_LIT:0>, **kwargs): | print("<STR_LIT>", (cmd if isinstance(cmd, str) else "<STR_LIT:U+0020>".join(cmd)))<EOL>if assert_output is False:<EOL><INDENT>assert_output = ("<STR_LIT>",)<EOL><DEDENT>elif assert_output is True:<EOL><INDENT>assert_output = ("<STR_LIT>",)<EOL><DEDENT>elif isinstance(assert_output, str):<EOL><INDENT>assert_output = (a... | Executes a shell command. | f11251:m1 |
def call_coconut(args, **kwargs): | if "<STR_LIT>" not in args and not PYPY and not PY26:<EOL><INDENT>args = ["<STR_LIT>", "<STR_LIT>"] + args<EOL><DEDENT>if "<STR_LIT>" in args and "<STR_LIT>" not in kwargs:<EOL><INDENT>kwargs["<STR_LIT>"] = True<EOL><DEDENT>call(["<STR_LIT>"] + args, **kwargs)<EOL> | Calls Coconut. | f11251:m2 |
def comp(path=None, folder=None, file=None, args=[], **kwargs): | paths = []<EOL>if path is not None:<EOL><INDENT>paths.append(path)<EOL><DEDENT>compdest = os.path.join(dest, *paths)<EOL>if folder is not None:<EOL><INDENT>paths.append(folder)<EOL><DEDENT>if file is not None:<EOL><INDENT>paths.append(file)<EOL><DEDENT>source = os.path.join(src, *paths)<EOL>call_coconut([source, compde... | Compiles a test file or directory. | f11251:m3 |
@contextmanager<EOL>def remove_when_done(path): | try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>try:<EOL><INDENT>if os.path.isdir(path):<EOL><INDENT>shutil.rmtree(path)<EOL><DEDENT>elif os.path.isfile(path):<EOL><INDENT>os.remove(path)<EOL><DEDENT><DEDENT>except OSError as err:<EOL><INDENT>logger.display_exc()<EOL><DEDENT><DEDENT> | Removes a path when done. | f11251:m4 |
@contextmanager<EOL>def using_dest(): | try:<EOL><INDENT>os.mkdir(dest)<EOL><DEDENT>except Exception:<EOL><INDENT>shutil.rmtree(dest)<EOL>os.mkdir(dest)<EOL><DEDENT>with remove_when_done(dest):<EOL><INDENT>yield<EOL><DEDENT> | Makes and removes the dest folder. | f11251:m5 |
@contextmanager<EOL>def using_logger(): | saved_logger = Logger(logger)<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>logger.copy_from(saved_logger)<EOL><DEDENT> | Use a temporary logger, then restore the old logger. | f11251:m6 |
def comp_extras(args=[], **kwargs): | comp(file="<STR_LIT>", args=args, **kwargs)<EOL> | Compiles extras.coco. | f11251:m7 |
def comp_runner(args=[], **kwargs): | comp(file="<STR_LIT>", args=args, **kwargs)<EOL> | Compiles runner.coco. | f11251:m8 |
def comp_agnostic(args=[], **kwargs): | comp(path="<STR_LIT>", folder="<STR_LIT>", args=args, **kwargs)<EOL> | Compiles agnostic. | f11251:m9 |
def comp_2(args=[], **kwargs): | comp(path="<STR_LIT>", folder="<STR_LIT>", args=["<STR_LIT>", "<STR_LIT:2>"] + args, **kwargs)<EOL> | Compiles target_2. | f11251:m10 |
def comp_3(args=[], **kwargs): | comp(path="<STR_LIT>", folder="<STR_LIT>", args=["<STR_LIT>", "<STR_LIT:3>"] + args, **kwargs)<EOL> | Compiles target_3. | f11251:m11 |
def comp_35(args=[], **kwargs): | comp(path="<STR_LIT>", folder="<STR_LIT>", args=["<STR_LIT>", "<STR_LIT>"] + args, **kwargs)<EOL> | Compiles target_35. | f11251:m12 |
def comp_sys(args=[], **kwargs): | comp(path="<STR_LIT>", folder="<STR_LIT>", args=["<STR_LIT>", "<STR_LIT>"] + args, **kwargs)<EOL> | Compiles target_sys. | f11251:m13 |
def run_src(**kwargs): | call(["<STR_LIT>", os.path.join(dest, "<STR_LIT>")], assert_output=True, **kwargs)<EOL> | Runs runner.py. | f11251:m14 |
def run_extras(**kwargs): | call(["<STR_LIT>", os.path.join(dest, "<STR_LIT>")], assert_output=True, check_errors=False, stderr_first=True, **kwargs)<EOL> | Runs extras.py. | f11251:m15 |
def run(args=[], agnostic_target=None, use_run_arg=False, expect_retcode=<NUM_LIT:0>): | if agnostic_target is None:<EOL><INDENT>agnostic_args = args<EOL><DEDENT>else:<EOL><INDENT>agnostic_args = ["<STR_LIT>", str(agnostic_target)] + args<EOL><DEDENT>with using_dest():<EOL><INDENT>if PY2:<EOL><INDENT>comp_2(args)<EOL><DEDENT>else:<EOL><INDENT>comp_3(args)<EOL>if sys.version_info >= (<NUM_LIT:3>, <NUM_LIT:5... | Compiles and runs tests. | f11251:m16 |
def comp_pyston(args=[], **kwargs): | call(["<STR_LIT>", "<STR_LIT>", pyston_git])<EOL>call_coconut(["<STR_LIT>"] + args, **kwargs)<EOL> | Compiles evhub/pyston. | f11251:m17 |
def run_pyston(**kwargs): | call(["<STR_LIT>", os.path.join(pyston, "<STR_LIT>")], assert_output=True, **kwargs)<EOL> | Runs pyston. | f11251:m18 |
def comp_pyprover(args=[], **kwargs): | call(["<STR_LIT>", "<STR_LIT>", pyprover_git])<EOL>call_coconut([os.path.join(pyprover, "<STR_LIT>"), "<STR_LIT>"] + args, **kwargs)<EOL>call_coconut([os.path.join(pyprover, "<STR_LIT>"), os.path.join(pyprover, "<STR_LIT>"), "<STR_LIT>"] + args, **kwargs)<EOL> | Compiles evhub/pyprover. | f11251:m19 |
def run_pyprover(**kwargs): | call(["<STR_LIT>", "<STR_LIT>", "<STR_LIT>", pyprover])<EOL>call(["<STR_LIT>", os.path.join(pyprover, "<STR_LIT>", "<STR_LIT>")], assert_output=True, **kwargs)<EOL> | Runs pyprover. | f11251:m20 |
def comp_prelude(args=[], **kwargs): | call(["<STR_LIT>", "<STR_LIT>", prelude_git])<EOL>call_coconut([os.path.join(prelude, "<STR_LIT>"), "<STR_LIT>"] + args, **kwargs)<EOL>if MYPY:<EOL><INDENT>args.append("<STR_LIT>")<EOL><DEDENT>call_coconut([os.path.join(prelude, "<STR_LIT>"), os.path.join(prelude, "<STR_LIT>"), "<STR_LIT>"] + args, **kwargs)<EOL> | Compiles evhub/coconut-prelude. | f11251:m21 |
def run_prelude(**kwargs): | call(["<STR_LIT>", "<STR_LIT>", "<STR_LIT>", prelude])<EOL>call(["<STR_LIT>", os.path.join(prelude, "<STR_LIT>", "<STR_LIT>")], assert_output=True, **kwargs)<EOL> | Runs coconut-prelude. | f11251:m22 |
def comp_all(args=[], **kwargs): | try:<EOL><INDENT>os.mkdir(dest)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>comp_2(args, **kwargs)<EOL>comp_3(args, **kwargs)<EOL>comp_35(args, **kwargs)<EOL>comp_agnostic(args, **kwargs)<EOL>comp_sys(args, **kwargs)<EOL>comp_runner(args, **kwargs)<EOL>comp_extras(args, **kwargs)<EOL> | Compile Coconut tests. | f11251:m23 |
def run_runnable(args=[]): | call(["<STR_LIT>"] + args + [runnable_coco, "<STR_LIT>"], assert_output=True)<EOL> | Call coconut-run on runnable_coco. | f11251:m24 |
def printerr(*args): | print(*args, file=sys.stderr)<EOL> | Prints to standard error. | f11253:m0 |
def format_error(err_type, err_value, err_trace=None): | if err_trace is None:<EOL><INDENT>err_parts = "<STR_LIT>".join(traceback.format_exception_only(err_type, err_value)).strip().split("<STR_LIT>", <NUM_LIT:1>)<EOL>if len(err_parts) == <NUM_LIT:1>:<EOL><INDENT>err_name, err_msg = err_parts[<NUM_LIT:0>], "<STR_LIT>"<EOL><DEDENT>else:<EOL><INDENT>err_name, err_msg = err_par... | Properly formats the specified error. | f11253:m1 |
def complain(error): | if callable(error):<EOL><INDENT>if DEVELOP:<EOL><INDENT>raise error()<EOL><DEDENT><DEDENT>elif DEVELOP:<EOL><INDENT>raise error<EOL><DEDENT>else:<EOL><INDENT>logger.warn_err(error)<EOL><DEDENT> | Raises in develop; warns in release. | f11253:m2 |
def __init__(self, other=None): | if other is not None:<EOL><INDENT>self.copy_from(other)<EOL><DEDENT>self.patch_logging()<EOL> | Create a logger, optionally from another logger. | f11253:c0:m0 |
def copy_from(self, other): | self.verbose, self.quiet, self.path, self.name, self.tracing = other.verbose, other.quiet, other.path, other.name, other.tracing<EOL> | Copy other onto self. | f11253:c0:m1 |
def display(self, messages, sig="<STR_LIT>", debug=False): | full_message = "<STR_LIT>".join(<EOL>sig + line for line in "<STR_LIT:U+0020>".join(<EOL>str(msg) for msg in messages<EOL>).splitlines(True)<EOL>)<EOL>if not full_message:<EOL><INDENT>full_message = sig.rstrip()<EOL><DEDENT>if debug:<EOL><INDENT>printerr(full_message)<EOL><DEDENT>else:<EOL><INDENT>print(full_message)<E... | Prints an iterator of messages. | f11253:c0:m2 |
def show(self, *messages): | if not self.quiet:<EOL><INDENT>self.display(messages)<EOL><DEDENT> | Prints messages if not --quiet. | f11253:c0:m3 |
def show_sig(self, *messages): | if not self.quiet:<EOL><INDENT>self.display(messages, main_sig)<EOL><DEDENT> | Prints messages with main signature if not --quiet. | f11253:c0:m4 |
def show_error(self, *messages): | if not self.quiet:<EOL><INDENT>self.display(messages, main_sig, debug=True)<EOL><DEDENT> | Prints error messages with main signature if not --quiet. | f11253:c0:m5 |
def log(self, *messages): | if self.verbose:<EOL><INDENT>printerr(*messages)<EOL><DEDENT> | Logs debug messages if --verbose. | f11253:c0:m6 |
def log_prefix(self, prefix, *messages): | if self.verbose:<EOL><INDENT>self.display(messages, prefix, debug=True)<EOL><DEDENT> | Logs debug messages with the given signature if --verbose. | f11253:c0:m7 |
def log_sig(self, *messages): | self.log_prefix(main_sig, *messages)<EOL> | Logs debug messages with the main signature if --verbose. | f11253:c0:m8 |
def log_vars(self, message, variables, rem_vars=("<STR_LIT>",)): | if self.verbose:<EOL><INDENT>new_vars = dict(variables)<EOL>for v in rem_vars:<EOL><INDENT>del new_vars[v]<EOL><DEDENT>printerr(message, new_vars)<EOL><DEDENT> | Logs variables with given message if --verbose. | f11253:c0:m9 |
def get_error(self): | exc_info = sys.exc_info()<EOL>if exc_info[<NUM_LIT:0>] is None:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>err_type, err_value, err_trace = exc_info[<NUM_LIT:0>], exc_info[<NUM_LIT:1>], None<EOL>if self.verbose and len(exc_info) > <NUM_LIT:2>:<EOL><INDENT>err_trace = exc_info[<NUM_LIT:2>]<EOL><DEDENT>return ... | Properly formats the current error. | f11253:c0:m10 |
@contextmanager<EOL><INDENT>def in_path(self, new_path, old_path=None):<DEDENT> | self.path = new_path<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>self.path = old_path<EOL><DEDENT> | Temporarily enters a path. | f11253:c0:m11 |
def warn(self, *args, **kwargs): | return self.warn_err(CoconutWarning(*args, **kwargs))<EOL> | Creates and displays a warning. | f11253:c0:m12 |
def warn_err(self, warning): | try:<EOL><INDENT>raise warning<EOL><DEDENT>except Exception:<EOL><INDENT>if not self.quiet:<EOL><INDENT>self.display_exc()<EOL><DEDENT><DEDENT> | Displays a warning. | f11253:c0:m13 |
def display_exc(self): | errmsg = self.get_error()<EOL>if errmsg is not None:<EOL><INDENT>if self.path is not None:<EOL><INDENT>errmsg_lines = ["<STR_LIT>" + self.path + "<STR_LIT::>"]<EOL>for line in errmsg.splitlines():<EOL><INDENT>if line:<EOL><INDENT>line = "<STR_LIT:U+0020>" * taberrfmt + line<EOL><DEDENT>errmsg_lines.append(line)<EOL><DE... | Properly prints an exception in the exception context. | f11253:c0:m14 |
def log_exc(self): | if self.verbose:<EOL><INDENT>self.display_exc()<EOL><DEDENT> | Display an exception only if --verbose. | f11253:c0:m15 |
def log_cmd(self, args): | self.log("<STR_LIT>" + "<STR_LIT:U+0020>".join(args))<EOL> | Logs a console command if --verbose. | f11253:c0:m16 |
def show_tabulated(self, begin, middle, end): | internal_assert(len(begin) < info_tabulation, "<STR_LIT>", begin)<EOL>self.show(begin + "<STR_LIT:U+0020>" * (info_tabulation - len(begin)) + middle + "<STR_LIT:U+0020>" + end)<EOL> | Shows a tabulated message. | f11253:c0:m17 |
def log_tag(self, tag, code, multiline=False): | if self.tracing:<EOL><INDENT>if callable(code):<EOL><INDENT>code = code()<EOL><DEDENT>tagstr = "<STR_LIT:[>" + str(tag) + "<STR_LIT:]>"<EOL>if multiline:<EOL><INDENT>printerr(tagstr + "<STR_LIT:\n>" + displayable(code))<EOL><DEDENT>else:<EOL><INDENT>printerr(tagstr, ascii(code))<EOL><DEDENT><DEDENT> | Logs a tagged message if tracing. | f11253:c0:m18 |
def log_trace(self, tag, original, loc, tokens=None, extra=None): | if self.tracing:<EOL><INDENT>tag, original, loc = displayable(tag), displayable(original), int(loc)<EOL>if "<STR_LIT:{>" not in tag:<EOL><INDENT>out = ["<STR_LIT:[>" + tag + "<STR_LIT:]>"]<EOL>add_line_col = True<EOL>if tokens is not None:<EOL><INDENT>if isinstance(tokens, Exception):<EOL><INDENT>msg = displayable(str(... | Formats and displays a trace if tracing. | f11253:c0:m19 |
def trace(self, item): | if DEVELOP:<EOL><INDENT>item.debugActions = (<EOL>None, <EOL>self._trace_success_action,<EOL>self._trace_exc_action,<EOL>)<EOL>item.debug = True<EOL><DEDENT>return item<EOL> | Traces a parse element (only enabled in develop). | f11253:c0:m22 |
@contextmanager<EOL><INDENT>def gather_parsing_stats(self):<DEDENT> | if self.verbose:<EOL><INDENT>start_time = time.clock()<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>elapsed_time = time.clock() - start_time<EOL>printerr("<STR_LIT>", elapsed_time, "<STR_LIT>")<EOL>if packrat_cache:<EOL><INDENT>hits, misses = ParserElement.packrat_cache_stats<EOL>printerr("<STR_LIT>", hi... | Times parsing if --verbose. | f11253:c0:m23 |
def patch_logging(self): | if not hasattr(logging, "<STR_LIT>"):<EOL><INDENT>def getLogger(name=None):<EOL><INDENT>other = Logger(self)<EOL>if name is not None:<EOL><INDENT>other.name = name<EOL><DEDENT>return other<EOL><DEDENT>logging.getLogger = getLogger<EOL><DEDENT> | Patches built-in Python logging if necessary. | f11253:c0:m24 |
def pylog(self, *args, **kwargs): | printerr(self.name, args, kwargs, traceback.format_exc())<EOL> | Display all available logging information. | f11253:c0:m25 |
def fixpath(path): | return os.path.normpath(os.path.realpath(os.path.expanduser(path)))<EOL> | Uniformly format a path. | f11254:m0 |
def get_target_info(target): | return tuple(int(x) for x in target)<EOL> | Return target information as a version tuple. | f11254:m1 |
def ver_tuple_to_str(req_ver): | return "<STR_LIT:.>".join(str(x) for x in req_ver)<EOL> | Converts a requirement version tuple into a version string. | f11254:m2 |
def ver_str_to_tuple(ver_str): | out = []<EOL>for x in ver_str.split("<STR_LIT:.>"):<EOL><INDENT>try:<EOL><INDENT>x = int(x)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>out.append(x)<EOL><DEDENT>return tuple(out)<EOL> | Convert a version string into a version tuple. | f11254:m3 |
def checksum(data): | return crc32(data) & <NUM_LIT><EOL> | Compute a checksum of the given data.
Used for computing __coconut_hash__. | f11254:m4 |
def set_to_tuple(tokens): | internal_assert(len(tokens) == <NUM_LIT:1>, "<STR_LIT>", tokens)<EOL>if "<STR_LIT>" in tokens or "<STR_LIT:list>" in tokens:<EOL><INDENT>return "<STR_LIT:(>" + tokens[<NUM_LIT:0>] + "<STR_LIT:)>"<EOL><DEDENT>elif "<STR_LIT:test>" in tokens:<EOL><INDENT>return "<STR_LIT:(>" + tokens[<NUM_LIT:0>] + "<STR_LIT>"<EOL><DEDEN... | Converts set literal tokens to tuples. | f11255:m0 |
def import_stmt(imp_from, imp, imp_as): | return (<EOL>("<STR_LIT>" + imp_from + "<STR_LIT:U+0020>" if imp_from is not None else "<STR_LIT>")<EOL>+ "<STR_LIT>" + imp<EOL>+ ("<STR_LIT>" + imp_as if imp_as is not None else "<STR_LIT>")<EOL>)<EOL> | Generate an import statement. | f11255:m1 |
def single_import(path, imp_as): | out = []<EOL>parts = path.split("<STR_LIT>") <EOL>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>imp_from, imp = None, parts[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>imp_from, imp = parts<EOL><DEDENT>if imp == imp_as:<EOL><INDENT>imp_as = None<EOL><DEDENT>elif imp.endswith("<STR_LIT:.>" + imp_as):<EOL><INDENT>if imp_from... | Generate import statements from a fully qualified import and the name to bind it to. | f11255:m2 |
def universal_import(imports, imp_from=None, target="<STR_LIT>"): | importmap = [] <EOL>for imps in imports:<EOL><INDENT>if len(imps) == <NUM_LIT:1>:<EOL><INDENT>imp, imp_as = imps[<NUM_LIT:0>], imps[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>imp, imp_as = imps<EOL><DEDENT>if imp_from is not None:<EOL><INDENT>imp = imp_from + "<STR_LIT>" + imp <EOL><DEDENT>old_imp = None<EOL>path = i... | Generate code for a universal import of imports from imp_from on target.
imports = [[imp1], [imp2, as], ...] | f11255:m3 |
def imported_names(imports): | for imp in imports:<EOL><INDENT>yield imp[-<NUM_LIT:1>].split("<STR_LIT:.>", <NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT> | Yields all the names imported by imports = [[imp1], [imp2, as], ...]. | f11255:m4 |
def split_args_list(tokens, loc): | req_args, def_args, star_arg, kwd_args, dubstar_arg = [], [], None, [], None<EOL>pos = <NUM_LIT:0><EOL>for arg in tokens:<EOL><INDENT>if len(arg) == <NUM_LIT:1>:<EOL><INDENT>if arg[<NUM_LIT:0>] == "<STR_LIT:*>":<EOL><INDENT>if pos >= <NUM_LIT:3>:<EOL><INDENT>raise CoconutDeferredSyntaxError("<STR_LIT>", loc)<EOL><DEDEN... | Splits function definition arguments. | f11255:m5 |
def match_case_tokens(loc, tokens, check_var, top): | if len(tokens) == <NUM_LIT:2>:<EOL><INDENT>matches, stmts = tokens<EOL>cond = None<EOL><DEDENT>elif len(tokens) == <NUM_LIT:3>:<EOL><INDENT>matches, cond, stmts = tokens<EOL><DEDENT>else:<EOL><INDENT>raise CoconutInternalException("<STR_LIT>", tokens)<EOL><DEDENT>matching = Matcher(loc, check_var)<EOL>matching.match(ma... | Build code for matching the given case. | f11255:m6 |
def __init__(self, *args, **kwargs): | self.setup(*args, **kwargs)<EOL> | Creates a new compiler with the given parsing parameters. | f11255:c0:m0 |
def setup(self, target=None, strict=False, minify=False, line_numbers=False, keep_lines=False, no_tco=False): | if target is None:<EOL><INDENT>target = "<STR_LIT>"<EOL><DEDENT>else:<EOL><INDENT>target = str(target).replace("<STR_LIT:.>", "<STR_LIT>")<EOL><DEDENT>if target in pseudo_targets:<EOL><INDENT>target = pseudo_targets[target]<EOL><DEDENT>if target not in targets:<EOL><INDENT>raise CoconutException(<EOL>"<STR_LIT>" + asci... | Initializes parsing parameters. | f11255:c0:m1 |
def __reduce__(self): | return (Compiler, (self.target, self.strict, self.minify, self.line_numbers, self.keep_lines, self.no_tco))<EOL> | Return pickling information. | f11255:c0:m2 |
def genhash(self, package, code): | return hex(checksum(<EOL>hash_sep.join(<EOL>str(item) for item in (VERSION_STR,)<EOL>+ self.__reduce__()[<NUM_LIT:1>]<EOL>+ (package, code)<EOL>).encode(default_encoding),<EOL>))<EOL> | Generate a hash from code. | f11255:c0:m3 |
def reset(self): | self.indchar = None<EOL>self.comments = {}<EOL>self.refs = []<EOL>self.set_skips([])<EOL>self.docstring = "<STR_LIT>"<EOL>self.ichain_count = <NUM_LIT:0><EOL>self.tre_store_count = <NUM_LIT:0><EOL>self.case_check_count = <NUM_LIT:0><EOL>self.stmt_lambdas = []<EOL>if self.strict:<EOL><INDENT>self.unused_imports = set()<... | Resets references. | f11255:c0:m4 |
def bind(self): | self.endline <<= attach(self.endline_ref, self.endline_handle)<EOL>self.moduledoc_item <<= trace(attach(self.moduledoc, self.set_docstring))<EOL>self.name <<= trace(attach(self.base_name, self.name_check))<EOL>self.comment <<= trace(attach(self.comment_ref, self.comment_handle, greedy=True))<EOL>self.set_literal <<= tr... | Binds reference objects to the proper parse actions. | f11255:c0:m5 |
def copy_skips(self): | return self.skips[:]<EOL> | Copy the line skips. | f11255:c0:m6 |
def set_skips(self, skips): | skips.sort()<EOL>internal_assert(lambda: len(set(skips)) == len(skips), "<STR_LIT>", skips)<EOL>self.skips = skips<EOL> | Set the line skips. | f11255:c0:m7 |
def adjust(self, ln): | adj_ln = ln<EOL>need_unskipped = <NUM_LIT:0><EOL>for i in self.skips:<EOL><INDENT>if i <= ln:<EOL><INDENT>need_unskipped += <NUM_LIT:1><EOL><DEDENT>elif adj_ln + need_unskipped < i:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>need_unskipped -= i - adj_ln - <NUM_LIT:1><EOL>adj_ln = i<EOL><DEDENT><DEDENT>return adj_l... | Converts a parsing line number into an original line number. | f11255:c0:m8 |
def reformat(self, snip, index=None): | if index is not None:<EOL><INDENT>return self.reformat(snip), len(self.reformat(snip[:index]))<EOL><DEDENT>else:<EOL><INDENT>return self.repl_proc(snip, reformatting=True, log=False)<EOL><DEDENT> | Post process a preprocessed snippet. | f11255:c0:m9 |
def eval_now(self, code): | result = eval(self.reformat(code))<EOL>if result is None or isinstance(result, (bool, int, float, complex)):<EOL><INDENT>return repr(result)<EOL><DEDENT>elif isinstance(result, bytes):<EOL><INDENT>return "<STR_LIT:b>" + self.wrap_str_of(result)<EOL><DEDENT>elif isinstance(result, str):<EOL><INDENT>return self.wrap_str_... | Reformat and evaluate a code snippet and return code for the result. | f11255:c0:m10 |
def make_err(self, errtype, message, original, loc, ln=None, reformat=True, *args, **kwargs): | if ln is None:<EOL><INDENT>ln = self.adjust(lineno(loc, original))<EOL><DEDENT>errstr, index = getline(loc, original), col(loc, original) - <NUM_LIT:1><EOL>if reformat:<EOL><INDENT>errstr, index = self.reformat(errstr, index)<EOL><DEDENT>return errtype(message, errstr, index, ln, *args, **kwargs)<EOL> | Generate an error of the specified type. | f11255:c0:m11 |
def strict_err_or_warn(self, *args, **kwargs): | if self.strict:<EOL><INDENT>raise self.make_err(CoconutStyleError, *args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>logger.warn_err(self.make_err(CoconutSyntaxWarning, *args, **kwargs))<EOL><DEDENT> | Raises an error if in strict mode, otherwise raises a warning. | f11255:c0:m12 |
def add_ref(self, reftype, data): | ref = (reftype, data)<EOL>try:<EOL><INDENT>index = self.refs.index(ref)<EOL><DEDENT>except ValueError:<EOL><INDENT>self.refs.append(ref)<EOL>index = len(self.refs) - <NUM_LIT:1><EOL><DEDENT>return str(index)<EOL> | Add a reference and returns the identifier. | f11255:c0:m13 |
def get_ref(self, reftype, index): | try:<EOL><INDENT>got_reftype, data = self.refs[int(index)]<EOL><DEDENT>except (IndexError, ValueError):<EOL><INDENT>raise CoconutInternalException("<STR_LIT>", index)<EOL><DEDENT>internal_assert(got_reftype == reftype, "<STR_LIT>" + reftype + "<STR_LIT>" + got_reftype + "<STR_LIT>")<EOL>return data<EOL> | Retrieve a reference. | f11255:c0:m14 |
def wrap_str(self, text, strchar, multiline=False): | if multiline:<EOL><INDENT>strchar *= <NUM_LIT:3><EOL><DEDENT>return strwrapper + self.add_ref("<STR_LIT:str>", (text, strchar)) + unwrapper<EOL> | Wrap a string. | f11255:c0:m15 |
def wrap_str_of(self, text): | text_repr = ascii(text)<EOL>internal_assert(text_repr[<NUM_LIT:0>] == text_repr[-<NUM_LIT:1>] and text_repr[<NUM_LIT:0>] in ("<STR_LIT:'>", '<STR_LIT:">'), "<STR_LIT>", text)<EOL>return self.wrap_str(text_repr[<NUM_LIT:1>:-<NUM_LIT:1>], text_repr[-<NUM_LIT:1>])<EOL> | Wrap a string of a string. | f11255:c0:m16 |
def wrap_passthrough(self, text, multiline=True): | if not multiline:<EOL><INDENT>text = text.lstrip()<EOL><DEDENT>if multiline:<EOL><INDENT>out = "<STR_LIT:\\>"<EOL><DEDENT>else:<EOL><INDENT>out = "<STR_LIT>"<EOL><DEDENT>out += self.add_ref("<STR_LIT>", text) + unwrapper<EOL>if not multiline:<EOL><INDENT>out += "<STR_LIT:\n>"<EOL><DEDENT>return out<EOL> | Wrap a passthrough. | f11255:c0:m17 |
def wrap_comment(self, text, reformat=True): | if reformat:<EOL><INDENT>text = self.reformat(text)<EOL><DEDENT>return "<STR_LIT:#>" + self.add_ref("<STR_LIT>", text) + unwrapper<EOL> | Wrap a comment. | f11255:c0:m18 |
def wrap_line_number(self, ln): | return "<STR_LIT:#>" + self.add_ref("<STR_LIT>", ln) + lnwrapper<EOL> | Wrap a line number. | f11255:c0:m19 |
def apply_procs(self, procs, kwargs, inputstring, log=True): | for get_proc in procs:<EOL><INDENT>proc = get_proc(self)<EOL>inputstring = proc(inputstring, **kwargs)<EOL>if log:<EOL><INDENT>logger.log_tag(proc.__name__, inputstring, multiline=True)<EOL><DEDENT><DEDENT>return inputstring<EOL> | Apply processors to inputstring. | f11255:c0:m20 |
def pre(self, inputstring, **kwargs): | out = self.apply_procs(self.preprocs, kwargs, str(inputstring))<EOL>logger.log_tag("<STR_LIT>", self.skips)<EOL>return out<EOL> | Perform pre-processing. | f11255:c0:m21 |
def post(self, result, **kwargs): | internal_assert(isinstance(result, str), "<STR_LIT>", result)<EOL>return self.apply_procs(self.postprocs, kwargs, result)<EOL> | Perform post-processing. | f11255:c0:m22 |
def getheader(self, which, use_hash=None, polish=True): | header = getheader(<EOL>which,<EOL>use_hash=use_hash,<EOL>target=self.target,<EOL>no_tco=self.no_tco,<EOL>strict=self.strict,<EOL>)<EOL>if polish:<EOL><INDENT>header = self.polish(header)<EOL><DEDENT>return header<EOL> | Get a formatted header. | f11255:c0:m23 |
@property<EOL><INDENT>def target_info(self):<DEDENT> | return get_target_info(self.target)<EOL> | Return information on the current target as a version tuple. | f11255:c0:m24 |
def make_syntax_err(self, err, original): | msg, loc = err.args<EOL>return self.make_err(CoconutSyntaxError, msg, original, loc)<EOL> | Make a CoconutSyntaxError from a CoconutDeferredSyntaxError. | f11255:c0:m25 |
def make_parse_err(self, err, reformat=True, include_ln=True): | err_line = err.line<EOL>err_index = err.col - <NUM_LIT:1><EOL>err_lineno = err.lineno if include_ln else None<EOL>if reformat:<EOL><INDENT>err_line, err_index = self.reformat(err_line, err_index)<EOL>if err_lineno is not None:<EOL><INDENT>err_lineno = self.adjust(err_lineno)<EOL><DEDENT><DEDENT>return CoconutParseError... | Make a CoconutParseError from a ParseBaseException. | f11255:c0:m26 |
def parse(self, inputstring, parser, preargs, postargs): | self.reset()<EOL>pre_procd = None<EOL>with logger.gather_parsing_stats():<EOL><INDENT>try:<EOL><INDENT>pre_procd = self.pre(inputstring, **preargs)<EOL>parsed = parse(parser, pre_procd)<EOL>out = self.post(parsed, **postargs)<EOL><DEDENT>except ParseBaseException as err:<EOL><INDENT>raise self.make_parse_err(err)<EOL><... | Use the parser to parse the inputstring with appropriate setup and teardown. | f11255:c0:m27 |
def prepare(self, inputstring, strip=False, nl_at_eof_check=False, **kwargs): | if self.strict and nl_at_eof_check and inputstring and not inputstring.endswith("<STR_LIT:\n>"):<EOL><INDENT>end_index = len(inputstring) - <NUM_LIT:1> if inputstring else <NUM_LIT:0><EOL>raise self.make_err(CoconutStyleError, "<STR_LIT>", inputstring, end_index)<EOL><DEDENT>original_lines = inputstring.splitlines()<EO... | Prepare a string for processing. | f11255:c0:m28 |
def str_proc(self, inputstring, **kwargs): | out = []<EOL>found = None <EOL>hold = None<EOL>_comment = <NUM_LIT:0> <EOL>_contents = <NUM_LIT:0> <EOL>_start = <NUM_LIT:1> <EOL>_stop = <NUM_LIT:2> <EOL>skips = self.copy_skips()<EOL>x = <NUM_LIT:0><EOL>while x <= len(inputstring):<EOL><INDENT>try:<EOL><INDENT>c = inputstring[x]<EOL><DEDENT>except IndexError:<EO... | Process strings and comments. | f11255:c0:m29 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.