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)
