def __setattr__(
self,
name : str,
valueProxy : (types.LambdaType, types.FunctionType, types.MethodType) ) \
-> None:
cls = self.__class__
if builtins.getattr(self.__Func, name, self.__Func) is self.__Func:
builtins.setattr(self.__Func, name, valueProxy())
def load_config(self):
try:
with open("settings.json", "r") as settings_file:
settings_json = load(settings_file)
for setting, value in settings_json.items():
setattr(self, setting, value)
return True
except Exception as e:
print(e)
return False
def standardize(self, orig, std_vals):
"""
Inputs: orig- the un-standardized values
std_vals- the attribue name for the standardized vals
Overrides the Variable class standardize to align with
a discrete uniform distribution.
"""
setattr(self, std_vals, getattr(self, orig))
return getattr(self, std_vals)
def standardize(self, orig, std_vals):
"""
Inputs: orig- the un-standardized values
std_vals- the attribue name for the standardized vals
Overrides the Variable class standardize to align with
a discrete poisson distribution.
"""
standardized = getattr(self, orig) - self.interval_low
setattr(self, std_vals, standardized)
return standardized
def standardize(self, orig, std_vals):
"""
Inputs: orig- the un-standardized values
std_vals- the attribue name for the standardized vals
Overrides the Variable class standardize to align with
a discrete Hypergeomeric distribution.
"""
original = getattr(self, orig)
standard = original - self.interval_shift
setattr(self, std_vals, standard)
return getattr(self, std_vals)
def check_num_string(self):
"""
Searches to replace sring 'pi' with its numpy equivalent in any of the
values that might contain it.
"""
lambd = getattr(self, 'lambda')
if isinstance(self.interval_low, str) and 'pi' in self.interval_low:
self.interval_low = float(
self.interval_low.replace('pi', str(np.pi)))
if isinstance(lambd, str) and 'pi' in lambd:
setattr(self, 'lambda', float(lambd.replace('pi', str(np.pi))))
def __init__(self,
*args,
indicator=None,
content=None,
score=1.0,
source=None,
**kwargs):
self.indicator = indicator
self.content = content
self.score = score
self.source = source
for (k, v) in kwargs.items():
setattr(self, k, v)
def update(self, config, write=True):
fields = ["url_pattern", "token", "url", "buffer_name", "period_s"]
for k, v in config.items():
if k in fields:
setattr(self, k, v)
print(f"setting attr {k} to {v}")
self.url = config.get("url")
if self.url_pattern is not None and self.token is not None:
url_frompattern = self.url_pattern.format(self.token)
self.logger.info(f"url from pattern: {url_frompattern}")
self.url = url_frompattern
self.logger.info(f"have set post url to {self.url}")
if write:
return self.write()
return config
def standardize(self, orig, std_vals):
"""
Inputs: orig- the un-standardized values
std_vals- the attribue name for the standardized vals
Overrides the Variable class standardize to align with
a discrete uniform distribution.
"""
original = getattr(self, orig)
rng = self.interval_high - self.interval_low
mean = rng / 2 + self.interval_low
stdev = rng / 2
standard = (original[:] - mean) / stdev
setattr(self, std_vals, standard)
return getattr(self, std_vals)
def __init__(self,
lambd,
interval_low=0,
order=2,
type='aleatory',
name='',
number=0):
if not lambd >= 0:
raise VariableInputError(
'PoissonVariable lambd must be greater than 0.')
self.interval_low = interval_low
self.order = order
self.type = UncertaintyType.from_name(type)
self.name = f'x{number}' if name == '' else name
setattr(self, 'lambda', lambd)
self.var_str = f'x{number}'
self.x = symbols(self.var_str)
self.distribution = Distribution.POISSON
self.find_high_lim()
self.get_probability_density_func()
self.check_num_string()
self.recursive_var_basis(self.x_values, self.probabilities, self.order)
self.create_norm_sq(self.x_values, self.probabilities)
self.low_approx = np.min(self.x_values)
self.high_approx = np.max(self.x_values)
self.std_bounds = (self.low_approx, self.high_approx)
self.check_bounds()
if self.type == UncertaintyType.EPISTEMIC:
warn(
'The PoissonVariable is usually not epistemic. For an epistemic '
'variable, consider using the continuous uniform '
'distribution with type epistemic.')
showwarning = _warn
def addClassData(cls) -> None:
# Bring into local scope.
# For use with locals().
clsName
cls.__EnumConstants = []
lastEnumConstValue = -1
for attr in dxnry.items():
attrName = attr[0]
attrObj = attr[1]
if not mcls.__isPythonSpecialName(attrName):
enumConst = cls()
enumConst.Name = \
'{clsName}.{attrName}'.format(**locals())
if type(attrObj) == int:
enumConst.Value = attrObj
else:
enumConst.Value = lastEnumConstValue + 1
lastEnumConstValue = enumConst.Value
builtins.setattr(cls, attrName, enumConst)
cls.__EnumConstants.append(enumConst)
def useful_variables(self):
names = []
if f"{self.module}_{self.event}" in self.args_by_module_and_event:
names = self.args_by_module_and_event[
f"{self.module}_{self.event}"]
elif self.event in self.args_by_event:
names = self.args_by_event[self.event]
elif self.module in self.args_by_module:
names = self.args_by_module[self.module]
if names:
[
setattr(self, name, self.variables[i])
for (i, name) in enumerate(names)
]
def __init__(self, **kwargs):
self.Context = kwargs['Context']
self.dataset_name = kwargs['dataset_name']
self.description = kwargs['description']
self.configurations_id = kwargs['configurations_id']
self.generated_files_base_name = kwargs['configurations_id'] + '.'
self.display_visuals = kwargs['display_visuals']
self.balance_data = kwargs['balance_data']
self.reduce_dimensionality = kwargs['reduce_dimensionality']
self.normalize = kwargs['normalize']
self.seed_count = kwargs['seed_count']
self.mode = kwargs['mode']
self.positive_classes = kwargs['positive_classes']
self.cv_fold = kwargs['cv_fold']
self.grid_search = kwargs['grid_search']
self.grid_inner_cv_fold = kwargs['grid_inner_cv_fold']
OptionalArguments = {'display_logs': True, 'binarize': True}
for key, value in OptionalArguments.items():
setattr(self, key, kwargs[key] if key in kwargs else value)
self.save_items_path = os.path.join(Config.framework_instance_generated_classification_path, self.dataset_name)
self.save_log_items_path = os.path.join(Config.framework_instance_generated_logs_path, self.dataset_name)
def read_var_vals(self, matrix_file, attr):
"""
Inputs: matrix_file- the file to be read from
attr- the attribute of the variables to set this data to
Reads the values in the file and sets them to the specified
attribute for each variable.
"""
try:
with open(matrix_file, 'r') as fi:
dat = fi.readlines()
line_count = len(dat)
var_count = len(self.var_list)
ind = 0
for i in range(var_count):
arr = np.zeros(line_count)
setattr(self.var_list[i], attr, arr)
for line in dat:
if '#' not in line and line != '\n':
curr_line = line.replace(',', '\t').split()
for i in range(var_count):
attribute = getattr(self.var_list[i], attr)
attribute[ind] = float(curr_line[i])
ind += 1
for i in range(var_count):
setattr(self.var_list[i], attr,
getattr(self.var_list[i], attr)[0:ind])
except FileNotFoundError:
pass
def get(self):
message = Message()
setattr(message, 'link', request.url)
try:
setattr(message, 'message', "Success")
galeryDao = GaleryDao()
result = None
if 'id_album' in request.args:
id_album = int(request.args['id_album'])
logger.info(id_album)
result = galeryDao.GetGaleryByAlbum(id_album)
else:
result = galeryDao.GetAllGaleries()
logger.info(result)
if result is None:
setattr(message, 'code', 404)
setattr(message, 'developerMessage', "Data is empty")
setattr(message, 'data', None)
else:
setattr(message, 'code', 200)
setattr(message, 'developerMessage', None)
setattr(message, 'data', result)
logger.info(message.GetResponse())
except Exception as e:
logger.error(e)
setattr(message, 'code', 500)
setattr(message, 'message', "Fail")
setattr(message, 'developerMessage', str(e))
setattr(message, 'data', None)
res = message.GetResponse()
return jsonify(res)
def setattr(attr, value, obj):
__builtin__.setattr(obj, attr, value)
return obj
config = Configurable()
settingName = 'settingName'
# <yes> <report> PYTHON_INJECTION_RESOURCE 36f5ed
config.setSetting(settingName)
import builtins
file = 'path/to/file'
# <yes> <report> PYTHON_INJECTION_RESOURCE 54972e
file(file)
# <yes> <report> PYTHON_INJECTION_RESOURCE 54972e
open(file)
# <yes> <report> PYTHON_INJECTION_RESOURCE 156b64
builtins.open(file)
# <yes> <report> PYTHON_INJECTION_RESOURCE 156b64
builtins.setattr(foo, bar, value)
from django.core.mail import EmailMessage
img_data = 'images/img'
message = EmailMessage('Title', 'Body', '*****@*****.**')
# <yes> <report> PYTHON_INJECTION_RESOURCE 0afea5
message.attach('design.png', img_data, 'image/png')
import shelve
# <yes> <report> PYTHON_INJECTION_RESOURCE 55142c
shelve.open(file)
import tarfile
import zipfile
# <yes> <report> PYTHON_INJECTION_RESOURCE 62ec63
tarfile.open(file)
def __call__(self, parser, namespace, values, option_string=None):
from builtins import getattr, setattr
items = getattr(namespace, self.dest) or []
items.extend(values)
setattr(namespace, self.dest, items)
def setattr(obj, name, value):
'''Replacement for the built-in
:func:`setattr() <python:setattr>` function.'''
builtins.setattr(obj, name, value)
def setattr(value, attr, obj):
"""
Like setattr, but with the arguments flipped.
"""
return _builtins.setattr(obj, attr, value)
lambda *args, **kwargs: builtins.reversed(*args, **kwargs),
builtins.reversed)
reversed._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.reversed)(*args, **kwargs),
builtins.reversed)
round = functools.update_wrapper(
lambda *args, **kwargs: builtins.round(*args, **kwargs), builtins.round)
round._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.round)(*args, **kwargs),
builtins.round)
set = functools.update_wrapper(
lambda *args, **kwargs: builtins.set(*args, **kwargs), builtins.set)
set._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.set)(*args, **kwargs), builtins.set)
setattr = functools.update_wrapper(
lambda *args, **kwargs: builtins.setattr(*args, **kwargs),
builtins.setattr)
setattr._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.setattr)(*args, **kwargs),
builtins.setattr)
slice = functools.update_wrapper(
lambda *args, **kwargs: builtins.slice(*args, **kwargs), builtins.slice)
slice._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.slice)(*args, **kwargs),
builtins.slice)
sorted = functools.update_wrapper(
lambda *args, **kwargs: builtins.sorted(*args, **kwargs), builtins.sorted)
sorted._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.sorted)(*args, **kwargs),
builtins.sorted)
str = functools.update_wrapper(
def get(self):
message = Message()
setattr(message, 'link', request.url)
try:
setattr(message, 'message', "Success")
pageDao = PageDao()
result = pageDao.GetAllPages()
if result is None:
setattr(message, 'code', 404)
setattr(message, 'developerMessage', "Data is empty")
setattr(message, 'data', None)
else:
setattr(message, 'code', 200)
setattr(message, 'developerMessage', None)
setattr(message, 'data', result)
logger.info(message.GetResponse())
except Exception as e:
logger.error(e)
setattr(message, 'code', 500)
setattr(message, 'message', "Fail")
setattr(message, 'developerMessage', str(e))
setattr(message, 'data', None)
res = message.GetResponse()
return jsonify(res)
def get(self):
message = Message()
setattr(message, 'link', request.url)
try:
setattr(message, 'message', "Success")
beritaDao = BeritaDao()
result = None
if 'id_berita' in request.args:
id_berita = int(request.args['id_berita'])
logger.info(id_berita)
result = beritaDao.GetBeritaById(id_berita)
logger.info(result)
elif 'id_kategori' in request.args:
id_kategori = int(request.args['id_kategori'])
logger.info(id_kategori)
result = beritaDao.GetBeritaByKategori(id_kategori)
elif 'limit' in request.args:
limit = int(request.args['limit'])
logger.info(limit)
result = beritaDao.GetBeritaLimit(limit)
else:
result = beritaDao.GetAllBerita()
if result is None:
setattr(message, 'code', 404)
setattr(message, 'developerMessage', "Data not found")
setattr(message, 'data', None)
else:
setattr(message, 'code', 200)
setattr(message, 'developerMessage', None)
setattr(message, 'data', result)
logger.info(message.GetResponse())
except Exception as e:
logger.error(e)
setattr(message, 'code', 500)
setattr(message, 'message', "Fail")
setattr(message, 'developerMessage', str(e))
setattr(message, 'data', None)
res = message.GetResponse()
return jsonify(res)
def setattr(obj, name, value):
builtins.setattr(obj, name, value)
return Star
def get(self):
message = Message()
setattr(message, 'link', request.url)
try:
setattr(message, 'message', "Success")
beritaDao = BeritaDao()
result = beritaDao.GetBeritaPopular()
if result is None:
setattr(message, 'code', 404)
setattr(message, 'developerMessage', "Data not found")
setattr(message, 'data', None)
else:
setattr(message, 'code', 200)
setattr(message, 'developerMessage', None)
setattr(message, 'data', result)
logger.info(message.GetResponse())
except Exception as e:
logger.error(e)
setattr(message, 'code', 500)
setattr(message, 'message', "Fail")
setattr(message, 'developerMessage', str(e))
setattr(message, 'data', None)
res = message.GetResponse()
return jsonify(res)
def _uno_struct__setattr__(self, name, value):
return __builtin__.setattr(self.__dict__["value"], name, value)
def get(self):
message = Message()
setattr(message, 'link', request.url)
try:
setattr(message, 'message', "Success")
agendaDao = AgendaDao()
result = None
if 'id_agenda' in request.args:
id_agenda = int(request.args['id_agenda'])
logger.info(id_agenda)
result = agendaDao.GetAgendaById(id_agenda)
elif 'limit' in request.args:
limit = int(request.args['limit'])
logger.info(limit)
result = agendaDao.GetAgendaLimit(limit)
else:
result = agendaDao.GetAllAgenda()
logger.info(result)
if result is None:
setattr(message,'code',404)
setattr(message, 'developerMessage', "Data is empty")
setattr(message, 'data', None)
else:
setattr(message,'code',200)
setattr(message, 'developerMessage', None)
setattr(message, 'data', result)
logger.info(message.GetResponse())
except Exception as e:
logger.error(e)
setattr(message,'code',500)
setattr(message, 'message', "Fail")
setattr(message, 'developerMessage', str(e))
setattr(message, 'data', None)
res = message.GetResponse()
return jsonify(res)
def __setattr__(self, name, value):
if name == '_state':
super().__setattr__(name, value)
else:
setattr(self._state, name, value)
def __setattr__(self, name, value):
print("__setattr__ >>> 当该类属性被设置时触发");
super().__setattr__(name, value);
def __delattr__(self, name):
print("__delattr__ >>> 当该类属性被删除时触发");
super().__delattr__(name);
def __getattr__(self, name):
print("__getattr__ >>> 当用户视图获取一个该类不存在的属性时触发");
c = C();
# 获取属性 and 获取一个不存在的属性
c.x;
print();
# 设置属性
c.x = 1;
setattr(c, "y", 500); ## 内建函数BIF
print();
# 删除属性
del c.x;
delattr(c, "y"); ## 内建函数BIF
print();
