def __init__(self, products): container = ProductsContainer(products) self.products = container self.metadata = MetadataCollection(container) self.clients = ClientContainer(container) self._repr = Repr()
def test_tuple(self): eq = self.assertEqual eq(r((1,)), "(1,)") t3 = (1, 2, 3) eq(r(t3), "(1, 2, 3)") r2 = Repr() r2.maxtuple = 2 expected = repr(t3)[:-2] + "...)" eq(r2.repr(t3), expected) # modified fillvalue: r3 = Repr() r3.fillvalue = '+++' r3.maxtuple = 2 expected = repr(t3)[:-2] + "+++)" eq(r3.repr(t3), expected)
def __init__(self, source, path_to_here=None, defaults=None): # if initialized from another EnvDict, copy the attributes to # initialize # this happens in the CLI parser, which instanttiates the env # because it needs to create one and then replace cli args, then # passes this modified object to DAGSpec if isinstance(source, EnvDict): for attr in ( '_path_to_env', '_preprocessed', '_expander', '_data', '_repr', '_default_keys', ): original = getattr(source, attr) setattr(self, attr, deepcopy(original)) else: ( # load data raw_data, # this will be None if source is a dict self._path_to_env) = load_from_source(source) if defaults: raw_data = {**defaults, **raw_data} # add default placeholders but override them if they are defined # in the raw data default = self._default_dict(include_here=path_to_here is not None) self._default_keys = set(default) - set(raw_data) raw_data = {**default, **raw_data} # check raw data is ok validate.raw_data_keys(raw_data) # expand _module special key, return its expanded value self._preprocessed = raw_preprocess(raw_data, self._path_to_env) # initialize expander, which converts placeholders to their values # we need to pass path_to_env since the {{here}} placeholder # resolves to its parent if path_to_here is None: # if no pat_to_here, use path_to_end path_to_here = (None if self._path_to_env is None else Path( self._path_to_env).parent) else: path_to_here = Path(path_to_here).resolve() self._expander = EnvironmentExpander(self._preprocessed, path_to_here=path_to_here) # now expand all values self._data = self._expander.expand_raw_dictionary(raw_data) self._repr = Repr()
def test_tuple(self): eq = self.assertEqual eq(r((1,)), "(1,)") t3 = (1, 2, 3) eq(r(t3), "(1, 2, 3)") r2 = Repr() r2.maxtuple = 2 expected = repr(t3)[:-2] + "...)" eq(r2.repr(t3), expected)
def test_init_kwargs(self): example_kwargs = { "maxlevel": 101, "maxtuple": 102, "maxlist": 103, "maxarray": 104, "maxdict": 105, "maxset": 106, "maxfrozenset": 107, "maxdeque": 108, "maxstring": 109, "maxlong": 110, "maxother": 111, "fillvalue": "x" * 112, } r1 = Repr() for attr, val in example_kwargs.items(): setattr(r1, attr, val) r2 = Repr(**example_kwargs) for attr in example_kwargs: self.assertEqual(getattr(r1, attr), getattr(r2, attr), msg=attr)
def __init__(self, core_obj, opts=None): Mprocessor.Processor.__init__(self, core_obj) self.response = {"errs": [], "msg": []} self.continue_running = False # True if we should leave command loop self.cmd_instances = self._populate_commands() # command name before alias or macro resolution self.cmd_name = "" # Current command getting run self.current_command = "" self.debug_nest = 1 self.display_mgr = Mdisplay.DisplayMgr() self.intf = core_obj.debugger.intf self.last_command = None # Initially a no-op self.precmd_hooks = [] # If not: # self.location = lambda : print_location(self) self.preloop_hooks = [] self.postcmd_hooks = [] self._populate_cmd_lists() # Stop only if line/file is different from last time self.different_line = None # These values updated on entry. Set initial values. self.curframe = None self.event = None self.event_arg = None self.frame = None self.list_lineno = 0 # Create a custom safe Repr instance and increase its maxstring. # The default of 30 truncates error messages too easily. self._repr = Repr() self._repr.maxstring = 100 self._repr.maxother = 60 self._repr.maxset = 10 self._repr.maxfrozen = 10 self._repr.array = 10 self._saferepr = self._repr.repr self.stack = [] self.thread_name = None self.frame_thread_name = None return
def get_prices_from_api(request_uri: str) -> dict: """using the provided URI, request data from the Octopus API and return a JSON object. Try to handle errors gracefully with retries when appropriate.""" # Try to handle issues with the API - rare but do happen, using an # exponential sleep time up to 2**14 (16384) seconds, approx 4.5 hours. # We will keep trying for over 9 hours and then give up. print('Requesting Agile prices from Octopus API...') retry_count = 0 my_repr = Repr() my_repr.maxstring = 80 # let's avoid truncating our error messages too much while retry_count <= MAX_RETRIES: if retry_count == MAX_RETRIES: raise SystemExit('API retry limit exceeded.') try: success = False response = requests.get(request_uri, timeout=5) response.raise_for_status() if response.status_code // 100 == 2: success = True return response.json() except requests.exceptions.HTTPError as error: print(('API HTTP error ' + str(response.status_code) + ',retrying in ' + str(2**retry_count) + 's')) time.sleep(2**retry_count) retry_count += 1 except requests.exceptions.ConnectionError as error: print(('API connection error: ' + my_repr.repr(str(error)) + ', retrying in ' + str(2**retry_count) + 's')) time.sleep(2**retry_count) retry_count += 1 except requests.exceptions.Timeout: print('API request timeout, retrying in ' + str(2**retry_count) + 's') time.sleep(2**retry_count) retry_count += 1 except requests.exceptions.RequestException as error: raise SystemExit('API Request error: ' + str(error)) from error if success: print('API request successful, status ' + str(response.status_code) + '.') break
def print_kwargs(self, kwargs, show_size=False): repr_instance = Repr() print() for arg_name, arg_val in kwargs.items(): print(f"\x1b[1m\x1b[34m{arg_name}\x1b[0m", end="") if isinstance(arg_val, (list, tuple, set, dict)): print(f"({len(arg_val)})", end="") if show_size: size = round(get_size(arg_val) / 1048576, 4) print(f" {size} MB", end="") print(f": {repr_instance.repr(arg_val)}") print()
def safe_max(*args): iterable = args[0] if len(args) == 1 else args return max((value for value in iterable if value is not None), default=None) def is_ipython(): try: __IPYTHON__ return True except NameError: return False compact_repr = Repr() compact_repr.maxstring = 80 compact_repr.maxother = 80 compact_repr = compact_repr.repr class OmittedType: __slots__ = () def __repr__(self): return "<...>" Omitted = OmittedType()
# XXX TO DO: # - popup menu # - support partial or total redisplay # - more doc strings # - tooltips # object browser # XXX TO DO: # - for classes/modules, add "open source" to object browser from reprlib import Repr from idlelib.tree import TreeItem, TreeNode, ScrolledCanvas myrepr = Repr() myrepr.maxstring = 100 myrepr.maxother = 100 class ObjectTreeItem(TreeItem): def __init__(self, labeltext, object, setfunction=None): self.labeltext = labeltext self.object = object self.setfunction = setfunction def GetLabelText(self): return self.labeltext def GetText(self): return myrepr.repr(self.object)
def __init__(self, core_obj, opts=None): super().__init__(core_obj, opts) self.core = core_obj self.debugger = core_obj.debugger self.continue_running = False # True if we should leave command loop self.event2short = dict(EVENT2SHORT) self.event2short["signal"] = "?!" self.event2short["brkpt"] = "xx" self.optional_modules = () # command argument string. Is like current_command, but the part # after cmd_name has been removed. self.cmd_argstr = "" # command name before alias or macro resolution self.cmd_name = "" self.cmd_queue = [] # Queued debugger commands self.completer = lambda text, state: Mcomplete.completer( self, text, state) self.current_command = "" # Current command getting run self.debug_nest = 1 self.display_mgr = Mdisplay.DisplayMgr() self.intf = core_obj.debugger.intf self.last_command = None # Initially a no-op self.precmd_hooks = [] # FIXME: can we adjust this to also show the instruction? self.location = lambda: self self.preloop_hooks = [] self.postcmd_hooks = [] # Note: prompt_str's value set below isn't used. It is # computed dynamically. The value is suggestive of what it # looks like. self.prompt_str = "(trepan-xpy) " # Stop only if line/file is different from last time self.different_line = None # These values updated on entry. Set initial values. self.curframe = None self.event = None self.event_arg = None self.frame = None self.list_lineno = 0 # last list number used in "list" self.list_offset = -1 # last list number used in "disassemble" self.list_obj = None self.list_filename = None # last filename used in list self.list_orig_lineno = 0 # line number of frame or exception on setup self.list_filename = None # filename of frame or exception on setup self.macros = {} # Debugger Macros # Create a custom safe Repr instance and increase its maxstring. # The default of 30 truncates error messages too easily. self._repr = Repr() self._repr.maxstring = 100 self._repr.maxother = 60 self._repr.maxset = 10 self._repr.maxfrozen = 10 self._repr.array = 10 self.stack = [] self.thread_name = None self.frame_thread_name = None get_option = lambda key: option_set(opts, key, DEFAULT_PROC_OPTS) initfile_list = get_option("initfile_list") for init_cmdfile in initfile_list: self.queue_startfile(init_cmdfile) # FIXME: This doesn't work # # Delegate functions here: # self.cmdproc = CommandProcessor(self) # for method in ( # "_saferepr", # "add_preloop_hook", # "defaultFile", # "eval", # "exec_line", # "forget", # "get_an_int", # "get_int_noerr", # "getval", # "ok_for_running", # "process_commands", # "queue_startfile", # "remove_preloop_hook", # "setup", # "undefined_cmd", # "read_history_file", # "write_history_file", # ): # setattr(self, method, getattr(cmdproc, method)) # Remove trepan3k commands which aren't valid here, and those specific to trepan-xpy remove_commands = ( "continue", "finish", "next", "quit", "set", "step", ) new_instances = [] for cmd in self.cmd_instances: if cmd.name in remove_commands: del self.commands[cmd.name] else: new_instances.append(cmd) pass pass self.cmd_instances = new_instances new_commands = self._update_commands() for new_command in new_commands: self.commands[new_command.name] = new_command self.cmd_instances += new_commands self._populate_cmd_lists() if self.debugger.settings["autopc"]: self.commands["set"].run(["set", "autopc"]) return
def __init__(self, core_obj, opts=None): get_option = lambda key: \ Mmisc.option_set(opts, key, DEFAULT_PROC_OPTS) Mprocessor.Processor.__init__(self, core_obj) self.continue_running = False # True if we should leave command loop self.event2short = dict(EVENT2SHORT) self.event2short['signal'] = '?!' self.event2short['brkpt'] = 'xx' self.optional_modules = ('ipython', 'bpy') self.cmd_instances = self._populate_commands() # command argument string. Is like current_command, but the part # after cmd_name has been removed. self.cmd_argstr = '' # command name before alias or macro resolution self.cmd_name = '' self.cmd_queue = [] # Queued debugger commands self.completer = lambda text, state: \ Mcomplete.completer(self, text, state) self.current_command = '' # Current command getting run self.debug_nest = 1 self.display_mgr = Mdisplay.DisplayMgr() self.intf = core_obj.debugger.intf self.last_command = None # Initially a no-op self.precmd_hooks = [] self.location = lambda: print_location(self) self.preloop_hooks = [] self.postcmd_hooks = [] self._populate_cmd_lists() self.prompt_str = '(trepan3k) ' # Stop only if line/file is different from last time self.different_line = None # These values updated on entry. Set initial values. self.curframe = None self.event = None self.event_arg = None self.frame = None self.list_lineno = 0 # last list number used in "list" self.list_filename = None # last filename used in list self.macros = {} # Debugger Macros # Create a custom safe Repr instance and increase its maxstring. # The default of 30 truncates error messages too easily. self._repr = Repr() self._repr.maxstring = 100 self._repr.maxother = 60 self._repr.maxset = 10 self._repr.maxfrozen = 10 self._repr.array = 10 self.stack = [] self.thread_name = None self.frame_thread_name = None initfile_list = get_option('initfile_list') for init_cmdfile in initfile_list: self.queue_startfile(init_cmdfile) return
from functools import wraps from reprlib import Repr import inspect from flask import request, g from flask_logger_decorator.config import config from flask_logger_decorator.logger import debug __r = Repr() __r.maxarray = __r.maxarray * 10 __r.maxdict = __r.maxdict * 10 __r.maxstring = __r.maxstring * 10 def request_tracing(fn): """ A decorator to tracing request. """ @wraps(fn) def wrapper(*args, **kwargs): tracing_request(fn, *args, **kwargs) return fn(*args, **kwargs) return wrapper def tracing_request(fn, *args, **kwargs): function_args = ' '.join(_get_fn_args(fn, *args, **kwargs)) trace_info = ' '.join(_get_fn_extra_info(fn)) func_msg = 'func_name:{} func_args:{} trace_info:{}'.format( fn.__name__, function_args, trace_info) request_msg = get_request_trace_info()
import linecache import bdb import re try: from reprlib import Repr except ImportError: from reprlib import Repr from pycopia import IO from pycopia import UI from pycopia import CLI # Create a custom safe Repr instance and increase its maxstring. # The default of 30 truncates error messages too easily. _repr = Repr() _repr.maxstring = 200 _repr.maxother = 50 _saferepr = _repr.repr DebuggerQuit = bdb.BdbQuit def find_function(funcname, filename): cre = re.compile(r'def\s+%s\s*[(]' % funcname) try: fp = open(filename) except IOError: return None # consumer of this info expects the first line to be 1 lineno = 1 answer = None
def __init__(self, core_obj, opts=None): get_option = lambda key: Mmisc.option_set(opts, key, DEFAULT_PROC_OPTS) super().__init__(core_obj) self.continue_running = False # True if we should leave command loop self.event2short = dict(EVENT2SHORT) self.event2short["signal"] = "?!" self.event2short["brkpt"] = "xx" self.optional_modules = ("ipython", "bpy") self.cmd_instances = self._populate_commands() # command argument string. Is like current_command, but the part # after cmd_name has been removed. self.cmd_argstr = "" # command name before alias or macro resolution self.cmd_name = "" self.cmd_queue = [] # Queued debugger commands self.completer = lambda text, state: Mcomplete.completer( self, text, state) self.current_command = "" # Current command getting run self.debug_nest = 1 self.display_mgr = Mdisplay.DisplayMgr() self.intf = core_obj.debugger.intf self.last_command = None # Initially a no-op self.precmd_hooks = [] self.location = lambda: print_location(self) self.preloop_hooks = [] self.postcmd_hooks = [] self.remap_file_re = None self._populate_cmd_lists() # Note: prompt_str's value set below isn't used. It is # computed dynamically. The value is suggestive of what it # looks like. self.prompt_str = "(trepan3k) " # Stop only if line/file is different from last time self.different_line = None # These values updated on entry. Set initial values. self.curframe = None self.event = None self.event_arg = None self.frame = None self.list_lineno = 0 # last list number used in "list" self.list_offset = -1 # last list number used in "disassemble" self.list_obj = None self.list_filename = None # last filename used in list self.list_orig_lineno = 0 # line number of frame or exception on setup self.list_filename = None # filename of frame or exception on setup self.macros = {} # Debugger Macros # Create a custom safe Repr instance and increase its maxstring. # The default of 30 truncates error messages too easily. self._repr = Repr() self._repr.maxstring = 100 self._repr.maxother = 60 self._repr.maxset = 10 self._repr.maxfrozen = 10 self._repr.array = 10 self.stack = [] self.thread_name = None self.frame_thread_name = None initfile_list = get_option("initfile_list") for init_cmdfile in initfile_list: self.queue_startfile(init_cmdfile) return
def __init__(self, identifier, client=None): super().__init__(identifier) self._client = client self._repr = Repr() self._repr.maxstring = 40 self._remote_ = _RemoteFile(self)
def __init__(self, primitive, hot_reload=False, required=None): self._logger = logging.getLogger('{}.{}'.format( __name__, type(self).__name__)) self._hot_reload = hot_reload self._variables = None self.__template = None # we have to take care of 4 possible cases and make sure we have # all we need to initialize the template, this includes having # access to the raw template (str) and a way to re-initialize # the jinja.environment.loader object (to make sure copies and # pickles work) if isinstance(primitive, Path): self._path = primitive self.__raw = primitive.read_text() self._loader_init = None elif isinstance(primitive, str): self._path = None self.__raw = primitive self._loader_init = None elif isinstance(primitive, Template): # NOTE: primitive.filename will be '<template>' if Template was # loaded from a string path = Path(primitive.filename) if primitive.environment.undefined != StrictUndefined: raise ValueError('Placeholder can only be initialized ' 'from jinja2.Templates whose undefined ' 'parameter is set to ' 'jinja2.StrictUndefined, set it explicitely ' 'either in the Template or Environment ' 'constructors') # we cannot get the raw template on this case, raise error # check '<template>' first, because Path('<template>').exists() # breaks on windows if primitive.filename == '<template>' or not path.exists(): raise ValueError( 'Could not load raw source from ' 'jinja2.Template. This usually happens ' 'when the placeholder is initialised with a ' 'jinja.Template which was initialized with ' 'a string. Only jinja2.Templates loaded from ' 'the filesystem are supported. Use ' 'ploomber.SourceLoader or jinja\'s ' 'FileSystemLoader/PackageLoader to fix ' 'this issue, if you want to create a template from ' 'a string pass it directly ' 'Placeholder("some {{placeholder}}")') self._path = path self.__raw = path.read_text() self._loader_init = _make_loader_init(primitive.environment.loader) # SourceLoader returns Placeholder objects, which could inadvertedly # be passed to another Placeholder constructor when instantiating # a source object, since they sometimes use placeholders # make sure this case is covered elif isinstance(primitive, Placeholder): self._path = primitive.path self.__raw = primitive._raw self._loader_init = _make_loader_init( primitive._template.environment.loader) else: raise TypeError('{} must be initialized with a Template, ' 'Placeholder, pathlib.Path or str, ' 'got {} instead'.format( type(self).__name__, type(primitive).__name__)) if self._path is None and hot_reload: raise ValueError('hot_reload only works when Placeholder is ' 'initialized from a file') # TODO: remove self.needs_render = self._needs_render() self._str = None if self.needs_render else self._raw self._repr = Repr() self._repr.maxstring = 40 if required: self._validate_required(required)