def to_dict(self, *args, **kwargs):
"""Creates dict representaion of config, recaptcha_forms are converted so angular models can
easily use it"""
repr_dict = super(Config, self).to_dict(*args, **kwargs)
repr_dict['recaptcha_forms'] = util.list_to_dict(
repr_dict['recaptcha_forms'])
return repr_dict
def find_all_equilibria(self):
"""Attempt to find all nash equilibria for a game. Returns a list of dicts, keys are symbols, values are probabilities (numbers or symbols."""
result = []
action_shape = self.payoffs.shape[:-1]
possible_actions = [
list(range(player_actions)) for player_actions in action_shape
]
#print(possible_actions)
# we should first eliminate dominated strategies. we will skip that step for now
for acombo in iter_subset_combos(possible_actions):
if is_pure(acombo):
# print(acombo)
profile = [[[player_action[0], 1]] for player_action in acombo]
if not self.is_dominated(profile):
profile_dict = [
list_to_dict(player_profile)
for player_profile in profile
]
result.append(profile_dict)
else:
#print("checking combo", acombo)
combo_solutions = self._get_indifference_probs(acombo)
for asol in combo_solutions:
# print('asol', asol)
#listy = [dict_to_list(psol) for psol in asol]
#print('psol', psol)
carnate = self._carnate_profile(asol)
listy = [dict_to_list(elm) for elm in carnate]
if not self.is_dominated(listy):
result.append(asol)
return result
def add_tld(self, tld):
"""add a new tld to the list"""
tld = tld.lower()
parts = tld.split('.')
parts.reverse()
update = list_to_dict(parts)
self.tldtree = dict_update(self.tldtree, update)
def add_tld(self, tld):
"""add a new tld to the list"""
tld = tld.lower()
parts = tld.split('.')
parts.reverse()
update = list_to_dict(parts)
self.tldtree = dict_update(self.tldtree, update)
async def patch_plano_trabalho(
cod_plano: str,
plano_trabalho: schemas.PlanoTrabalhoUpdateSchema,
db: Session = Depends(get_db),
token: str = Depends(oauth2_scheme),
user: User = Depends(fastapi_users.current_user(active=True))
):
"Atualiza um plano de trabalho existente nos campos informados."
# Validações da entrada conforme regras de negócio
if cod_plano != plano_trabalho.cod_plano:
raise HTTPException(
status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="Parâmetro cod_plano diferente do conteúdo do JSON")
db_plano_trabalho = crud.get_plano_trabalho(db, user.cod_unidade,
cod_plano)
if db_plano_trabalho is None:
raise HTTPException(
status.HTTP_404_NOT_FOUND,
detail="Só é possível aplicar PATCH em um recurso"+
" existente.")
if db_plano_trabalho.cod_unidade != user.cod_unidade:
raise HTTPException(
status.HTTP_403_FORBIDDEN,
detail="Usuário não pode alterar Plano de Trabalho"+
" de outra unidade.")
# atualiza os atributos, exceto atividades
merged_plano_trabalho = util.sa_obj_to_dict(db_plano_trabalho)
patch_plano_trabalho = plano_trabalho.dict(exclude_unset=True)
if patch_plano_trabalho.get("atividades", None):
del patch_plano_trabalho["atividades"]
merged_plano_trabalho.update(patch_plano_trabalho)
# atualiza as atividades
# traz a lista de atividades que está no banco
db_atividades = util.list_to_dict(
[
util.sa_obj_to_dict(atividade)
for atividade in getattr(db_plano_trabalho, "atividades", list())
],
"id_atividade"
)
# cada atividade a ser modificada
patch_atividades = util.list_to_dict(
plano_trabalho.dict(exclude_unset=True).get("atividades", list()),
"id_atividade"
)
merged_atividades = util.merge_dicts(db_atividades, patch_atividades)
merged_plano_trabalho["atividades"] = util.dict_to_list(
merged_atividades,
"id_atividade"
)
# tenta validar o esquema
# para validar o esquema, é necessário ter o atributo atividades,
# mesmo que seja uma lista vazia
if merged_plano_trabalho.get("atividades", None) is None:
merged_plano_trabalho["atividades"] = []
# valida o esquema do plano de trabalho atualizado
try:
merged_schema = schemas.PlanoTrabalhoSchema(**merged_plano_trabalho)
except ValidationError as e:
raise HTTPException(
status.HTTP_422_UNPROCESSABLE_ENTITY,
detail=json.loads(e.json())
)
crud.update_plano_trabalho(db, merged_schema, user.cod_unidade)
return merged_plano_trabalho
def extract_feature(scenario):
n_layer = scenario['layer']
target_directory = get_feature_array_scenario_path(scenario['codename'])
create_directory(target_directory)
array_px_files = get_files(target_directory)
# Jangan lakukan ekstraksi fitur ulang
if len(array_px_files) >= 50:
print "feature "+scenario['codename']+" is already existed. Abort mission"
return
# Ambil semua file gambar
image_filenames = get_files(directory_path)
counter = 0
for image_filename in image_filenames:
# print "Extracting %s:%s"%(counter, position_file)
counter += 1
a = read_image(image_filename)
gt = read_groundtruth_image(image_filename)
# konversi menjadi binary image
gt = gt > 20
gt = gt.astype(int)
image_shape = a.shape
image_row = image_shape[0]
image_col = image_shape[1]
image_layer = image_shape[2]
im_slic = []
im_disp = []
im_bound = []
features = []
# Extract superpixel feature for each layer
for i in range(n_layer):
im_slic.append(slic(a, compactness=scenario['settings'][i]['compactness'],
n_segments=scenario['settings'][i]['segment'],
sigma=scenario['settings'][i]['sigma']))
im_slic[i] = label(im_slic[i], neighbors=8)
im_disp.append(np.copy(im_slic[i]))
im_bound.append(mark_boundaries(a, im_slic[i]))
temp_feature = regionprops(im_slic[i], intensity_image=rgb2gray(a))
features.append(list_to_dict(temp_feature))
X_indiv = []
for im_row in range(image_row):
for im_col in range(image_col):
# extract position and corresponding labels
posLabel = gt[im_row, im_col]
current_labels = []
# validate labels. 0 label is not allowed. causing not exists error
valid_position = True
for i in range(n_layer):
current_level_labels = im_slic[i][im_row, im_col]
current_labels.append(current_level_labels)
if current_level_labels == 0:
valid_position = False
break
if not valid_position:
continue
# concat all layer properties
x_entry = []
for i in range(n_layer):
feat = features[i][current_labels[i]]
for att in attributes:
if att == 'bbox':
(min_row, min_col, max_row, max_col) = feat['bbox']
x_entry.append(min_row)
x_entry.append(min_col)
x_entry.append(max_row)
x_entry.append(max_col)
else:
x_entry.append(feat[att])
if posLabel == 1:
mark(current_labels[i], 1, im_slic[i], im_disp[i])
x_entry.append(posLabel)
X_indiv.append(x_entry)
f = get_feature_array_file(scenario['codename'], image_filename, mode='w')
X_indiv = np.array(X_indiv)
X_indiv_u = unique_rows(X_indiv)
np.save(f, X_indiv_u)
f.close()
def to_dict(self, *args, **kwargs):
"""Creates dict representaion of config, recaptcha_forms are converted so angular models can
easily use it"""
repr_dict = super(Config, self).to_dict(*args, **kwargs)
repr_dict["recaptcha_forms"] = util.list_to_dict(repr_dict["recaptcha_forms"])
return repr_dict
def test_list_to_dict(input_pt: dict):
"""Testa a transformação de lista em dicionário.
"""
atividades = util.list_to_dict(input_pt["atividades"], "id_atividade")
assert atividades == atividades_dict
