metadata
dict | text
stringlengths 60
3.49M
|
|---|---|
{
"source": "980302306/FewShotGAN",
"score": 2
} |
#### File: FewShotGAN/lib/utils.py
```python
import os
import numpy as np
import tensorflow as tf
import math
from PIL import Image
#import pdb
F = tf.app.flags.FLAGS
"""
Save tensorflow model
Parameters:
* checkpoint_dir - name of the directory where model is to be saved
* sess - current tensorflow session
* saver - tensorflow saver
"""
def save_model(checkpoint_dir, sess, saver):
model_name = "model.ckpt"
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
saver.save(sess, os.path.join(checkpoint_dir, model_name))
"""
Load tensorflow model
Parameters:
* checkpoint_dir - name of the directory where model is to be loaded from
* sess - current tensorflow session
* saver - tensorflow saver
Returns: True if the model loaded successfully, else False
"""
def load_model(checkpoint_dir, sess, saver):
print(" [*] Reading checkpoints...")
ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
if ckpt and ckpt.model_checkpoint_path:
ckpt_name = os.path.basename(ckpt.model_checkpoint_path)
saver.restore(sess, os.path.join(checkpoint_dir, ckpt_name))
return True
else:
return False
"""
To recompose an array of 3D images from patches
"""
def recompose3D_overlap(preds, img_h, img_w, img_d, stride_h, stride_w, stride_d):
patch_h = preds.shape[1]
patch_w = preds.shape[2]
patch_d = preds.shape[3]
N_patches_h = (img_h-patch_h)//stride_h+1
N_patches_w = (img_w-patch_w)//stride_w+1
N_patches_d = (img_d-patch_d)//stride_d+1
N_patches_img = N_patches_h * N_patches_w * N_patches_d
print("N_patches_h: " ,N_patches_h)
print("N_patches_w: " ,N_patches_w)
print("N_patches_d: " ,N_patches_d)
print("N_patches_img: ",N_patches_img)
assert(preds.shape[0]%N_patches_img==0)
N_full_imgs = preds.shape[0]//N_patches_img
print("According to the dimension inserted, there are " \
+str(N_full_imgs) +" full images (of " +str(img_h)+"x" +str(img_w)+"x" +str(img_d) +" each)")
# itialize to zero mega array with sum of Probabilities
raw_pred_martrix = np.zeros((N_full_imgs,img_h,img_w,img_d))
raw_sum = np.zeros((N_full_imgs,img_h,img_w,img_d))
final_matrix = np.zeros((N_full_imgs,img_h,img_w,img_d),dtype='uint16')
k = 0
# iterator over all the patches
for i in range(N_full_imgs):
for h in range((img_h-patch_h)//stride_h+1):
for w in range((img_w-patch_w)//stride_w+1):
for d in range((img_d-patch_d)//stride_d+1):
raw_pred_martrix[i,h*stride_h:(h*stride_h)+patch_h,\
w*stride_w:(w*stride_w)+patch_w,\
d*stride_d:(d*stride_d)+patch_d]+=preds[k]
raw_sum[i,h*stride_h:(h*stride_h)+patch_h,\
w*stride_w:(w*stride_w)+patch_w,\
d*stride_d:(d*stride_d)+patch_d]+=1.0
k+=1
assert(k==preds.shape[0])
#To check for non zero sum matrix
assert(np.min(raw_sum)>=1.0)
final_matrix = np.around(raw_pred_martrix/raw_sum)
return final_matrix
#functions below are added by liuhuaqing 2019-07-15
def make_grid(tensor, nrow=8, padding=2,
normalize=False, scale_each=False):
"""Code based on https://github.com/pytorch/vision/blob/master/torchvision/utils.py"""
nmaps = tensor.shape[0]
xmaps = min(nrow, nmaps)
ymaps = int(math.ceil(float(nmaps) / xmaps))
height, width = int(tensor.shape[1] + padding), int(tensor.shape[2] + padding)
grid = np.zeros([height * ymaps + 1 + padding // 2, width * xmaps + 1 + padding // 2], dtype=np.uint8)
k = 0
for y in range(ymaps):
for x in range(xmaps):
if k >= nmaps:
break
h, h_width = y * height + 1 + padding // 2, height - padding
w, w_width = x * width + 1 + padding // 2, width - padding
grid[h:h+h_width, w:w+w_width] = tensor[k]
k = k + 1
return grid
def save_image(tensor, filename, nrow=8, padding=2,
normalize=False, scale_each=False):
ndarr = make_grid(tensor, nrow=nrow, padding=padding,
normalize=normalize, scale_each=scale_each)
im = Image.fromarray(ndarr)
im.save(filename)
# 语义分割准确率的定义和计算，参考：https://blog.csdn.net/majinlei121/article/details/78965435
def fast_hist(a, b, n):
k = (a >= 0) & (a < n) #正常情况下全是True
return np.bincount(n * a[k].astype(int) + b[k], minlength=n**2).reshape(n, n)#np.bincount 用于统计数组中（从小到大）给取值出现的次数
def Hist(a,b,n):
hist = fast_hist(a,b,n)
return hist
def pixelAccuracy(trueMask,predMask,n_cls):
hist = Hist(trueMask,predMask,n_cls)
PA = np.diag(hist).sum() / hist.sum()
return PA
def MeanPixelAccuracy(trueMask,predMask,n_cls):
#epsilon = 1
hist = Hist(trueMask,predMask,n_cls)
PAs = np.diag(hist) / hist.sum(1)
return PAs
def IntersectionoverUnion(trueMask,predMask,n_cls):
#epsilon = 1
hist = Hist(trueMask,predMask,n_cls)
IoUs = np.diag(hist) / (hist.sum(1) + hist.sum(0) - np.diag(hist))
return IoUs
def DiceScore(trueMask,predMask,n_cls):
# epsilon = 1
hist = Hist(trueMask,predMask,n_cls)
correct_pred = np.diag(hist) # 给类别正确预测的像素点数
pred_classes = np.sum(hist,0) # 预测处的各类别像素点数,
true_classes = np.sum(hist,1) # 真实的各类别像素点数
DSs = 2*correct_pred/(pred_classes+true_classes)
return DSs
``` |
{
"source": "98057/DuckyTails",
"score": 3
} |
#### File: 98057/DuckyTails/DuckyTails.py
```python
import pyautogui
import configparser
import base64
import mimetypes
import time
def main():
config = configparser.ConfigParser()
config.read('config.ini')
files = eval(config.get("Main", "Files"))
for f in files:
global last_command
global default_delay
last_command = ""
duck_text = ""
default_delay = 0
mime = mimetypes.guess_type(f)
if mime[0] == 'application/octet-stream':
duck_bin = open(f, 'rb').read()
duck_text = base64.b64decode(duck_bin)
duck_text = duck_text.decode('ascii')
duck_text = duck_text.splitlines()
elif mime[0] == 'text/plain':
duck_text = open(f, 'r').readlines()
for line in duck_text:
execute_command(line)
last_command = line
def execute_command(cmd):
global default_delay
global last_command
time.sleep(default_delay)
cmd = cmd.split(' ', 1)
if '-' in cmd[0]:
cmd[0] = cmd[0].split('-', 1)
if len(cmd) > 1:
cmd = cmd[0] + [cmd[1]]
else:
cmd = cmd[0]
execute_hotkey(cmd)
elif cmd[0] == 'DELAY':
cmd[1] = eval(cmd[1])/1000
time.sleep(cmd[1])
elif cmd[0] == 'DEFAULT_DELAY':
default_delay = eval(cmd[1]) / 1000
elif cmd[0] == 'STRING':
pyautogui.typewrite(cmd[1].rstrip())
elif cmd[0] == 'GUI' or cmd[0] == 'WINDOWS':
cmd[0] = 'win'
execute_hotkey(cmd)
elif cmd[0] == 'MENU' or cmd[0] == 'APP':
pyautogui.hotkey('shift', 'f10')
elif cmd[0] == 'CTRL' or cmd[0] == 'SHIFT' or cmd[0] == 'ALT':
execute_hotkey(cmd)
elif cmd[0] == 'CONTROL':
cmd[0] = 'ctrl'
execute_hotkey(cmd)
elif cmd[0] == 'DOWNARROW':
pyautogui.press('down')
elif cmd[0] == 'LEFTARROW':
pyautogui.press('left')
elif cmd[0] == 'RIGHTARROW':
pyautogui.press('right')
elif cmd[0] == 'UPARROW':
pyautogui.press('up')
elif cmd[0] == 'REPEAT':
for x in range(0, eval(cmd[1])):
execute_command(last_command)
else:
execute_hotkey(cmd)
def execute_hotkey(cmd):
cmd[0] = cmd[0].rstrip().lower()
if len(cmd) > 1:
cmd[1] = cmd[1].split(' ')
[x.strip().lower() for x in cmd[1]]
pyautogui.hotkey(cmd[0], *cmd[1], interval=0.1)
else:
print(cmd[0])
pyautogui.hotkey(cmd[0])
if __name__ == "__main__":
default_delay = 0
last_command = ""
main()
``` |
{
"source": "981935539/Ace",
"score": 3
} |
#### File: DLStart/common/multi_layer_net_extend.py
```python
import sys, os
sys.path.append(os.pardir) # 为了导入父目录的文件而进行的设定
import numpy as np
from collections import OrderedDict
from .layers import *
from .gradient import numerical_gradient
class MultiLayerNetExtend:
"""扩展版的全连接的多层神经网络
具有Weiht Decay、Dropout、Batch Normalization的功能
Parameters
----------
input_size : 输入大小（MNIST的情况下为784）
hidden_size_list : 隐藏层的神经元数量的列表（e.g. [100, 100, 100]）
output_size : 输出大小（MNIST的情况下为10）
activation : 'relu' or 'sigmoid'
weight_init_std : 指定权重的标准差（e.g. 0.01）
指定'relu'或'he'的情况下设定“He的初始值”
指定'sigmoid'或'xavier'的情况下设定“Xavier的初始值”
weight_decay_lambda : Weight Decay（L2范数）的强度
use_dropout: 是否使用Dropout
dropout_ration : Dropout的比例
use_batchNorm: 是否使用Batch Normalization
"""
def __init__(self, input_size, hidden_size_list, output_size,
activation='relu', weight_init_std='relu', weight_decay_lambda=0,
use_dropout = False, dropout_ration = 0.5, use_batchnorm=False):
self.input_size = input_size
self.output_size = output_size
self.hidden_size_list = hidden_size_list
self.hidden_layer_num = len(hidden_size_list)
self.use_dropout = use_dropout
self.weight_decay_lambda = weight_decay_lambda
self.use_batchnorm = use_batchnorm
self.params = {}
# 初始化权重
self.__init_weight(weight_init_std)
# 生成层
activation_layer = {'sigmoid': Sigmoid, 'relu': Relu}
self.layers = OrderedDict()
for idx in range(1, self.hidden_layer_num+1):
self.layers['Affine' + str(idx)] = Affine(self.params['W' + str(idx)],
self.params['b' + str(idx)])
if self.use_batchnorm:
self.params['gamma' + str(idx)] = np.ones(hidden_size_list[idx-1])
self.params['beta' + str(idx)] = np.zeros(hidden_size_list[idx-1])
self.layers['BatchNorm' + str(idx)] = BatchNormalization(self.params['gamma' + str(idx)], self.params['beta' + str(idx)])
self.layers['Activation_function' + str(idx)] = activation_layer[activation]()
if self.use_dropout:
self.layers['Dropout' + str(idx)] = Dropout(dropout_ration)
idx = self.hidden_layer_num + 1
self.layers['Affine' + str(idx)] = Affine(self.params['W' + str(idx)], self.params['b' + str(idx)])
self.last_layer = SoftmaxWithLoss()
def __init_weight(self, weight_init_std):
"""设定权重的初始值
Parameters
----------
weight_init_std : 指定权重的标准差（e.g. 0.01）
指定'relu'或'he'的情况下设定“He的初始值”
指定'sigmoid'或'xavier'的情况下设定“Xavier的初始值”
"""
all_size_list = [self.input_size] + self.hidden_size_list + [self.output_size]
for idx in range(1, len(all_size_list)):
scale = weight_init_std
if str(weight_init_std).lower() in ('relu', 'he'):
scale = np.sqrt(2.0 / all_size_list[idx - 1]) # 使用ReLU的情况下推荐的初始值
elif str(weight_init_std).lower() in ('sigmoid', 'xavier'):
scale = np.sqrt(1.0 / all_size_list[idx - 1]) # 使用sigmoid的情况下推荐的初始值
self.params['W' + str(idx)] = scale * np.random.randn(all_size_list[idx-1], all_size_list[idx])
self.params['b' + str(idx)] = np.zeros(all_size_list[idx])
def predict(self, x, train_flg=False):
for key, layer in self.layers.items():
if "Dropout" in key or "BatchNorm" in key:
x = layer.forward(x, train_flg)
else:
x = layer.forward(x)
return x
def loss(self, x, t, train_flg=False):
"""求损失函数
参数x是输入数据，t是教师标签
"""
y = self.predict(x, train_flg)
weight_decay = 0
for idx in range(1, self.hidden_layer_num + 2):
W = self.params['W' + str(idx)]
weight_decay += 0.5 * self.weight_decay_lambda * np.sum(W**2)
return self.last_layer.forward(y, t) + weight_decay
def accuracy(self, X, T):
Y = self.predict(X, train_flg=False)
Y = np.argmax(Y, axis=1)
if T.ndim != 1 : T = np.argmax(T, axis=1)
accuracy = np.sum(Y == T) / float(X.shape[0])
return accuracy
def numerical_gradient(self, X, T):
"""求梯度（数值微分）
Parameters
----------
X : 输入数据
T : 教师标签
Returns
-------
具有各层的梯度的字典变量
grads['W1']、grads['W2']、...是各层的权重
grads['b1']、grads['b2']、...是各层的偏置
"""
loss_W = lambda W: self.loss(X, T, train_flg=True)
grads = {}
for idx in range(1, self.hidden_layer_num+2):
grads['W' + str(idx)] = numerical_gradient(loss_W, self.params['W' + str(idx)])
grads['b' + str(idx)] = numerical_gradient(loss_W, self.params['b' + str(idx)])
if self.use_batchnorm and idx != self.hidden_layer_num+1:
grads['gamma' + str(idx)] = numerical_gradient(loss_W, self.params['gamma' + str(idx)])
grads['beta' + str(idx)] = numerical_gradient(loss_W, self.params['beta' + str(idx)])
return grads
def gradient(self, x, t):
# forward
self.loss(x, t, train_flg=True)
# backward
dout = 1
dout = self.last_layer.backward(dout)
layers = list(self.layers.values())
layers.reverse()
for layer in layers:
dout = layer.backward(dout)
# 设定
grads = {}
for idx in range(1, self.hidden_layer_num+2):
grads['W' + str(idx)] = self.layers['Affine' + str(idx)].dW + self.weight_decay_lambda * self.params['W' + str(idx)]
grads['b' + str(idx)] = self.layers['Affine' + str(idx)].db
if self.use_batchnorm and idx != self.hidden_layer_num+1:
grads['gamma' + str(idx)] = self.layers['BatchNorm' + str(idx)].dgamma
grads['beta' + str(idx)] = self.layers['BatchNorm' + str(idx)].dbeta
return grads
``` |
{
"source": "981935539/Sample",
"score": 2
} |
#### File: project/db/database.py
```python
import os
from datetime import datetime, date
from sqlalchemy import create_engine, MetaData
from sqlalchemy.orm import sessionmaker, scoped_session
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.ext.automap import automap_base
ECHO = False
if not os.path.exists('sqlite'): os.mkdir('sqlite')
conn_str = "sqlite+pysqlite:///sqlite/agent.db"
# dbengine = create_engine(conn_str, convert_unicode=True, encoding='utf8', echo=ECHO)
dbengine = create_engine(conn_str, convert_unicode=True, encoding='utf8', echo=ECHO, connect_args={'check_same_thread': False})
session_factory = sessionmaker(bind=dbengine, autocommit=False, autoflush=True, expire_on_commit=False)
db_session = scoped_session(session_factory)
def _dt_convert(obj):
if isinstance(obj, datetime):
return obj.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(obj, date):
return obj.strftime('%Y-%m-%d')
else:
return obj
def to_dict(self, simple=False, convert_datetime=True):
if simple:
return {c: _dt_convert(getattr(self, c, None)) for c in self._simple_key}
return {c.name: _dt_convert(getattr(self, c.name, None)) for c in self.__table__.columns}
def connect_db(param):
engine = create_engine('postgresql+psycopg2://{0}:{1}@{2}/{3}?client_encoding={4}&connect_timeout=5'.
format(param["user"], param["passwd"], param["host"], param["dbname"],
param["encoding"]), echo=param["echo"], pool_size=100, pool_recycle=60)
session_factory = sessionmaker(bind=engine, autocommit=False, autoflush=True, expire_on_commit=False)
session = scoped_session(session_factory)
return session
Base = declarative_base()
Base.query = db_session.query_property()
Base.to_dict = to_dict
def init_db():
from . import models
Base.metadata.create_all(bind=dbengine)
```
#### File: project/handlers/__init__.py
```python
import tornado.web
class BaseHandler(tornado.web.RequestHandler):
@property
def db(self):
return self.application.db
def on_finish(self):
self.db.remove()
from .index import IndexHandler
```
#### File: Sample/project/settings.py
```python
import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
ImageStoragePathMap = {'srcdir':'/dx', '../tests/volume':'C:\\Users\\Administrator\\Desktop'}
def dir_exist(path):
if not os.path.exists(path):
os.makedirs(path, exist_ok=True)
return path
DEBUG = False
PORT = 8085
PROCESS_NUM = 0 # 进程数
# 日志配置
LOGCONF = {
"dir": "/var/log/webpacsai",
"name": "main",
"level": "DEBUG",
"backcount": 10
}
# 数据库配置
DATABASE = {
"hyx": {
'host': '10.119.43.84',
'user': 'postgres',
'passwd': '<PASSWORD>',
'dbname': 'test',
'encoding': 'utf8',
'echo': False
},
"rispacs": {
'host': '10.11.12.148',
'user': 'postgres',
'passwd': '<PASSWORD>',
'dbname': 'test',
'encoding': 'utf8',
'echo': False
}
}
# 文件路径配置
FILEPATH = {
"ai": {
"compress": dir_exist(os.path.join(BASE_DIR, 'data/ai/compress')),
"failed": dir_exist(os.path.join(BASE_DIR, 'data/ai/failed')),
},
"study": {
"compress": dir_exist(os.path.join(BASE_DIR, 'data/study/compress')),
"failed": dir_exist(os.path.join(BASE_DIR, 'data/study/failed')),
},
"report": {
"compress": dir_exist(os.path.join(BASE_DIR, 'data/report/compress')),
"failed": dir_exist(os.path.join(BASE_DIR, 'data/report/failed')),
"backups": dir_exist(os.path.join(BASE_DIR, 'data/report/backups'))
}
}
SFTP = {
"host": "172.16.31.10",
"port": 22,
"username": "root",
"password": "<PASSWORD>.",
# "local": 'F:\\sftptest\\aaa\\test.py', # 本地目录或文件
"remote": "/data/sftptest/" # 远程目录
}
PARTITION_SIZE = 8*1024*1024 # 8M
Content_Type = "application/octet-stream" # HTTP请求内容类型
IF_AISERVER = True
IF_INCREASE_STUDY = True
IF_INCREASE_REPORT = True
URL = {
"AISERVER_URL": "http://172.16.31.10:8004", # 测试服务器地址
"AI_UPLOAD_SERVER_URL": "http://172.16.31.10:8001"
}
# Ai相关配置信息
AICONF = {
"CHANNEL_ID": "0000060000", # 渠道ID
"ORGANIZATION_ID": "003131010100000080000000", # 数据机构ID
"ACCESS_KEY": "<KEY>",
"SECRET_KEY": "<KEY>",
"PUBLIC_KEY": "<KEY>",
"LocalIP": '10.11.12.91',
"DeviceID": '00:00:00:00:00:00',
}
# API相关配置
APICONF = {
"API_VERSION": "1.1", # API版本
"API_REQUEST_AI": "/api/ai/request", # 发起AI请求
"API_REQUEST_AI_RESULT": "/api/ai/result", # 获取AI结果
"API_OUT_PATIENT": '/api/patient/outPatient', # 门诊患者信息
"API_FILE_UPLOAD": "/fileupload/data/serialUID=", # 文件地址
}
# 加密相关配置
ENCRYP = {
"SIGN_METHOD": "sha256",
"ALGORITHM_KEY": "AES", # 密钥算法
"ALGORITHM_ECB": "AES/ECB/PKCS5Padding", # 加密算法/工作模型/填充模式
}
get = lambda key, default=dict(): sys.modules[__name__].__dict__.get(key, default)
``` |
{
"source": "98210184/Quadcopter-PID-Control-in-V-REP",
"score": 2
} |
#### File: Quadcopter-PID-Control-in-V-REP/Quadcopter PID Control in V-REP simolator/A2C_model5.py
```python
import torch
import torch.nn as nn
import torch as T
import torch.optim as optim
from math import pi
from math import e as E
def calc_logprob(mu_v, var_v, actions_v):
p1 = - ((mu_v - actions_v) ** 2) / (2*var_v.clamp(min=1e-3))
p2 = - torch.log(torch.sqrt(2 * pi * var_v))
return p1 + p2
class ActorCriticNetwork(nn.Module):
def __init__(self, state_size, hidden_size, alpha=0.01, K_static=0, K_domain=0, Sigma_domain=0.01):
super(ActorCriticNetwork, self).__init__()
action_size = 3
self.state_size = state_size
self.hidden_size = hidden_size
self.action_size = action_size
self.K_static = K_static
self.K_domain = K_domain
self.Sigma_domain= Sigma_domain
self.hidden1 = nn.Linear(state_size , hidden_size, bias=True)
self.hidden2 = nn.Linear(hidden_size, hidden_size, bias=True)
self.out1 = nn.Linear(hidden_size, action_size, bias=False)
self.u = nn.Linear(action_size, 1 , bias=False)
for params in self.u.parameters():
params.requires_grad = False
self.fc1 = nn.Linear(1+2 , hidden_size, bias=True)
self.fc2 = nn.Linear(hidden_size, hidden_size, bias=True)
self.mu = nn.Linear(hidden_size, 1)
self.sig = nn.Linear(hidden_size, 1)
self.v = nn.Linear(hidden_size, 1)
self.optimizer = optim.Adam(self.parameters(), lr=alpha)
def forward(self, x, x_prime):
x = torch.sigmoid(self.hidden1(x))
x = torch.sigmoid(self.hidden2(x))
self.PID_gains = self.K_static + self.K_domain*torch.tanh(self.out1(x))
# print(self.PID_gains)
u = self.u(self.PID_gains)
self.Control_Signal = u
xs = torch.cat((u, x_prime), dim=1)
xs = torch.sigmoid(self.fc1(xs))
xs = torch.sigmoid(self.fc2(xs))
mu = self.mu(xs)
sigma = self.Sigma_domain*(1+T.tanh(self.sig(xs))) # Sigma must be bounded and positive
v = self.v(xs)
self.Mu = mu
self.Sigma = sigma
return mu, sigma, v
def PID(self):
return self.PID_gains
def CtrlSignal(self):
return self.Control_Signal
class NewAgent(object):
def __init__(self, state_size, hidden_size=5, alpha=0.01, gamma=0.99, K_static=0, K_domain=0, Sigma_domain=0.01):
self.gamma = gamma
self.log_probs = None
self.actor_critic = ActorCriticNetwork(state_size, hidden_size, alpha, K_static, K_domain, Sigma_domain)
def choose_action(self, input1, input2, yd):
mu, sigma, v = self.actor_critic.forward(input1, input2)
if sigma <= torch.tensor([0.01*mu[0][0]]):
sigma = torch.tensor([0.01*mu[0][0]])
self.sigma = sigma
action_probs = T.distributions.Normal(mu, sigma)
probs = action_probs.sample(sample_shape=T.Size([1]))
self.log_probs = calc_logprob(mu, sigma, probs)#action_probs.log_prob(probs)
action = probs #T.tanh(probs)
self.e_mu = mu - yd
self.e_sigma = 0.1*(self.sigma - abs(self.e_mu))
return action.item()
def learn(self, state1, state2, reward, new_state1, new_state2, done=0):
self.actor_critic.optimizer.zero_grad()
_, _, critic_value_ = self.actor_critic.forward(new_state1, new_state2)
_, _, critic_value = self.actor_critic.forward(state1, state2)
reward = T.tensor(reward, dtype=T.float)
delta = reward + self.gamma*critic_value_*(1-int(done)) - critic_value
self.delta = delta
# Individual Losses
w1, w2, w3, w4 = 1.0, 1.0, 1.0, 1.0
# actor_loss = -self.log_probs * abs(delta)
actor_loss = w1*(0.1+abs(delta))*self.e_mu**2 + w2*self.e_sigma**2
critic_loss = w3*delta**2
entropy = w4*T.sqrt(2*pi*E*self.sigma.pow(2))
# Losses
self.actor_loss = actor_loss
self.critic_loss = critic_loss
self.entropy = entropy
self.Total_Loss = actor_loss + critic_loss + entropy
# Back Propagation
(actor_loss + critic_loss + entropy).backward()
# Update Optimizer
self.actor_critic.optimizer.step()
```
#### File: Quadcopter-PID-Control-in-V-REP/Quadcopter PID Control in V-REP simolator/rl_helper.py
```python
import numpy as np
import math
from scipy.stats import norm
import vrep
import vrep_rotors, vrep_imu
class RL(object):
def __init__(self, clientID):
self.clientID = clientID
self.quadHandle = None
self.pos = [0, 0, 0]
self.rotor_data = [0.0, 0.0, 0.0, 0.0]
self.orig_location = [0, 0, 0]
self.curr_location = [0, 0, 0]
self.target_z = 0.0
'''
Initialize all sensors and reset quadcopter position in world
'''
def init_sensors(self):
# Initialize IMU
err, self.quadHandle = vrep.simxGetObjectHandle(self.clientID, 'Quadricopter', vrep.simx_opmode_blocking)
vrep_imu.init_imu(self.clientID, self.quadHandle)
# Initialize Rotors
vrep_rotors.init_rotors(self.clientID)
# Reset quadcopter position
err, self.pos = vrep.simxGetObjectPosition(self.clientID, self.quadHandle, -1, vrep.simx_opmode_buffer)
self.pos = [0,0,0]
vrep.simxSetObjectPosition(self.clientID, self.quadHandle, -1, self.pos, vrep.simx_opmode_oneshot)
err, self.orig_location = vrep.simxGetObjectPosition(self.clientID, self.quadHandle, -1, vrep.simx_opmode_buffer)
'''
Start V-REP simulation
'''
def start_sim(self):
vrep.simxStartSimulation(self.clientID, vrep.simx_opmode_oneshot_wait)
return
'''
Stop V-REP simulation
'''
def stop_sim(self):
vrep.simxStopSimulation(self.clientID, vrep.simx_opmode_oneshot_wait)
return
'''
This function returns reward based on current and previous location data (x,y,z)
'''
def get_reward(self):
self.curr_location = self.get_state()
deviation_x = np.linalg.norm(self.curr_location[0] - self.orig_location[0])
deviation_y = np.linalg.norm(self.curr_location[1] - self.orig_location[1])
deviation_z = np.linalg.norm(self.target_z - self.curr_location[2])
gaussian = norm(0, 2)
reward_x = gaussian.pdf(deviation_x)
reward_y = gaussian.pdf(deviation_y)
reward_z = 1 - math.exp(deviation_z)
total_reward = 2 * (0.5 * reward_x + 0.5 * reward_y + reward_z)
return total_reward
'''
This function moves quadcopter rotors
'''
def do_action(self):
vrep_rotors.move_rotors(self.clientID, self.rotor_data)
return
'''
This function gets quadcopter state
'''
def get_position(self):
self.pos = vrep_imu.get_pos(self.clientID, self.quadHandle)
return self.pos
def get_attitude(self):
self.attitude = vrep.simxGetObjectOrientation(self.clientID, self.quadHandle, -1, vrep.simx_opmode_oneshot_wait)
return self.attitude[1]
def setTargetPosition(self, targetName='Quadricopter_target', desiredPos=[0,0,0]):
err, self.targetHandle = vrep.simxGetObjectHandle(self.clientID, targetName, vrep.simx_opmode_blocking)
vrep.simxSetObjectPosition(self.clientID, self.targetHandle, -1, desiredPos, vrep.simx_opmode_oneshot)
#def getMatrix(self):
# ret, arr = vrep.simxGetObjectMatrix(self.clientID, self.quadHandle, vrep.simx_opmode_blocking)
# return arr
def synchronous(self, enable):
vrep.simxSynchronous(self.clientID, enable)
def synchronousTrigger(self):
vrep.simxSynchronousTrigger(self.clientID)
``` |
{
"source": "98210184/Video-Synopsis",
"score": 3
} |
#### File: Video Synopsis/Video1/tracker.py
```python
import cv2
import math
import numpy as np
from munkres import Munkres, print_matrix
from random import randint
class Tracker:
tracks = []
next_id = 1
min_tracker_distance = 100
max_aging = 10
max_assignment_cost = 2000
def track(self, bounding_boxes):
if len(self.tracks) == 0:
for bounding_box in bounding_boxes:
self.tracks.append(self.create_new_track(bounding_box))
self.next_id += 1
elif len(bounding_boxes) > 0:
# Kalman Prediction & Munkres Matrix
munkres_matrix = []
for bounding_box in bounding_boxes:
x2 = bounding_box.rect.center.x
y2 = bounding_box.rect.center.y
munkres_matrix_row = []
for track in self.tracks:
prediction = track.kalman_filter.predict()
x1 = prediction[0]
y1 = prediction[1]
distance = math.hypot(x2 - x1, y2 - y1)
munkres_matrix_row.append(distance)
munkres_matrix.append(munkres_matrix_row)
munkres = Munkres()
#print(munkres_matrix)
indexes = munkres.compute(munkres_matrix)
assignments = [None] * len(bounding_boxes)
# Rows: BoundingBoxes, Columns: Trackers
for row, column in indexes:
value = munkres_matrix[row][column]
#print('(%d, %d) -> %d' % (row, column, value))
if value < self.max_assignment_cost:
assignments[row] = (column, self.tracks[column])
for track in self.tracks:
track.age += 1
index = 0
for assignment in assignments:
if assignment is None:
self.tracks.append(self.create_new_track(bounding_box))
self.next_id += 1
else:
tracker_index, tracker = assignment
bounding_box = bounding_boxes[index]
track = self.tracks[tracker_index]
track.bounding_box = bounding_box
track.kalman_filter.correct(np.array([[np.float32(bounding_box.rect.center.x)], [np.float32(bounding_box.rect.center.y)]]))
track.age = 0
index += 1
for track in list(self.tracks):
if track.age > self.max_aging:
self.tracks.remove(track)
return self.tracks
def create_new_track(self, bounding_box):
track = self.Track()
kalman = self.init_kalman_filter()
kalman.correct(np.array([[np.float32(bounding_box.rect.center.x)], [np.float32(bounding_box.rect.center.y)]]))
kalman.predict()
track.id = self.next_id
track.bounding_box = bounding_box
track.kalman_filter = kalman
track.color = (randint(0, 255), randint(0, 255), randint(0, 255))
return track
def init_kalman_filter(self):
kalman = cv2.KalmanFilter(4,2)
kalman.measurementMatrix = np.array([[1,0,0,0],[0,1,0,0]],np.float32)
kalman.transitionMatrix = np.array([[1,0,1,0],[0,1,0,1],[0,0,1,0],[0,0,0,1]],np.float32)
kalman.processNoiseCov = np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]],np.float32) * 0.03
return kalman
class Track:
id = None
bounding_box = None
color = None
kalman_filter = None
age = 0
``` |
{
"source": "983632847/homura",
"score": 2
} |
#### File: test/test_vision/test_cutmix.py
```python
import torch
import torch.jit
from homura.vision import cutmix
def test_cutmix():
input = torch.empty(4, 3, 32, 32)
target = torch.tensor([1, 2, 3, 4], dtype=torch.long)
cutmix(input, target, 0.1)
jit_cutmix = torch.jit.script(cutmix)
jit_cutmix(input, target, 0.1)
``` |
{
"source": "983632847/USCL",
"score": 2
} |
#### File: train_USCL/data_aug/dataset_wrapper_Ultrasound_Video_Mixup.py
```python
import os
import random
from PIL import Image
import numpy as np
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
from torch.utils.data.sampler import SubsetRandomSampler
import torchvision.transforms as transforms
from data_aug.gaussian_blur import GaussianBlur
from data_aug.cutout import Cutout
from data_aug.outpainting import Outpainting
from data_aug.nonlin_trans import NonlinearTrans
from data_aug.sharpen import Sharpen
np.random.seed(0)
class USDataset_video(Dataset):
def __init__(self, data_dir, transform=None, LabelList=None, DataList=None, Checkpoint_Num=None):
"""
Ultrasound self-supervised training Dataset, choose 2 different images from a video
:param data_dir: str
:param transform: torch.transform
"""
# self.label_name = {"Rb1": 0, "Rb2": 1, "Rb3": 2, "Rb4": 3, "Rb5": 4, "F0_": 5, "F1_": 6, "F2_": 7, "F3_": 8, "F4_": 9,
# "Reg": 10, "Cov": 11, "Ali": 10, "Bli": 11, "Ple": 11, "Oth": 11} # US-4
# self.label_name = {"Rb1": 0, "Rb2": 1, "Rb3": 2, "Rb4": 3, "Rb5": 4} # CLUST
# self.label_name = {"F0_": 0, "F1_": 1, "F2_": 2, "F3_": 3, "F4_": 4} # Liver Forbrosis
self.label_name = {"Reg": 0, "Cov": 1} # Butterfly
# self.label_name = {"Ali": 0, "Bli": 1, "Ple": 2, "Oth": 3} # COVID19-LUSMS
self.data_info = self.get_img_info(data_dir)
self.transform = transform
self.LabelList = LabelList
self.DataList = DataList
self.Checkpoint_Num = Checkpoint_Num
def __getitem__(self, index):
# ## Different data rate
if index not in self.DataList:
index = random.sample(self.DataList, 1)[0] # index in data set
path_imgs = self.data_info[index]
if len(path_imgs) >= 3: # more than 3 images in one video
path_img = random.sample(path_imgs, 3) # random choose 3 images
img1 = Image.open(path_img[0]).convert('RGB') # 0~255
img2 = Image.open(path_img[1]).convert('RGB') # 0~255
img3 = Image.open(path_img[2]).convert('RGB') # 0~255
if index in self.LabelList:
# path_imgs[0]: '/home/zhangchunhui/MedicalAI/Butte/Cov-Cardiomyopathy_mp4/Cov-Cardiomyopathy_mp4_frame0.jpg'
# path_imgs[0][35:38]: 'Cov'
label1 = self.label_name[path_imgs[0][35:38]]
label2 = self.label_name[path_imgs[1][35:38]]
label3 = self.label_name[path_imgs[2][35:38]]
else:
label1, label2, label3 = 9999, 9999, 9999 # unlabel data = 9999
if self.transform is not None:
img1, img2, img3 = self.transform((img1, img2, img3)) # transform
##########################################################################
### frame mixup
# alpha, beta = 2, 5
alpha, beta = 0.5, 0.5
lam = np.random.beta(alpha, beta)
# img2 as anchor
mixupimg1 = lam * img1 + (1.0 - lam) * img2
mixupimg2 = lam * img3 + (1.0 - lam) * img2
return mixupimg1, label1, mixupimg2, label2, img1, img2
elif len(path_imgs) == 2:
path_img = random.sample(path_imgs, 2) # random choose 3 images
img1 = Image.open(path_img[0]).convert('RGB') # 0~255
img2 = Image.open(path_img[1]).convert('RGB') # 0~255
if index in self.LabelList:
label1 = self.label_name[path_imgs[0][35:38]]
label2 = self.label_name[path_imgs[1][35:38]]
else:
label1, label2 = 9999, 9999 # unlabel data = 9999
if self.transform is not None:
img1, img2 = self.transform((img1, img2)) # transform
return img1, label1, img2, label2, img1, img2
else: # one image in the video, using augmentation to obtain two positive samples
img1 = Image.open(path_imgs[0]).convert('RGB') # 0~255
img2 = Image.open(path_imgs[0]).convert('RGB') # 0~255
if index in self.LabelList:
label1 = self.label_name[path_imgs[0][35:38]]
label2 = self.label_name[path_imgs[0][35:38]]
else:
label1, label2 = 9999, 9999 # unlabel data = 9999
if self.transform is not None:
img1, img2 = self.transform((img1, img2)) # transform
return img1, label1, img2, label2, img1, img2
# if self.transform is not None:
# img1, img2 = self.transform((img1, img2)) # transform
# return img1, label1, img2, label2
def __len__(self): # len
return len(self.data_info)
@staticmethod
def get_img_info(data_dir):
data_info = list()
for root, dirs, _ in os.walk(data_dir):
for sub_dir in dirs: # one video as one class
img_names = os.listdir(os.path.join(root, sub_dir))
img_names = list(filter(lambda x: x.endswith('.jpg') or x.endswith('.png'), img_names))
path_imgs = [] # list
for i in range(len(img_names)):
img_name = img_names[i]
path_img = os.path.join(root, sub_dir, img_name)
path_imgs.append(path_img)
data_info.append(path_imgs)
return data_info
class USDataset_image(Dataset):
def __init__(self, data_dir, transform=None, LabelList=None, DataList=None):
"""
Ultrasound self-supervised training Dataset, only choose one image from a video
:param data_dir: str
:param transform: torch.transform
"""
self.data_info = self.get_img_info(data_dir)
self.transform = transform
self.LabelList = LabelList
self.DataList = DataList
def __getitem__(self, index):
path_imgs = self.data_info[index] # list
path_img = random.sample(path_imgs, 1) # random choose one image
img1 = Image.open(path_img[0]).convert('RGB') # 0~255
img2 = Image.open(path_img[0]).convert('RGB') # 0~255
label1 = 0 if path_img[0].lower()[64:].find("cov") > -1 else (1 if path_img[0].lower()[64:].find("pneu") > -1 else 2)
if self.transform is not None:
img1, img2 = self.transform((img1, img2)) # transform
return img1, label1, img2, label1
def __len__(self): # len
return len(self.data_info)
@staticmethod
def get_img_info(data_dir):
data_info = list()
for root, dirs, _ in os.walk(data_dir):
for sub_dir in dirs: # one video as one class
img_names = os.listdir(os.path.join(root, sub_dir))
img_names = list(filter(lambda x: x.endswith('.jpg') or x.endswith('.png'), img_names))
path_imgs = []
for i in range(len(img_names)):
img_name = img_names[i]
path_img = os.path.join(root, sub_dir, img_name)
path_imgs.append(path_img)
data_info.append(path_imgs)
return data_info
class DataSetWrapper(object):
def __init__(self, batch_size, LabelList, DataList, Checkpoint_Num, num_workers, valid_size, input_shape, s):
self.batch_size = batch_size
self.num_workers = num_workers
self.valid_size = valid_size # leave out ratio, e.g. 0.20
self.s = s
self.input_shape = eval(input_shape) # (H, W, C) shape of input image
self.LabelList = LabelList
self.DataList = DataList
self.Checkpoint_Num = Checkpoint_Num
def get_data_loaders(self):
''' Get dataloader for target dataset, this function will be called before the training process '''
data_augment = self._get_simclr_pipeline_transform()
print('\nData augmentation:')
print(data_augment)
use_video = True
if use_video:
print('\nUse video augmentation!')
# US-4
# train_dataset = USDataset_video("/home/zhangchunhui/WorkSpace/SSL/Ultrasound_Datasets_train/Video/",
# transform=SimCLRDataTransform(data_augment), LabelList=self.LabelList, DataList=self.DataList) # augmented from 2 images
# 1 video-CLUST
# train_dataset = USDataset_video("/home/zhangchunhui/MedicalAI/Ultrasound_Datasets_train/CLUST/",
# transform=SimCLRDataTransform(data_augment), LabelList=self.LabelList, DataList=self.DataList) # augmented from 2 images
# 1 video-Liver
# train_dataset = USDataset_video("/home/zhangchunhui/MedicalAI/Ultrasound_Datasets_train/Liver/",
# transform=SimCLRDataTransform(data_augment), LabelList=self.LabelList, DataList=self.DataList) # augmented from 2 images
# 1 video-COVID
# train_dataset = USDataset_video("/home/zhangchunhui/MedicalAI/Ultrasound_Datasets_train/COVID/",
# transform=SimCLRDataTransform(data_augment), LabelList=self.LabelList, DataList=self.DataList) # augmented from 2 images
# 1 video-Butte
train_dataset = USDataset_video("/home/zhangchunhui/MedicalAI/Butte/",
transform=SimCLRDataTransform(data_augment), LabelList=self.LabelList, DataList=self.DataList) # augmented from 2 images
else:
print('\nDo not use video augmentation!')
# Images
train_dataset = USDataset_image("/home/zhangchunhui/MedicalAI/Butte/",
transform=SimCLRDataTransform(data_augment), LabelList=self.LabelList, DataList=self.DataList) # augmented from 1 image
train_loader, valid_loader = self.get_train_validation_data_loaders(train_dataset)
# train_loader = self.get_train_validation_data_loaders(train_dataset)
return train_loader, valid_loader
# return train_loader
def __len__(self): #
return self.batch_size
def _get_simclr_pipeline_transform(self):
'''
Get a set of data augmentation transformations as described in the SimCLR paper.
Random Crop (resize to original size) + Random color distortion + Gaussian Blur
'''
color_jitter = transforms.ColorJitter(0.8 * self.s, 0.8 * self.s, 0.8 * self.s, 0.2 * self.s)
data_transforms = transforms.Compose([Sharpen(degree=0),
transforms.Resize((self.input_shape[0], self.input_shape[1])),
transforms.RandomResizedCrop(size=self.input_shape[0], scale=(0.8, 1.0), ratio=(0.8, 1.25)),
transforms.RandomHorizontalFlip(),
# transforms.RandomRotation(10),
color_jitter,
# transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
# GaussianBlur(kernel_size=int(0.05 * self.input_shape[0])),
transforms.ToTensor(),
# NonlinearTrans(prob=0.9), # 0-1
# transforms.Normalize(mean=[0.5,0.5,0.5], std=[0.25,0.25,0.25]),
# Cutout(n_holes=3, length=32),
# Outpainting(n_holes=5),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.25, 0.25, 0.25]),
])
return data_transforms
def get_train_validation_data_loaders(self, train_dataset):
# obtain indices that will be used for training / validation
num_train = len(train_dataset)
indices = list(range(num_train))
np.random.shuffle(indices)
split = int(np.floor(self.valid_size * num_train))
train_idx, valid_idx = indices[split:], indices[:split]
train_idx= indices[split:]
# define samplers for obtaining training and validation batches
train_sampler = SubsetRandomSampler(train_idx)
valid_sampler = SubsetRandomSampler(valid_idx)
# data loaders for training and validation, drop_last should be False to avoid data shortage of valid_loader
train_loader = DataLoader(train_dataset, batch_size=self.batch_size, sampler=train_sampler,
num_workers=self.num_workers, drop_last=False, shuffle=False)
valid_loader = DataLoader(train_dataset, batch_size=self.batch_size, sampler=valid_sampler,
num_workers=self.num_workers, drop_last=False)
return train_loader, valid_loader
# return train_loader
class SimCLRDataTransform(object):
''' transform two images in a video to two augmented samples '''
def __init__(self, transform):
self.transform = transform
def __call__(self, sample):
if len(sample)>2:
xi = self.transform(sample[0]) # sample -> xi, xj in original implementation
xj = self.transform(sample[1])
xk = self.transform(sample[2])
return xi, xj, xk
else:
xi = self.transform(sample[0]) # sample -> xi, xj in original implementation
xj = self.transform(sample[1])
return xi, xj
``` |
{
"source": "983632847/video_analyst",
"score": 2
} |
#### File: got_benchmark/experiments/trackingnet.py
```python
from __future__ import absolute_import
import os
import numpy as np
from loguru import logger
from .otb import ExperimentOTB
from ..datasets import TrackingNet
from ..utils.metrics import rect_iou, center_error
from ..utils.ioutils import compress
class ExperimentTrackingNet(ExperimentOTB):
r"""Experiment pipeline and evaluation toolkit for TrackingNet dataset.
Only the TEST subset part implemented.
Args:
root_dir (string): Root directory of LaSOT dataset.
subset (string, optional): Specify ``train`` or ``test`` or ``train0,1,...``
subset of TrackingNet. Default is ``test``.
return_meta (bool, optional): whether to fetch meta info
(occlusion or out-of-view). Default is ``False``.
result_dir (string, optional): Directory for storing tracking
results. Default is ``./results``.
report_dir (string, optional): Directory for storing performance
evaluation results. Default is ``./reports``.
"""
def __init__(self,
root_dir,
subset='test',
return_meta=False,
result_dir='results',
report_dir='reports'):
# assert subset.upper() in ['TRAIN', 'TEST']
assert subset.startswith(('train', 'test')), 'Unknown subset.'
self.subset = subset
self.dataset = TrackingNet(root_dir, subset, return_meta=return_meta)
self.result_dir = os.path.join(result_dir, 'TrackingNet')
self.report_dir = os.path.join(report_dir, 'TrackingNet')
# as nbins_iou increases, the success score
# converges to the average overlap (AO)
self.nbins_iou = 21
self.nbins_ce = 51
def report(self, tracker_names, *args, plot_curves=True, **kwargs):
if self.subset == 'test':
logger.info(
"TEST subset's annotations are withholded, generate submission file instead..."
)
for tracker_name in tracker_names:
# compress all tracking results
result_dir = os.path.join(self.result_dir, tracker_name)
save_file = result_dir
compress(result_dir, save_file)
print('Records saved at', os.path.realpath(save_file + '.zip'))
# print submission guides
print('\033[93mLogin and follow instructions on')
print('http://eval.tracking-net.org/')
print('to upload and evaluate your tracking results\033[0m')
performance = None
else:
performance = super(ExperimentTrackingNet,
self).report(tracker_names,
*args,
plot_curves=plot_curves,
**kwargs)
return performance
# def _calc_metrics(self, boxes, anno):
# valid = ~np.any(np.isnan(anno), axis=1)
# if len(valid) == 0:
# print('Warning: no valid annotations')
# return None, None
# else:
# ious = rect_iou(boxes[valid, :], anno[valid, :])
# center_errors = center_error(
# boxes[valid, :], anno[valid, :])
# return ious, center_errors
```
#### File: task_model/taskmodel_impl/siamese_track.py
```python
import numpy as np
from loguru import logger
import torch
import torch.nn as nn
import torch.nn.functional as F
from videoanalyst.model.common_opr.common_block import (conv_bn_relu,
xcorr_depthwise)
from videoanalyst.model.module_base import ModuleBase
from videoanalyst.model.task_model.taskmodel_base import (TRACK_TASKMODELS,
VOS_TASKMODELS)
torch.set_printoptions(precision=8)
@TRACK_TASKMODELS.register
@VOS_TASKMODELS.register
class SiamTrack(ModuleBase):
r"""
SiamTrack model for tracking
Hyper-Parameters
----------------
pretrain_model_path: string
path to parameter to be loaded into module
head_width: int
feature width in head structure
"""
default_hyper_params = dict(pretrain_model_path="",
head_width=256,
conv_weight_std=0.01,
neck_conv_bias=[True, True, True, True],
corr_fea_output=False,
trt_mode=False,
trt_fea_model_path="",
trt_track_model_path="")
support_phases = ["train", "feature", "track", "freeze_track_fea"]
def __init__(self, backbone, head, loss=None):
super(SiamTrack, self).__init__()
self.basemodel = backbone
self.head = head
self.loss = loss
self.trt_fea_model = None
self.trt_track_model = None
self._phase = "train"
@property
def phase(self):
return self._phase
@phase.setter
def phase(self, p):
assert p in self.support_phases
self._phase = p
def forward(self, *args, phase=None):
r"""
Perform tracking process for different phases (e.g. train / init / track)
Arguments
---------
target_img: torch.Tensor
target template image patch
search_img: torch.Tensor
search region image patch
Returns
-------
fcos_score_final: torch.Tensor
predicted score for bboxes, shape=(B, HW, 1)
fcos_bbox_final: torch.Tensor
predicted bbox in the crop, shape=(B, HW, 4)
fcos_cls_prob_final: torch.Tensor
classification score, shape=(B, HW, 1)
fcos_ctr_prob_final: torch.Tensor
center-ness score, shape=(B, HW, 1)
"""
if phase is None:
phase = self._phase
# used during training
if phase == 'train':
# resolve training data
training_data = args[0]
target_img = training_data["im_z"]
search_img = training_data["im_x"]
# backbone feature
f_z = self.basemodel(target_img)
f_x = self.basemodel(search_img)
# feature adjustment
c_z_k = self.c_z_k(f_z)
r_z_k = self.r_z_k(f_z)
c_x = self.c_x(f_x)
r_x = self.r_x(f_x)
# feature matching
r_out = xcorr_depthwise(r_x, r_z_k)
c_out = xcorr_depthwise(c_x, c_z_k)
# head
fcos_cls_score_final, fcos_ctr_score_final, fcos_bbox_final, corr_fea = self.head(
c_out, r_out)
predict_data = dict(
cls_pred=fcos_cls_score_final,
ctr_pred=fcos_ctr_score_final,
box_pred=fcos_bbox_final,
)
if self._hyper_params["corr_fea_output"]:
predict_data["corr_fea"] = corr_fea
return predict_data
# used for template feature extraction (normal mode)
elif phase == 'feature':
target_img, = args
if self._hyper_params["trt_mode"]:
# extract feature with trt model
out_list = self.trt_fea_model(target_img)
else:
# backbone feature
f_z = self.basemodel(target_img)
# template as kernel
c_z_k = self.c_z_k(f_z)
r_z_k = self.r_z_k(f_z)
# output
out_list = [c_z_k, r_z_k]
# used for template feature extraction (trt mode)
elif phase == "freeze_track_fea":
search_img, = args
# backbone feature
f_x = self.basemodel(search_img)
# feature adjustment
c_x = self.c_x(f_x)
r_x = self.r_x(f_x)
# head
return [c_x, r_x]
# [Broken] used for template feature extraction (trt mode)
# currently broken due to following issue of "torch2trt" package
# c.f. https://github.com/NVIDIA-AI-IOT/torch2trt/issues/251
elif phase == "freeze_track_head":
c_out, r_out = args
# head
outputs = self.head(c_out, r_out, 0, True)
return outputs
# used for tracking one frame during test
elif phase == 'track':
if len(args) == 3:
search_img, c_z_k, r_z_k = args
if self._hyper_params["trt_mode"]:
c_x, r_x = self.trt_track_model(search_img)
else:
# backbone feature
f_x = self.basemodel(search_img)
# feature adjustment
c_x = self.c_x(f_x)
r_x = self.r_x(f_x)
elif len(args) == 4:
# c_x, r_x already computed
c_z_k, r_z_k, c_x, r_x = args
else:
raise ValueError("Illegal args length: %d" % len(args))
# feature matching
r_out = xcorr_depthwise(r_x, r_z_k)
c_out = xcorr_depthwise(c_x, c_z_k)
# head
fcos_cls_score_final, fcos_ctr_score_final, fcos_bbox_final, corr_fea = self.head(
c_out, r_out, search_img.size(-1))
# apply sigmoid
fcos_cls_prob_final = torch.sigmoid(fcos_cls_score_final)
fcos_ctr_prob_final = torch.sigmoid(fcos_ctr_score_final)
# apply centerness correction
fcos_score_final = fcos_cls_prob_final * fcos_ctr_prob_final
# register extra output
extra = dict(c_x=c_x, r_x=r_x, corr_fea=corr_fea)
# output
out_list = fcos_score_final, fcos_bbox_final, fcos_cls_prob_final, fcos_ctr_prob_final, extra
else:
raise ValueError("Phase non-implemented.")
return out_list
def update_params(self):
r"""
Load model parameters
"""
self._make_convs()
self._initialize_conv()
super().update_params()
if self._hyper_params["trt_mode"]:
logger.info("trt mode enable")
from torch2trt import TRTModule
self.trt_fea_model = TRTModule()
self.trt_fea_model.load_state_dict(
torch.load(self._hyper_params["trt_fea_model_path"]))
self.trt_track_model = TRTModule()
self.trt_track_model.load_state_dict(
torch.load(self._hyper_params["trt_track_model_path"]))
logger.info("loading trt model succefully")
def _make_convs(self):
head_width = self._hyper_params['head_width']
# feature adjustment
self.r_z_k = conv_bn_relu(head_width,
head_width,
1,
3,
0,
has_relu=False)
self.c_z_k = conv_bn_relu(head_width,
head_width,
1,
3,
0,
has_relu=False)
self.r_x = conv_bn_relu(head_width, head_width, 1, 3, 0, has_relu=False)
self.c_x = conv_bn_relu(head_width, head_width, 1, 3, 0, has_relu=False)
def _initialize_conv(self, ):
conv_weight_std = self._hyper_params['conv_weight_std']
conv_list = [
self.r_z_k.conv, self.c_z_k.conv, self.r_x.conv, self.c_x.conv
]
for ith in range(len(conv_list)):
conv = conv_list[ith]
torch.nn.init.normal_(conv.weight,
std=conv_weight_std) # conv_weight_std=0.01
def set_device(self, dev):
if not isinstance(dev, torch.device):
dev = torch.device(dev)
self.to(dev)
if self.loss is not None:
for loss_name in self.loss:
self.loss[loss_name].to(dev)
``` |
{
"source": "983834572/kitsune",
"score": 2
} |
#### File: kitsune/kitsune/settings.py
```python
import logging
import os
import platform
from datetime import date
from bundles import MINIFY_BUNDLES
from kitsune.lib.sumo_locales import LOCALES
DEBUG = True
TEMPLATE_DEBUG = DEBUG
STAGE = False
LOG_LEVEL = logging.INFO
SYSLOG_TAG = 'http_sumo_app'
# Repository directory.
ROOT = os.path.dirname(os.path.dirname(__file__))
# Django project directory.
PROJECT_ROOT = os.path.dirname(__file__)
PROJECT_MODULE = 'kitsune'
# path bases things off of ROOT
path = lambda *a: os.path.abspath(os.path.join(ROOT, *a))
ADMINS = (
# ('<NAME>', '<EMAIL>'),
)
MANAGERS = ADMINS
DATABASES = {
'default': {
# Add 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3'
# or 'oracle'.
'ENGINE': 'django.db.backends.mysql',
# Or path to database file if sqlite3.
'NAME': 'kitsune',
# Not used with sqlite3.
'USER': '',
# Not used with sqlite3.
'PASSWORD': '',
# Set to empty string for localhost. Not used with sqlite3.
'HOST': '',
# Set to empty string for default. Not used with sqlite3.
'PORT': '',
'OPTIONS': {'init_command': 'SET storage_engine=InnoDB'},
}
}
DATABASE_ROUTERS = ('multidb.PinningMasterSlaveRouter',)
# Put the aliases for your slave databases in this list
SLAVE_DATABASES = []
# Cache Settings
# CACHES = {
# 'default': {
# 'BACKEND': 'caching.backends.memcached.MemcachedCache',
# 'LOCATION': ['localhost:11211'],
# 'PREFIX': 'sumo:',
# },
# }
# Setting this to the Waffle version.
WAFFLE_CACHE_PREFIX = 'w0.7.7a:'
# Addresses email comes from
DEFAULT_FROM_EMAIL = '<EMAIL>'
DEFAULT_REPLY_TO_EMAIL = '<EMAIL>'
SERVER_EMAIL = '<EMAIL>'
EMAIL_SUBJECT_PREFIX = '[support] '
PLATFORM_NAME = platform.node()
# Local time zone for this installation. Choices can be found here:
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# although not all choices may be available on all operating systems.
# If running in a Windows environment this must be set to the same as your
# system time zone.
TIME_ZONE = 'US/Pacific'
# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = 'en-US'
# Supported languages
# Note: We periodically add locales to this list and it is easier to
# review with changes with one locale per line.
SUMO_LANGUAGES = (
'ar',
'bg',
'bn-BD',
'bn-IN',
'bs',
'ca',
'cs',
'da',
'de',
'el',
'en-US',
'es',
'eu',
'fa',
'fi',
'fr',
'he',
'hi-IN',
'hr',
'hu',
'id',
'it',
'ja',
'km',
'ko',
'lt',
'ml',
'ne-NP',
'nl',
'no',
'pl',
'pt-BR',
'pt-PT',
'ro',
'ru',
'si',
'sk',
'sl',
'sq',
'sr-Cyrl',
'sv',
'ta',
'ta-LK',
'te',
'th',
'tr',
'uk',
'vi',
'xx', # This is a test locale
'zh-CN',
'zh-TW',
)
# A list of locales for which AAQ is available.
AAQ_LANGUAGES = (
'en-US',
'fi',
'hu',
'pt-BR',
'sl',
'sr-Cyrl',
)
# These languages won't show a warning about FxOS when contributors try
# to add content.
FXOS_LANGUAGES = [
'bn-BD',
'bn-IN',
'cs',
'de',
'el',
'en-US',
'es',
'fr',
'hi-IN',
'hr',
'hu',
'it',
'nl',
'pl',
'pt-BR',
'pt-PT',
'ro',
'ru',
'sr',
'ta',
'sr-Cyrl',
'tr',
]
# Languages that should show up in language switcher.
LANGUAGE_CHOICES = tuple(
[(lang, LOCALES[lang].native) for lang in SUMO_LANGUAGES
if lang != 'xx'])
LANGUAGES_DICT = dict([(i.lower(), LOCALES[i].native) for i in SUMO_LANGUAGES])
LANGUAGES = LANGUAGES_DICT.items()
LANGUAGE_URL_MAP = dict([(i.lower(), i) for i in SUMO_LANGUAGES])
# Locales that are known but unsupported. Keys are the locale, values
# are an optional fallback locale, or None, to use the LANGUAGE_CODE.
NON_SUPPORTED_LOCALES = {
'ach': None,
'af': None,
'ak': None,
'an': 'es',
'as': None,
'ast': 'es',
'az': None,
'be': 'ru',
'br': 'fr',
'csb': 'pl',
'eo': None,
'et': None,
'ff': None,
'fur': 'it',
'fy-NL' : 'nl',
'ga-IE': None,
'gd': None,
'gl': 'es',
'gu-IN': None,
'hsb': 'de',
'hy-AM': None,
'ilo': None,
'is': None,
'kk': None,
'kn': None,
'lg': None,
'lij': 'it',
'mai': None,
'mk': None,
'mn': None,
'mr': None,
'ms': None,
'my': None,
'nb-NO': 'no',
'nn-NO': 'no',
'nso': None,
'oc': 'fr',
'pa-IN': None,
'rm': None,
'rw': None,
'sah': None,
'son': None,
'sv-SE': 'sv',
'sw': None,
'xh': None,
'zu': None,
}
ES_LOCALE_ANALYZERS = {
'ar': 'arabic',
'bg': 'bulgarian',
'ca': 'snowball-catalan',
'cs': 'czech',
'da': 'snowball-danish',
'de': 'snowball-german',
'en-US': 'snowball-english',
'es': 'snowball-spanish',
'eu': 'snowball-basque',
'fa': 'persian',
'fi': 'snowball-finnish',
'fr': 'snowball-french',
'hi-IN': 'hindi',
'hu': 'snowball-hungarian',
'id': 'indonesian',
'it': 'snowball-italian',
'ja': 'cjk',
'nl': 'snowball-dutch',
'no': 'snowball-norwegian',
'pl': 'polish',
'pt-BR': 'snowball-portuguese',
'pt-PT': 'snowball-portuguese',
'ro': 'snowball-romanian',
'ru': 'snowball-russian',
'sv': 'snowball-swedish',
'th': 'thai',
'tr': 'snowball-turkish',
'zh-CN': 'chinese',
'zh-TW': 'chinese',
}
ES_PLUGIN_ANALYZERS = [
'polish'
]
ES_USE_PLUGINS = False
# These are for the indexer for the offline sumo app.
LANGUAGES_WITHOUT_SPACES = (
'zh-CN',
'zh-TW',
'ja',
'ko',
'my'
)
TEXT_DOMAIN = 'messages'
SITE_ID = 1
# If you set this to False, Django will make some optimizations so as
# not to load the internationalization machinery.
USE_I18N = True
USE_L10N = True
DB_LOCALIZE = {
'karma': {
'Title': {
'attrs': ['name'],
'comments': ['This is a karma title.'],
}
},
'products': {
'Product': {
'attrs': ['title', 'description'],
},
'Topic': {
'attrs': ['title', 'description'],
},
},
'badger': {
'Badge': {
'attrs': ['title', 'description'],
},
},
}
# locale is in the kitsune git repo project directory, so that's
# up one directory from the PROJECT_ROOT
LOCALE_PATHS = (
path('locale'),
)
# Use the real robots.txt?
ENGAGE_ROBOTS = False
# Absolute path to the directory that holds media.
# Example: "/home/media/media.lawrence.com/"
MEDIA_ROOT = path('media')
# URL that handles the media served from MEDIA_ROOT. Make sure to use a
# trailing slash if there is a path component (optional in other cases).
# Examples: "http://media.lawrence.com", "http://example.com/media/"
MEDIA_URL = '/media/'
STATIC_ROOT = path('static')
STATIC_URL = '/static/'
STATICFILES_FINDERS = (
'django.contrib.staticfiles.finders.FileSystemFinder',
'django.contrib.staticfiles.finders.AppDirectoriesFinder',
'kitsune.sumo.static_finders.WTFinder')
# Paths that don't require a locale prefix.
SUPPORTED_NONLOCALES = (
'1',
'admin',
'api',
'favicon.ico',
'media',
'offline',
'postcrash',
'robots.txt',
'services',
'wafflejs',
'geoip-suggestion',
)
# Make this unique, and don't share it with anybody.
SECRET_KEY = <KEY>'
# List of callables that know how to import templates from various
# sources.
TEMPLATE_LOADERS = (
'jingo.Loader',
'django.template.loaders.filesystem.Loader',
'django.template.loaders.app_directories.Loader',
# 'django.template.loaders.eggs.Loader',
)
# Because Jinja2 is the default template loader, add any non-Jinja templated
# apps here:
JINGO_EXCLUDE_APPS = [
'admin',
'adminplus',
'authority',
'kadmin',
'rest_framework',
'waffle',
]
TEMPLATE_CONTEXT_PROCESSORS = (
'django.contrib.auth.context_processors.auth',
'django.core.context_processors.debug',
'django.core.context_processors.media',
'django.core.context_processors.static',
'django.core.context_processors.request',
'session_csrf.context_processor',
'django.contrib.messages.context_processors.messages',
'kitsune.sumo.context_processors.global_settings',
'kitsune.sumo.context_processors.i18n',
'kitsune.sumo.context_processors.geoip_cache_detector',
'jingo_minify.helpers.build_ids',
'kitsune.messages.context_processors.unread_message_count',
)
MIDDLEWARE_CLASSES = (
'multidb.middleware.PinningRouterMiddleware',
'django_statsd.middleware.GraphiteMiddleware',
'commonware.request.middleware.SetRemoteAddrFromForwardedFor',
# LocaleURLMiddleware requires access to request.user. These two must be
# loaded before the LocaleURLMiddleware
'commonware.middleware.NoVarySessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'kitsune.users.middleware.LogoutDeactivatedUsersMiddleware',
# This should come before TokenLoginMiddleware, because
# TokenLoginMiddleware uses this to tell users they have been
# automatically logged. It also has to come after
# NoVarySessionMiddleware.
'django.contrib.messages.middleware.MessageMiddleware',
# This middleware should come after AuthenticationMiddleware.
'kitsune.users.middleware.TokenLoginMiddleware',
# LocaleURLMiddleware must be before any middleware that uses
# sumo.urlresolvers.reverse() to add locale prefixes to URLs:
'kitsune.sumo.middleware.LocaleURLMiddleware',
# Mobile detection should happen in Zeus.
'kitsune.sumo.middleware.DetectMobileMiddleware',
'mobility.middleware.XMobileMiddleware',
'kitsune.sumo.middleware.MobileSwitchMiddleware',
'kitsune.sumo.middleware.Forbidden403Middleware',
'django.middleware.common.CommonMiddleware',
'kitsune.sumo.middleware.RemoveSlashMiddleware',
'kitsune.inproduct.middleware.EuBuildMiddleware',
'kitsune.sumo.middleware.NoCacheHttpsMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
'kitsune.sumo.anonymous.AnonymousIdentityMiddleware',
'session_csrf.CsrfMiddleware',
'kitsune.twitter.middleware.SessionMiddleware',
'kitsune.sumo.middleware.PlusToSpaceMiddleware',
'commonware.middleware.ScrubRequestOnException',
'django_statsd.middleware.GraphiteRequestTimingMiddleware',
'waffle.middleware.WaffleMiddleware',
'commonware.middleware.ContentTypeOptionsHeader',
'commonware.middleware.StrictTransportMiddleware',
'commonware.middleware.XSSProtectionHeader',
'commonware.middleware.RobotsTagHeader',
# 'axes.middleware.FailedLoginMiddleware'
)
# Auth
AUTHENTICATION_BACKENDS = (
'django.contrib.auth.backends.ModelBackend',
'kitsune.users.auth.TokenLoginBackend',
)
AUTH_PROFILE_MODULE = 'users.Profile'
USER_AVATAR_PATH = 'uploads/avatars/'
DEFAULT_AVATAR = 'img/avatar.png'
AVATAR_SIZE = 48 # in pixels
MAX_AVATAR_FILE_SIZE = 131072 # 100k, in bytes
GROUP_AVATAR_PATH = 'uploads/groupavatars/'
ACCOUNT_ACTIVATION_DAYS = 30
PASSWORD_HASHERS = (
'kitsune.users.hashers.SHA256PasswordHasher',
)
USERNAME_BLACKLIST = path('kitsune', 'configs', 'username-blacklist.txt')
ROOT_URLCONF = '%s.urls' % PROJECT_MODULE
TEMPLATE_DIRS = (
# Put strings here, like "/home/html/django_templates"
# Always use forward slashes, even on Windows.
# Don't forget to use absolute paths, not relative paths.
# Check templates in the sumo apps first. There are overrides for the admin
# templates.
path('kitsune', 'sumo', 'templates'),
)
# TODO: Figure out why changing the order of apps (for example, moving
# taggit higher in the list) breaks tests.
INSTALLED_APPS = (
# south needs to come early so tests don't fail
'south',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.messages',
'django.contrib.staticfiles',
'django.contrib.admin',
'kitsune.users',
'dennis.django_dennis',
'tower',
'jingo_minify',
'authority',
'timezones',
'waffle',
'kitsune.access',
'kitsune.sumo',
'kitsune.search',
'kitsune.forums',
'djcelery',
'badger',
'cronjobs',
'tidings',
'rest_framework.authtoken',
'kitsune.questions',
'adminplus',
'kitsune.kadmin',
'kitsune.kbadge',
'taggit',
'kitsune.flagit',
'kitsune.upload',
'product_details',
'kitsune.wiki',
'kitsune.kbforums',
'kitsune.dashboards',
'kitsune.gallery',
'kitsune.customercare',
'kitsune.twitter',
'kitsune.inproduct',
'kitsune.postcrash',
'kitsune.landings',
'kitsune.announcements',
'kitsune.community',
'kitsune.messages',
'commonware.response.cookies',
'kitsune.groups',
'kitsune.karma',
'kitsune.tags',
'kitsune.kpi',
'kitsune.offline',
'kitsune.products',
'rest_framework',
'statici18n',
# 'axes',
# App for Sentry:
'raven.contrib.django',
# Extra apps for testing.
'django_nose',
'test_utils',
# Extra app for python migrations.
'django_extensions',
# App for sample data
'eadred',
)
TEST_RUNNER = 'kitsune.sumo.tests.TestSuiteRunner'
def JINJA_CONFIG():
from django.conf import settings
config = {'extensions': ['tower.template.i18n', 'caching.ext.cache',
'jinja2.ext.autoescape', 'jinja2.ext.with_',
'jinja2.ext.do'],
'finalize': lambda x: x if x is not None else ''}
if not settings.DEBUG:
import jinja2
from caching.base import cache
if hasattr(cache, 'scheme') and 'memcached' in cache.scheme:
# We're passing the _cache object directly to jinja because
# Django can't store binary directly; it enforces unicode on it.
# Details:
# http://jinja.pocoo.org/2/documentation/api#bytecode-cache
# and in the errors you get when you try it the other way.
bc = jinja2.MemcachedBytecodeCache(cache._cache,
"%sj2:" % settings.CACHE_PREFIX)
config['cache_size'] = -1 # Never clear the cache
config['bytecode_cache'] = bc
return config
# Let Tower know about our additional keywords.
# DO NOT import an ngettext variant as _lazy.
TOWER_KEYWORDS = {
'_lazy': None,
}
# Tells the extract script what files to look for l10n in and what
# function handles the extraction. The Tower library expects this.
tower_tmpl = 'tower.management.commands.extract.extract_tower_template'
tower_python = 'tower.management.commands.extract.extract_tower_python'
DOMAIN_METHODS = {
'messages': [
('kitsune/forums/**.py', 'ignore'),
('kitsune/forums/**.html', 'ignore'),
('kitsune/**/tests/**.py', 'ignore'),
('kitsune/**/management/**.py', 'ignore'),
('kitsune/**.py', tower_python),
('kitsune/**/templates/**.html', tower_tmpl),
('vendor/src/django-tidings/**/templates/**.html', tower_tmpl),
('vendor/src/django-badger/badger/*.py', tower_python),
('vendor/src/django-badger/badger/templatetags/*.py', tower_python),
],
'lhtml': [
('kitsune/forums/**.lhtml', 'ignore'),
('**/templates/**.lhtml', tower_tmpl)
],
'ltxt': [
('**/templates/**.ltxt', tower_tmpl),
],
'javascript': [
# We can't say **.js because that would dive into any libraries.
('kitsune/**/static/js/*-all.js', 'ignore'),
('kitsune/**/static/js/*-min.js', 'ignore'),
('kitsune/**/static/js/*.js', 'javascript'),
],
}
# These domains will not be merged into messages.pot and will use
# separate PO files. See the following URL for an example of how to
# set these domains in DOMAIN_METHODS.
# http://github.com/jbalogh/zamboni/blob/d4c64239c24aa2f1e91276909823d1d1b290f0ee/settings.py#L254 # nopep8
STANDALONE_DOMAINS = [
TEXT_DOMAIN,
'javascript',
'yaocho',
]
STATICI18N_DOMAIN = 'javascript'
STATICI18N_PACKAGES = ['kitsune.sumo']
# If you have trouble extracting strings with Tower, try setting this
# to True
TOWER_ADD_HEADERS = True
LESS_BIN = 'lessc'
UGLIFY_BIN = 'uglifyjs'
CLEANCSS_BIN = 'cleancss'
NUNJUCKS_PRECOMPILE_BIN = 'nunjucks-precompile'
#
# Sessions
SESSION_COOKIE_AGE = 4 * 7 * 24 * 60 * 60 # 4 weeks
SESSION_COOKIE_SECURE = True
SESSION_COOKIE_HTTPONLY = True
SESSION_EXPIRE_AT_BROWSER_CLOSE = False
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'
SESSION_EXISTS_COOKIE = 'sumo_session'
SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'
#
# Connection information for Elastic
ES_URLS = ['http://127.0.0.1:9200']
# Indexes for reading
ES_INDEXES = {
'default': 'sumo-20130913',
'non-critical': 'sumo-non-critical',
'metrics': 'sumo-metrics',
}
# Indexes for indexing--set this to ES_INDEXES if you want to read to
# and write to the same index.
ES_WRITE_INDEXES = ES_INDEXES
# This is prepended to index names to get the final read/write index
# names used by kitsune. This is so that you can have multiple
# environments pointed at the same ElasticSearch cluster and not have
# them bump into one another.
ES_INDEX_PREFIX = 'sumo'
# Keep indexes up to date as objects are made/deleted.
ES_LIVE_INDEXING = False
# Timeout for querying requests
ES_TIMEOUT = 5
SEARCH_MAX_RESULTS = 1000
SEARCH_RESULTS_PER_PAGE = 10
# Search default settings
SEARCH_DEFAULT_CATEGORIES = (10, 20,)
# IA default settings
IA_DEFAULT_CATEGORIES = (10, 20,)
# The length for which we would like the user to cache search forms
# and results, in minutes.
SEARCH_CACHE_PERIOD = 15
# Maximum length of the filename. Forms should use this and raise
# ValidationError if the length is exceeded.
# @see http://code.djangoproject.com/ticket/9893
# Columns are 250 but this leaves 50 chars for the upload_to prefix
MAX_FILENAME_LENGTH = 200
MAX_FILEPATH_LENGTH = 250
# Default storage engine - ours does not preserve filenames
DEFAULT_FILE_STORAGE = 'kitsune.upload.storage.RenameFileStorage'
# Auth and permissions related constants
LOGIN_URL = '/users/login'
LOGOUT_URL = '/users/logout'
LOGIN_REDIRECT_URL = "/"
LOGOUT_REDIRECT_URL = "/"
REGISTER_URL = '/users/register'
# Video settings, hard coded here for now.
# TODO: figure out a way that doesn't need these values
WIKI_VIDEO_WIDTH = 640
WIKI_VIDEO_HEIGHT = 480
IMAGE_MAX_FILESIZE = 1048576 # 1 megabyte, in bytes
THUMBNAIL_SIZE = 120 # Thumbnail size, in pixels
THUMBNAIL_UPLOAD_PATH = 'uploads/images/thumbnails/'
IMAGE_UPLOAD_PATH = 'uploads/images/'
# A string listing image mime types to accept, comma separated.
# String must not contain double quotes!
IMAGE_ALLOWED_MIMETYPES = 'image/jpeg,image/png,image/gif'
# Topics
TOPIC_IMAGE_PATH = 'uploads/topics/'
# Products
PRODUCT_IMAGE_PATH = 'uploads/products/'
# Email
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
# Read-only mode setup.
READ_ONLY = False
# Turn on read-only mode in settings_local.py by putting this line
# at the VERY BOTTOM: read_only_mode(globals())
def read_only_mode(env):
env['READ_ONLY'] = True
# Replace the default (master) db with a slave connection.
if not env.get('SLAVE_DATABASES'):
raise Exception("We need at least one slave database.")
slave = env['SLAVE_DATABASES'][0]
env['DATABASES']['default'] = env['DATABASES'][slave]
# No sessions without the database, so disable auth.
env['AUTHENTICATION_BACKENDS'] = ('kitsune.sumo.readonlyauth.ReadOnlyBackend',)
# Add in the read-only middleware before csrf middleware.
extra = 'kitsune.sumo.middleware.ReadOnlyMiddleware'
before = 'session_csrf.CsrfMiddleware'
m = list(env['MIDDLEWARE_CLASSES'])
m.insert(m.index(before), extra)
env['MIDDLEWARE_CLASSES'] = tuple(m)
# Celery
import djcelery
djcelery.setup_loader()
BROKER_HOST = 'localhost'
BROKER_PORT = 5672
BROKER_USER = 'kitsune'
BROKER_PASSWORD = '<PASSWORD>'
BROKER_VHOST = 'kitsune'
CELERY_RESULT_BACKEND = 'amqp'
CELERY_IGNORE_RESULT = True
CELERY_ALWAYS_EAGER = True # For tests. Set to False for use.
CELERY_SEND_TASK_ERROR_EMAILS = True
CELERYD_LOG_LEVEL = logging.INFO
CELERYD_CONCURRENCY = 4
CELERY_EAGER_PROPAGATES_EXCEPTIONS = True # Explode loudly during tests.
CELERYD_HIJACK_ROOT_LOGGER = False
# Wiki rebuild settings
WIKI_REBUILD_TOKEN = 'sumo:wiki:full-rebuild'
# Anonymous user cookie
ANONYMOUS_COOKIE_NAME = 'SUMO_ANONID'
ANONYMOUS_COOKIE_MAX_AGE = 30 * 86400 # Seconds
# Top contributors cache settings
TOP_CONTRIBUTORS_CACHE_KEY = 'sumo:TopContributors'
TOP_CONTRIBUTORS_CACHE_TIMEOUT = 60 * 60 * 12
# Do not change this without also deleting all wiki documents:
WIKI_DEFAULT_LANGUAGE = LANGUAGE_CODE
# Gallery settings
GALLERY_DEFAULT_LANGUAGE = WIKI_DEFAULT_LANGUAGE
GALLERY_IMAGE_PATH = 'uploads/gallery/images/'
GALLERY_IMAGE_THUMBNAIL_PATH = 'uploads/gallery/images/thumbnails/'
GALLERY_VIDEO_PATH = 'uploads/gallery/videos/'
GALLERY_VIDEO_URL = None
GALLERY_VIDEO_THUMBNAIL_PATH = 'uploads/gallery/videos/thumbnails/'
GALLERY_VIDEO_THUMBNAIL_PROGRESS_URL = MEDIA_URL + 'img/video-thumb.png'
THUMBNAIL_PROGRESS_WIDTH = 32 # width of the above image
THUMBNAIL_PROGRESS_HEIGHT = 32 # height of the above image
VIDEO_MAX_FILESIZE = 52428800 # 50 megabytes, in bytes
# Customer Care settings
CC_MAX_TWEETS = 500 # Max. no. of tweets in DB
CC_TWEETS_PERPAGE = 100 # How many tweets to collect in one go. Max: 100.
CC_SHOW_REPLIES = True # Show replies to tweets?
CC_ALLOW_REMOVE = True # Allow users to hide tweets?
CC_TOP_CONTRIB_CACHE_KEY = 'sumo-cc-top-contrib-stats'
CC_TOP_CONTRIB_SORT = '1w'
CC_TOP_CONTRIB_LIMIT = 10
CC_STATS_CACHE_TIMEOUT = 24 * 60 * 60 # 24 hours
CC_STATS_WARNING = 30 * 60 * 60 # Warn if JSON data is older than 30 hours
CC_REPLIES_GOAL = 175 # Goal # of replies in 24 hours.
CC_TWEETS_DAYS = 7 # Limit tweets to those from the last 7 days.
# If any of these words show up in a tweet, it probably isn't
# actionable, so don't add it to the AoA.
CC_WORD_BLACKLIST = [
'$1000',
'boycott',
'#boycottfirefox',
'brendan',
'ceo',
'civil',
'cupid',
'donation',
'eich',
'leadership',
'lgbt',
'marriage',
'#mozillagate',
'opposition',
'political',
'prop8',
'proposition',
'protest',
'rights',
'okcupid',
'#nozilla',
'intolerance',
'speech',
'employees',
'boycott',
'fascist',
'amendment',
'diversity',
'bigots',
'rights',
'conservative',
'boycot',
'political',
'tolerance',
'speech',
'censor',
'censorship',
'resign',
'resignation',
'equal',
'equality',
'intolerant',
'intolerance',
'christian',
'StandWithMozilla',
'StandWithFirefox',
'police',
'freedom',
'tcot',
'bigot',
'bigots',
'bigotted',
'bigoted',
'liberal',
'hypocrite',
'hypocrites',
'hypocritical',
'debacle',
'#tcot',
'harassment',
'belief',
'beliefs',
'fascism',
'moral',
'morality',
'morals',
'leftists',
'bullying',
'bully',
'homophobe',
'homophobic',
'homophobia',
'gaystapo',
'#UninstallFirefox',
'#firefoxboycott',
'comercial',
'#NoMásComercialMovistarFirefox',
'#NoMasComercialMovistarFirefox',
]
BITLY_API_URL = 'http://api.bitly.com/v3/shorten?callback=?'
BITLY_LOGIN = None
BITLY_API_KEY = None
TWITTER_COOKIE_SECURE = True
TWITTER_CONSUMER_KEY = ''
TWITTER_CONSUMER_SECRET = ''
TWITTER_ACCESS_TOKEN = ''
TWITTER_ACCESS_TOKEN_SECRET = ''
TIDINGS_FROM_ADDRESS = '<EMAIL>'
# Anonymous watches must be confirmed.
TIDINGS_CONFIRM_ANONYMOUS_WATCHES = True
TIDINGS_MODEL_BASE = 'kitsune.sumo.models.ModelBase'
TIDINGS_REVERSE = 'kitsune.sumo.urlresolvers.reverse'
# Google Analytics settings.
GA_KEY = 'longkey' # Google API client key
GA_ACCOUNT = '<EMAIL>' # Google API Service Account email address
GA_PROFILE_ID = '12345678' # Google Analytics profile id for SUMO prod
GA_START_DATE = date(2012, 11, 10)
MOBILE_COOKIE = 'msumo'
# Directory of JavaScript test files for django_qunit to run
QUNIT_TEST_DIRECTORY = os.path.join('kitsune', 'sumo', 'static', 'js', 'tests')
# Key to access /services/version. Set to None to disallow.
VERSION_CHECK_TOKEN = None
REDIS_BACKENDS = {
#'default': 'redis://localhost:6379?socket_timeout=0.5&db=0',
#'karma': 'redis://localhost:6381?socket_timeout=0.5&db=0',
#'helpfulvotes': 'redis://localhost:6379?socket_timeout=0.5&db=1',
}
HELPFULVOTES_UNHELPFUL_KEY = 'helpfulvotes_topunhelpful'
LAST_SEARCH_COOKIE = 'last_search'
OPTIPNG_PATH = None
# Zendesk info. Fill in the prefix, email and password in settings_local.py.
ZENDESK_URL = 'https://appsmarket.zendesk.com'
ZENDESK_SUBJECT_PREFIX = '[TEST] ' # Set to '' in prod
ZENDESK_USER_EMAIL = ''
ZENDESK_USER_PASSWORD = ''
# Tasty Pie
API_LIMIT_PER_PAGE = 0
# Change the default for XFrameOptionsMiddleware.
X_FRAME_OPTIONS = 'DENY'
# Where to find the about:support troubleshooting addon.
# This is a link to the latest version, whatever that may be.
TROUBLESHOOTER_ADDON_URL = 'https://addons.mozilla.org/firefox/downloads/latest/426841/addon-426841-latest.xpi'
# SurveyGizmo API
SURVEYGIZMO_USER = ''
SURVEYGIZMO_PASSWORD = ''
# Django Rest Framework
REST_FRAMEWORK = {
'DEFAULT_FILTER_BACKENDS': (
'rest_framework.filters.DjangoFilterBackend',
),
'DEFAULT_AUTHENTICATION_CLASSES': (
'rest_framework.authentication.BasicAuthentication',
'rest_framework.authentication.TokenAuthentication',
),
}
# Django-axes settings.
AXES_LOGIN_FAILURE_LIMIT = 10
AXES_LOCK_OUT_AT_FAILURE = True
AXES_USE_USER_AGENT = False
AXES_COOLOFF_TIME = 1 # hour
AXES_BEHIND_REVERSE_PROXY = True
AXES_REVERSE_PROXY_HEADER = 'HTTP_X_CLUSTER_CLIENT_IP'
# Set this to True to wrap each HTTP request in a transaction on this database.
ATOMIC_REQUESTS = True
# XXX Fix this when Bug 1059545 is fixed
CC_IGNORE_USERS = []
``` |
{
"source": "983/cppglsl",
"score": 3
} |
#### File: 983/cppglsl/fix_inout.py
```python
import re, os, sys
def fix_out(s):
s = re.sub("inout\s", "out ", s)
def repl(s):
return s.group(1) + "INOUT(" + s.group(2) + ") "
# one char that is not variable name
# out
# whitespaces
# a variable name
# whirespace
pattern = "([^a-zA-Z0-9])out\s+([a-zA-Z0-9]+)\s"
return re.sub(pattern, repl, s)
if __name__ == "__main__":
n = len(sys.argv)
if n != 3:
print "usage: ./fix_out.py input.hpp output.hpp"
else:
f = open(sys.argv[1])
src = f.read()
f.close()
dst = fix_out(src)
f = open(sys.argv[2], "w")
f.write(dst)
f.close()
``` |
{
"source": "984881878/ProgressiveSearch",
"score": 2
} |
#### File: models/super_nets/super_progressive.py
```python
from queue import Queue
import copy
from modules.mix_op import *
from models.normal_nets.progressive_nets import *
from utils import LatencyEstimator
class ImagenetSuperProgressiveNASNets(ImagenetProgressiveNASNets):
MODE = 'Pretrain' # Pretrain Search Finish
def __init__(self, width_stages, n_cell_stages, conv_candidates, stride_stages,
n_classes=10, width_mult=1, bn_param=(0.1, 1e-3), dropout_rate=0,
enable_mix=True, share_mix_layer=False, share_classifier=False,
enable_init_mix=True, fix_determined=False):
input_channel = make_divisible(32 * width_mult, 8)
first_cell_width = make_divisible(16 * width_mult, 8) # 这里的16可以调整 24,32都可以尝试
for i in range(len(width_stages)):
width_stages[i] = make_divisible(width_stages[i] * width_mult, 8)
# first conv layer
first_conv = ConvLayer(
3, input_channel, kernel_size=3, stride=2, use_bn=True, act_func='relu6', ops_order='weight_bn_act'
)
first_block_conv = build_candidate_ops(['3x3_MBConv1'], input_channel, first_cell_width, 1)[0]
first_block = MobileInvertedResidualBlock(first_block_conv, None)
input_channel = first_cell_width
# blocks
blocks = [first_block]
# blocks = []
for width, n_cell, s in zip(width_stages, n_cell_stages, stride_stages):
for i in range(n_cell):
if i == 0:
stride = s
else:
stride = 1
if stride == 1 and input_channel == width:
modified_conv_candidates = conv_candidates + ['Zero']
else:
modified_conv_candidates = conv_candidates
conv_op = MixedEdge(candidate_ops=build_candidate_ops(
modified_conv_candidates, input_channel, width, stride,
), n_classes=n_classes, enable_mix=enable_mix, share_mix_layer=share_mix_layer,
share_classifier=share_classifier, dropout_rate=dropout_rate
)
# shortcut
if stride == 1 and input_channel == width:
shortcut = IdentityLayer(input_channel, input_channel)
else:
shortcut = None
inverted_residual_block = MobileInvertedResidualBlock(conv_op, shortcut)
blocks.append(inverted_residual_block)
input_channel = width
# feature mix layer
last_channel = make_divisible(1280 * width_mult, 8) if width_mult > 1.0 else 1280
feature_mix_layer = ConvLayer(
input_channel, last_channel, kernel_size=1, use_bn=True, act_func='relu6', ops_order='weight_bn_act',
)
classifier = LinearLayer(last_channel, n_classes, dropout_rate=dropout_rate)
super(ImagenetSuperProgressiveNASNets, self).__init__(first_conv, blocks, feature_mix_layer, classifier,
enable_init_mix, fix_determined)
# set bn param
self.set_bn_param(momentum=bn_param[0], eps=bn_param[1])
def forward(self, x):
if ImagenetSuperProgressiveNASNets.MODE == 'Pretrain':
x = self.first_conv(x)
for i in range(self.curLayer):
x = self.blocks[i](x)
if self.init_mix is not None:
x = self.init_mix(x)
# x = F.adaptive_avg_pool2d(x, 1)
# x = x.view(x.size(0), -1)
batch_size, num_channels, H, W = x.size()
x = x.view(batch_size, num_channels, -1).mean(dim=2)
x = self.init_classifier(x)
elif ImagenetSuperProgressiveNASNets.MODE == 'Search':
if self.fix_determined:
with torch.no_grad():
x = self.first_conv(x)
for i in range(self.curLayer):
x = self.blocks[i](x)
else:
x = self.first_conv(x)
for i in range(self.curLayer):
x = self.blocks[i](x)
x = self.cur_block(x) # generator
elif ImagenetSuperProgressiveNASNets.MODE == 'Determined_train':
x = self.first_conv(x)
for i in range(self.curLayer):
x = self.blocks[i](x)
# assert self.cur_block_mixlayer.n_choices == 1
x = self.cur_block(x)
if self.cur_block_mixlayer.enable_mix:
x = self.cur_block_mixlayer.candidate_ops_mixed_layer(x)
# x = F.adaptive_avg_pool2d(x, 1)
# x = x.view(x.size(0), -1)
batch_size, num_channels, H, W = x.size()
x = x.view(batch_size, num_channels, -1).mean(dim=2)
x = self.cur_block_mixlayer.candidate_ops_classifier(x)
else: # MODE == 'Finish'
x = super(ImagenetSuperProgressiveNASNets, self).forward(x)
return x
def add_acc(self, acc):
self.cur_block_mixlayer.accuracy.append(acc)
def add_infer_latency(self, latency):
self.cur_block_mixlayer.infer_latency.append(latency)
@property
def cur_block(self):
return self.blocks[self.curLayer]
@property
def cur_block_mixlayer(self):
return self.blocks[self.curLayer].body
@property
def config(self):
raise ValueError('not needed')
@staticmethod
def build_from_config(config):
raise ValueError('not needed')
def convert_to_normal_net(self):
self.init_mix = None
self.init_classifier = None
for i, module in enumerate(self.blocks):
mic = module.mobile_inverted_conv
if isinstance(mic, MixedEdge):
assert mic.n_choices == 1
if i == self.totalSearchLayer - 1:
if mic.candidate_ops_mixed_layer is not None:
self.feature_mix_layer = mic.candidate_ops_mixed_layer
if mic.candidate_ops_classifier is not None \
and mic.candidate_ops_classifier.in_features == self.classifier.in_features:
self.classifier = mic.candidate_ops_classifier
module.mobile_inverted_conv = mic.candidate_ops[0]
assert self.curLayer == self.totalSearchLayer
class Cifar10SuperProgressiveNASNets(Cifar10ProgressiveNASNets):
MODE = 'Pretrain' # Pretrain Search Determined_train Finish
def __init__(self, depth, alpha, conv_candidates, n_classes=10, bn_param=(0.1, 1e-3), dropout_rate=0,
enable_mix=False, share_mix_layer=True, share_classifier=True, enable_init_mix=False,
fix_determined=False):
init_channel = 16
n = int((depth - 2) / 9) # 92
addrate = alpha / (3 * n * 1.0) # 32
first_conv = ConvLayer(
3, init_channel, kernel_size=3, stride=1, use_bn=True, act_func='relu', ops_order='weight_bn_act'
)
conv_candidates += ['Zero']
blocks = []
in_channel, real_in_channel = init_channel, init_channel
for i in range(3):
for j in range(0, n):
if j == 0 and i != 0:
shortcut = PoolingLayer(real_in_channel, real_in_channel, 'avg', kernel_size=2, stride=2)
stride = 2
else:
shortcut = IdentityLayer(real_in_channel, real_in_channel)
stride = 1
out_channel = in_channel + addrate
conv_op = MixedEdge(candidate_ops=build_candidate_ops(
conv_candidates, real_in_channel, int(round(out_channel)), stride,
), n_classes=n_classes, enable_mix=enable_mix, share_mix_layer=share_mix_layer,
share_classifier=share_classifier, dropout_rate=dropout_rate
)
block = BottleneckBlock(conv_op, shortcut)
blocks.append(block)
real_in_channel = blocks[-1].body.candidate_ops[0].real_outchannels
in_channel = out_channel
last_channel = blocks[-1].body.candidate_ops[0].real_outchannels
classifier = LinearLayer(last_channel, n_classes, dropout_rate=dropout_rate)
super(Cifar10SuperProgressiveNASNets, self).__init__(first_conv, blocks, classifier,
enable_init_mix, fix_determined)
# set bn param
self.set_bn_param(momentum=bn_param[0], eps=bn_param[1])
def forward(self, x):
if Cifar10SuperProgressiveNASNets.MODE == 'Pretrain':
x = self.first_conv(x)
for i in range(self.curLayer):
x = self.blocks[i](x)
if self.init_mix is not None:
x = self.init_mix(x)
# x = F.adaptive_avg_pool2d(x, 1)
# x = x.view(x.size(0), -1)
batch_size, num_channels, H, W = x.size()
x = x.view(batch_size, num_channels, -1).mean(dim=2)
x = self.init_classifier(x)
elif Cifar10SuperProgressiveNASNets.MODE == 'Search':
if self.fix_determined:
with torch.no_grad():
x = self.first_conv(x)
for i in range(self.curLayer):
x = self.blocks[i](x)
else:
x = self.first_conv(x)
for i in range(self.curLayer):
x = self.blocks[i](x)
x = self.cur_block(x) # generator
elif Cifar10SuperProgressiveNASNets.MODE == 'Determined_train':
x = self.first_conv(x)
for i in range(self.curLayer):
x = self.blocks[i](x)
# assert self.cur_block_mixlayer.n_choices == 1
x = self.cur_block(x)
if self.cur_block_mixlayer.enable_mix:
x = self.cur_block_mixlayer.candidate_ops_mixed_layer(x)
# x = F.adaptive_avg_pool2d(x, 1)
# x = x.view(x.size(0), -1)
batch_size, num_channels, H, W = x.size()
x = x.view(batch_size, num_channels, -1).mean(dim=2)
x = self.cur_block_mixlayer.candidate_ops_classifier(x)
else: # MODE == 'Finish'
x = super(Cifar10SuperProgressiveNASNets, self).forward(x)
return x
def add_acc(self, acc):
self.cur_block_mixlayer.accuracy.append(acc)
def add_infer_latency(self, latency):
self.cur_block_mixlayer.infer_latency.append(latency)
@property
def cur_block(self):
return self.blocks[self.curLayer]
@property
def cur_block_mixlayer(self):
return self.blocks[self.curLayer].body
@property
def config(self):
raise ValueError('not needed')
@staticmethod
def build_from_config(config):
raise ValueError('not needed')
def convert_to_normal_net(self):
self.init_mix = None
self.init_classifier = None
for i, module in enumerate(self.blocks):
mic = module.bottleneck
if isinstance(mic, MixedEdge):
assert mic.n_choices == 1
if i == self.totalSearchLayer - 1:
if mic.candidate_ops_classifier is not None \
and mic.candidate_ops_classifier.in_features == self.classifier.in_features:
self.classifier = mic.candidate_ops_classifier
module.bottleneck = mic.candidate_ops[0]
# module.body = mic.candidate_ops[0] # the body setter seems not work
assert self.curLayer == self.totalSearchLayer
```
#### File: 984881878/ProgressiveSearch/random_architecture_generator.py
```python
import os
import tensorwatch as tw
import torch
from models.super_nets.super_progressive import SuperProgressiveNASNets
from modules.mix_op import MixedEdge
import json
arch1 = [17, 16, 10, 10, 16, 11, 4, 8, 14, 17, 9, 12, 3, 12, 12, 6, 8, 9, 12, 1, 1]
arch2 = [17, 17, 16, 10, 8, 11, 7, 8, 16, 1, 1, 7, 16, 5, 2, 13, 17, 5, 2, 5, 1]
arch = arch2
width_stages = [24, 40, 80, 96, 192, 320]
n_cell_stages = [4, 4, 4, 4, 4, 1]
conv_candidates = [
'3x3_MBConv1', '3x3_MBConv2', '3x3_MBConv3', '3x3_MBConv4', '3x3_MBConv5', '3x3_MBConv6',
'5x5_MBConv1', '5x5_MBConv2', '5x5_MBConv3', '5x5_MBConv4', '5x5_MBConv5', '5x5_MBConv6',
'7x7_MBConv1', '7x7_MBConv2', '7x7_MBConv3', '7x7_MBConv4', '7x7_MBConv5', '7x7_MBConv6',
]
stride_stages = [2, 2, 2, 1, 2, 1]
def main():
net = SuperProgressiveNASNets(width_stages, n_cell_stages, conv_candidates, stride_stages,
n_classes=10, width_mult=1, bn_param=(0.1, 1e-3), dropout_rate=0,
enable_mix=False, share_mix_layer=False, share_classifier=False,
enable_init_mix=False)
for i in arch:
net.blocks[net.curLayer].mobile_inverted_conv = net.cur_block_mixlayer.candidate_ops[i]
net.blocks[net.curLayer].is_mixed_edge = isinstance(net.cur_block_mixlayer, MixedEdge)
net.curLayer = net.curLayer + 1
assert net.curLayer == net.totalSearchLayer
SuperProgressiveNASNets.MODE = 'Finish'
# net.eval()
# input = torch.rand([1, 3, 32, 32])
# output = net(input)
# print(output.shape)
# drawing = tw.draw_model(net, [1, 3, 32, 32]) # orientation='LR'
# drawing.save('abc.png')
json.dump(super(SuperProgressiveNASNets, net).config,
open('net_config.txt', 'w'), indent=4)
if __name__ == '__main__':
main()
```
#### File: ProgressiveSearch/utils/latency_estimator.py
```python
import yaml
import os
import sys
import hashlib
try:
from urllib import urlretrieve
except ImportError:
from urllib.request import urlretrieve
def calculate_md5(fpath, chunk_size=1024 * 1024):
md5 = hashlib.md5()
with open(fpath, 'rb') as f:
for chunk in iter(lambda: f.read(chunk_size), b''):
md5.update(chunk)
return md5.hexdigest()
def check_md5(fpath, md5, **kwargs):
return md5 == calculate_md5(fpath, **kwargs)
def check_integrity(fpath, md5=None):
if not os.path.isfile(fpath):
return False
if md5 is None:
return True
return check_md5(fpath, md5)
def download_url(url, md5, model_dir='~/.torch/proxyless_nas', overwrite=False):
target_dir = url.split('//')[-1]
target_dir = os.path.dirname(target_dir)
model_dir = os.path.expanduser(model_dir)
model_dir = os.path.join(model_dir, target_dir)
if not os.path.exists(model_dir):
os.makedirs(model_dir)
filename = url.split('/')[-1]
cached_file = os.path.join(model_dir, filename)
sys.stderr.write('Start downloading: "{}" to {}\n'.format(url, cached_file))
if not check_integrity(cached_file, md5):
if not os.path.exists(cached_file) or overwrite:
sys.stderr.write('Downloading......\n')
urlretrieve(url, cached_file)
else:
sys.stderr.write('Files already downloaded and verified\n')
sys.stderr.write('Finished\n')
return cached_file
class LatencyEstimator(object):
def __init__(self, url='https://hanlab.mit.edu/files/proxylessNAS/LatencyTools/mobile_trim.yaml'):
self.md5 = '07b8a4b9e39a7e9c027d4f7e717b7b09'
fname = download_url(url, self.md5, overwrite=True)
with open(fname, 'r') as fp:
self.lut = yaml.load(fp)
@staticmethod
def repr_shape(shape):
if isinstance(shape, (list, tuple)):
return 'x'.join(str(_) for _ in shape)
elif isinstance(shape, str):
return shape
else:
return TypeError
def predict(self, ltype: str, _input, output, expand=None, kernel=None, stride=None, idskip=None, ):
"""
:param ltype:
Layer type must be one of the followings
1. `Conv`: The initial 3x3 conv with stride 2.
2. `Conv_1`: The upsample 1x1 conv that increases num_filters by 4 times.
3. `Logits`: All operations after `Conv_1`.
4. `expanded_conv`: MobileInvertedResidual
:param _input: input shape (h, w, #channels)
:param output: output shape (h, w, #channels)
:param expand: expansion ratio
:param kernel: kernel size
:param stride:
:param idskip: indicate whether has the residual connection
"""
infos = [ltype, 'input:%s' % self.repr_shape(_input), 'output:%s' % self.repr_shape(output), ]
if ltype in ('expanded_conv',):
assert None not in (expand, kernel, stride, idskip)
infos += ['expand:%d' % expand, 'kernel:%d' % kernel, 'stride:%d' % stride, 'idskip:%d' % idskip]
key = '-'.join(infos)
return self.lut[key]['mean']
if __name__ == '__main__':
est = LatencyEstimator()
s = est.predict('expanded_conv', _input=(112, 112, 16), output=(56, 56, 24), expand=3, kernel=5, stride=2, idskip=0)
print(s)
``` |
{
"source": "98672794/AutoWeb2022",
"score": 2
} |
#### File: AutoWeb2022/O202202061825/ATWFolder.py
```python
import ATWREADME
###################################################################################
############################################################# ATWFolder說明
def README():
ThisREADME = [
'*** ATWFolder.README ***', # PYfileName
'_SetFolder(v1,sel) =\n 生成文件夾',
'_GetFolder() =\n 獲取檔案路徑和當前工作目錄',
'_MakeJobFolder(FolderName) =\n 在當前文件夾创工作目錄',
' ==== 恭賀新禧 ==== ',
'mokaki202202051218',
'https://98672794.github.io/'
]
ATWREADME._READYourME(ThisREADME)
###################################################################################
################################################################ AutoWeb 生成文件夾
def _SetFolder(v1,sel): # (文件夾名,動作)
#print ('_SetFolder\n'+ str(v1) +'\n')
# MakeFolder = MakeFolder
if sel == 'MakeFolder':
# 查 文件夾 在否 ./NOW
folder = ATWREADME.os.path.exists(v1)
if not folder:
ATWREADME.os.makedirs(v1) # makedirs 文件夾不在创，在ＥＲＲＯＲ
print ("\n*** 成功创建文件夾 ",v1," ***\n")
#_AutoWebLanguageSetting("\n***!!成功创建文件夾!!!!!*****\n")
#print (Talk0,LanguageText,v1)
###################################################################################
######################################################### 獲取檔案路徑和當前工作目錄
# https://www.delftstack.com/zh-tw/howto/python/python-get-path/
def _GetFolder():
# print ('_GetFolder')
NowFolder = (ATWREADME.os.path.dirname(ATWREADME.os.path.abspath(__file__)))
#print ('_GetFolder,',NowFolder)
return NowFolder
###################################################################################
############################################################# 在當前文件夾创工作目錄
def _MakeJobFolder(FolderName):
# 要創的文件夾名 = FolderName
# 獲取當前工作目錄
NowFolder = _GetFolder()
# 文件夾 全名
NowJobFolder = NowFolder + '\\' + FolderName
# 创文件夾 if 冇
_SetFolder(NowJobFolder,'MakeFolder')
return NowJobFolder
if __name__ == "__main__":
README()
```
#### File: 98672794/AutoWeb2022/z_ATWFileList.py
```python
import os
def ATWFileList(HtmlUrl,n2):
global ATWFileList0
# ATWFileList
# 找出現在目錄所有.py
L1 = []
L1.clear()
ss = os.listdir(HtmlUrl)
for item in ss:
if(item.endswith(n2)):
L1.append(item)
i = 0
while i < len(L1):
print(' ',i,'=====',L1[i],'\n')
i+=1
while True:
ImportPyUrl = input('\n 請填寫文件號\n 或直接填寫文件名和路徑，如 ./path'+n2+'\n')
# 不能空值
if ImportPyUrl == '':
continue
# 查 ImportPyUrl 是否 int
try:
ATWFileList0 = L1[int(ImportPyUrl)]
break
except:
break
# 不存在，請從試 返回 ImportPyUrl
#ATWFileList0 = ImportPyUrl
###########################################
######################################################################################################
######################################################################## 用「例外處理」檢查檔案是否存在
def IfHaveFile(target_file):
try:
file = open(target_file, 'r')
except FileNotFoundError:
gfdg = (target_file + '不存在')
OK = 0
except PermissionError:
gfdg = (target_file + '不是檔案')
OK = 0
else:
gfdg = (target_file + '檔案存在')
OK = 1
file.close()
print ('gfdg,',gfdg)
return OK
```
#### File: 98672794/AutoWeb2022/z_ATWGetListKeyTxt.py
```python
def ATWGetListKeyTxt(KeyTxt,List,NewTxt,sel):
global ATWGetListKeyTxt0
global ATWGetListKeyTxt1Nb
ATWGetListKeyTxt0 = []
ATWGetListKeyTxt0.clear()
if sel == 'LGT':
# kw = List 中所有
for kw in List:
# 如 關鍵字在 add list
if KeyTxt in kw:
ATWGetListKeyTxt0.append(kw)
if sel == 'LCT':
# List 轉新 關鍵字
i = 0
while i < len(List):
ttt = List[i] # QQQQQQQQ
if KeyTxt == ttt:
#print(' List[',i,'] =\n{',List[i],'}\n')
List[i] = NewTxt+"\n"
ATWGetListKeyTxt1Nb = i
#print(' List[',i,'] =\n{',List[i],'}\n')
i+=1
for kw in List:
ATWGetListKeyTxt0.append(kw)
#print(' ATWGetListKeyTxt0 =\n{',ATWGetListKeyTxt0,'}\n')
###########################################
# sel == 'LGT' == List中找關鍵字
# sel == 'LCT' == List 轉新 關鍵字
```
#### File: 98672794/AutoWeb2022/z_ATWReadFile.py
```python
def ATWReadFile(OutData,NewData,sel):
#global ATWReadFileList0
#print(' *OutData** ',OutData,' *** ')
if sel == 'LSF':
# loop Save File loop save
f2p = open( NewData , "a", encoding="utf-8" )
f2p.writelines(OutData+'\n')
f2p.close()
# List to File list 轉 新文件 w = 创新删舊
if sel == 'LTF':
f2p = open( NewData , "w", encoding="utf-8" )
count=len(OutData) # OutData = list
i = 0
while i < count:
f2p.writelines(OutData[i])
i+=1
f2p.close()
# File to List 查看文件每一行 返回 List
elif sel == 'FTL':
with open( OutData , 'r', encoding="utf-8" ) as fp:
count=len(open( OutData , 'r', encoding="utf-8" ) .readlines())
ATWReadFileList0 = []
ATWReadFileList0.clear()
i = 0
while i < count:
line = fp.readline()
ATWReadFileList0.append(line)
i+=1
return ATWReadFileList0
# File to File 抄寫新文件 w = 创新删舊
elif sel == 'FTF':
with open( OutData , 'r', encoding="utf-8" ) as fp:
count=len(open( OutData , 'r', encoding="utf-8" ) .readlines())
f2p = open( NewData , "w", encoding="utf-8" )
i = 0
while i < count:
line = fp.readline()
f2p.writelines(line)
i+=1
f2p.close()
#print("\n *** SAVE ",NewData, " DONE *** \n")
###########################################
# sel == 'LTF': List to File list 轉 新文件
# sel == 'FTF': File to File 抄寫新文件
# sel == 'FTL': File to List 查看文件每一行 返回 List
# sel == 'LSF': loop Save File loop save
# /././.
# List to File list 轉 新文件 w = 创新删舊
def ListToFile(List,FileName):
count=len(List) # OutData = list
i = 0
with open(FileName, 'w', encoding="utf-8") as kf:
while i < count:
kf.writelines(List[i])
i+=1
kf.close()
# 202111021505
# Txt To list 多文用 to 轉 list
# https://www.kite.com/python/answers/how-to-read-a-text-file-into-a-list-in-python
def TxtToList(txt,to):
NewTxt = txt.split(to)
return NewTxt
``` |
{
"source": "987123879113/firebeatrtc",
"score": 3
} |
#### File: 987123879113/firebeatrtc/rtcpass.py
```python
class BitArrayBuffer:
def __init__(self, len):
self.buffer = [0] * len
def xor(self, buffer2):
buffer1_len = len(self.buffer)
buffer2_len = len(buffer2.buffer)
output_buffer_len = min(buffer1_len, buffer2_len)
new_buffer = [0] * output_buffer_len
for i in range(output_buffer_len):
new_buffer[i] = self.buffer[i] ^ buffer2.buffer[i]
self.buffer = new_buffer
def read(self, offset, bits):
x = [1 << i for i in range(bits) if self.buffer[offset+i] != 0]
return sum(x) if x else 0
def write(self, offset, bits, input):
for i in range(bits):
self.buffer[offset + i] = 1 if (input & (1 << i)) != 0 else 0
class KonamiRand:
def __init__(self):
self.buffer_len = 55
self.buffer = [0] * (self.buffer_len + 2) # +2 for seed and read index
def get_safe_val(self, val):
return (val + (1000000000 if val < 0 else 0)) & 0xffffffff
def scramble(self):
def _inner_scramble(start, end, offset1, offset2):
for i in range(start, end):
val = self.get_safe_val(self.buffer[offset1 + i] - self.buffer[offset2 + i])
self.buffer[offset1 + i] = val
_inner_scramble(1, 25, 0, 0x1f)
_inner_scramble(25, 56, 0, -0x18)
def seed(self, input):
self.buffer[-2] = input & 0xffffffff
val = 1
for i in range(1, 55):
offset = (i * 21) % 55
self.buffer[offset] = val
val = self.get_safe_val(input - val)
input = self.buffer[offset]
self.scramble()
self.scramble()
self.scramble()
self.buffer[-1] = self.buffer_len
def next(self):
self.buffer[-1] += 1
if self.buffer[-1] > self.buffer_len:
self.scramble()
self.buffer[-1] = 1
return self.buffer[self.buffer[-1]]
def base36encode(val, len, alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"):
output = ""
for _ in range(len):
val, i = divmod(val, 36)
output += alphabet[i]
return output
def base36decode(val, alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"):
output = 0
for i, c in enumerate(val.upper()):
output += alphabet.index(c) * (36 ** i)
return output & 0xffffffff
def verify_date(date):
# Konami's logic
return date < 0xf2000 and ((date / 100) % 100) < 13 and (date % 100) < 32
def decode_firebeat_recovery_password(input):
def buffer_to_str(buffer):
parts = []
for i in range(0, 70, 10):
v = buffer.read(i, 10)
parts.append((v // 100) % 10)
parts.append((v // 10) % 10)
parts.append(v % 10)
v = buffer.read(70, 7)
parts.append((v // 10) % 10)
parts.append(v % 10)
return "".join([str(c) for c in parts])
input = input.replace("-", "")
krand = KonamiRand()
output_buffer = BitArrayBuffer(112)
output_buffer.write(0, 31, base36decode(input[:6]))
output_buffer.write(31, 31, base36decode(input[6:12]))
output_buffer.write(62, 31, base36decode(input[12:18]))
output_buffer.write(93, 10, base36decode(input[18:]))
seed = output_buffer.read(93, 10)
checksum_base = output_buffer.read(77, 16)
krand.seed(seed * 3 + 0x70)
checksum = (checksum_base ^ krand.next()) & 0xffff
krand.seed(seed * 7 + checksum * 5 + 0x70)
xor_buffer = BitArrayBuffer(108)
xor_buffer.write(0, 32, krand.next())
xor_buffer.write(32, 32, krand.next())
xor_buffer.write(64, 13, krand.next())
output_buffer.xor(xor_buffer)
internal_sum = sum([
output_buffer.read(0, 12),
output_buffer.read(12, 12),
output_buffer.read(24, 12),
output_buffer.read(36, 12),
output_buffer.read(48, 12),
output_buffer.read(60, 12),
output_buffer.read(72, 5),
]) & 0xffff
output_str = buffer_to_str(output_buffer)
serial_num = output_str[:9]
keycode_num = output_str[9:17]
date_num = output_str[17:]
is_valid = checksum == internal_sum and len(serial_num) == 9 and len(keycode_num) == 8 and len(date_num) == 6 and verify_date(int(date_num))
return {
'password': input,
'decoded': output_str,
'serial': serial_num,
'keycode': keycode_num,
'date': date_num,
'is_valid': is_valid,
}
def encode_firebeat_recovery_password(serial, keycode, date, seed, verify_password=False):
def generate_key(serial, keycode, date):
assert(len(serial) == 9)
assert(len(keycode) == 8)
snum = "".join(["%c" % chr(ord(c) - (0x31 if ord(c) >= 0x61 else 0)) for c in serial.lower()])
nnum = keycode
dnum = "%06d" % (date if verify_date(date) else 0)
return "".join([snum, nnum, dnum])
def str_to_buffer(input):
output_buffer = BitArrayBuffer(112)
for i in range(len(input) // 3):
output_buffer.write(i*10, 10, int(input[i*3:(i*3)+3]))
i = len(input) // 3
output_buffer.write(70, 7, int(input[i*3:(i*3)+3]))
return output_buffer
date = int(date)
seed = int(seed)
k = generate_key(serial, keycode, date)
output_buffer = str_to_buffer(k)
internal_sum = sum([
output_buffer.read(0, 12),
output_buffer.read(12, 12),
output_buffer.read(24, 12),
output_buffer.read(36, 12),
output_buffer.read(48, 12),
output_buffer.read(60, 12),
output_buffer.read(72, 5),
]) & 0xffff
krand = KonamiRand()
krand.seed(seed * 3 + 0x70)
checksum = (internal_sum ^ krand.next()) & 0xffff
output_buffer.write(77, 16, checksum)
output_buffer.write(93, 10, seed)
krand.seed(seed * 7 + internal_sum * 5 + 0x70)
xor_buffer = BitArrayBuffer(108)
xor_buffer.write(0, 32, krand.next())
xor_buffer.write(32, 32, krand.next())
xor_buffer.write(64, 13, krand.next())
output_buffer.xor(xor_buffer)
parts = [
base36encode(output_buffer.read(0, 31), 6),
base36encode(output_buffer.read(31, 31), 6),
base36encode(output_buffer.read(62, 31), 6),
base36encode(output_buffer.read(93, 10), 2),
]
parts_str = "".join(parts)
password = "-".join([parts_str[i:i+5] for i in range(0, len(parts_str), 5)])
if verify_password:
decoded_password = decode_firebeat_recovery_password(password)
if not decoded_password['is_valid']:
return "FAILED"
return password
``` |
{
"source": "987Frogh/project-makehuman",
"score": 3
} |
#### File: diagram/actions/activitynodes.py
```python
import ast
import math
from gaphas.constraint import EqualsConstraint, LessThanConstraint
from gaphas.geometry import Rectangle, distance_line_point
from gaphas.item import Handle, Item, LinePort
from gaphas.state import observed, reversible_property
from gaphas.util import path_ellipse
from gaphor import UML
from gaphor.diagram.presentation import ElementPresentation, Named
from gaphor.diagram.shapes import Box, EditableText, IconBox, Text
from gaphor.diagram.support import represents
from gaphor.UML.modelfactory import stereotypes_str
DEFAULT_JOIN_SPEC = "and"
def no_movable_handles(item):
for h in item._handles:
h.movable = False
class ActivityNodeItem(Named):
"""Basic class for simple activity nodes.
Simple activity node is not resizable.
"""
@represents(UML.InitialNode)
class InitialNodeItem(ElementPresentation, ActivityNodeItem):
"""
Representation of initial node. Initial node has name which is put near
top-left side of node.
"""
def __init__(self, id=None, model=None):
super().__init__(id, model)
no_movable_handles(self)
self.shape = IconBox(
Box(style={"min-width": 20, "min-height": 20}, draw=draw_initial_node),
# Text should be left-top
Text(
text=lambda: stereotypes_str(self.subject),
style={"min-width": 0, "min-height": 0},
),
EditableText(text=lambda: self.subject and self.subject.name or ""),
)
self.watch("subject[NamedElement].name")
self.watch("subject.appliedStereotype.classifier.name")
def draw_initial_node(_box, context, _bounding_box):
cr = context.cairo
r = 10
d = r * 2
path_ellipse(cr, r, r, d, d)
cr.set_line_width(0.01)
cr.fill()
@represents(UML.ActivityFinalNode)
class ActivityFinalNodeItem(ElementPresentation, ActivityNodeItem):
"""Representation of activity final node. Activity final node has name
which is put near right-bottom side of node.
"""
def __init__(self, id=None, model=None):
super().__init__(id, model)
no_movable_handles(self)
self.shape = IconBox(
Box(
style={"min-width": 30, "min-height": 30}, draw=draw_activity_final_node
),
# Text should be right-bottom
Text(
text=lambda: stereotypes_str(self.subject),
style={"min-width": 0, "min-height": 0},
),
EditableText(text=lambda: self.subject and self.subject.name or ""),
)
self.watch("subject[NamedElement].name")
self.watch("subject.appliedStereotype.classifier.name")
def draw_activity_final_node(_box, context, _bounding_box):
cr = context.cairo
inner_radius = 10
outer_radius = 15
r = outer_radius + 1
d = inner_radius * 2
path_ellipse(cr, r, r, d, d)
cr.set_line_width(0.01)
cr.fill()
d = r * 2
path_ellipse(cr, r, r, d, d)
cr.set_line_width(0.01)
cr.set_line_width(2)
cr.stroke()
@represents(UML.FlowFinalNode)
class FlowFinalNodeItem(ElementPresentation, ActivityNodeItem):
"""
Representation of flow final node. Flow final node has name which is
put near right-bottom side of node.
"""
def __init__(self, id=None, model=None):
super().__init__(id, model)
no_movable_handles(self)
self.shape = IconBox(
Box(style={"min-width": 20, "min-height": 20}, draw=draw_flow_final_node),
# Text should be right-bottom
Text(
text=lambda: stereotypes_str(self.subject),
style={"min-width": 0, "min-height": 0},
),
EditableText(text=lambda: self.subject and self.subject.name or ""),
)
self.watch("subject[NamedElement].name")
self.watch("subject.appliedStereotype.classifier.name")
def draw_flow_final_node(_box, context, _bounding_box):
cr = context.cairo
r = 10
d = r * 2
path_ellipse(cr, r, r, d, d)
cr.stroke()
dr = (1 - math.sin(math.pi / 4)) * r
cr.move_to(dr, dr)
cr.line_to(d - dr, d - dr)
cr.move_to(dr, d - dr)
cr.line_to(d - dr, dr)
cr.stroke()
@represents(UML.DecisionNode)
class DecisionNodeItem(ElementPresentation, ActivityNodeItem):
"""
Representation of decision or merge node.
"""
def __init__(self, id=None, model=None):
super().__init__(id, model)
no_movable_handles(self)
self._combined = None
self.shape = IconBox(
Box(style={"min-width": 20, "min-height": 30}, draw=draw_decision_node),
# Text should be left-top
Text(
text=lambda: stereotypes_str(self.subject),
style={"min-width": 0, "min-height": 0},
),
EditableText(text=lambda: self.subject and self.subject.name or ""),
)
self.watch("subject[NamedElement].name")
self.watch("subject.appliedStereotype.classifier.name")
def save(self, save_func):
if self._combined:
save_func("combined", self._combined, reference=True)
super().save(save_func)
def load(self, name, value):
if name == "combined":
self._combined = value
else:
super().load(name, value)
@observed
def _set_combined(self, value):
self._combined = value
combined = reversible_property(lambda s: s._combined, _set_combined)
def draw_decision_node(_box, context, _bounding_box):
"""
Draw diamond shape, which represents decision and merge nodes.
"""
cr = context.cairo
r = 15
r2 = r * 2 / 3
cr.move_to(r2, 0)
cr.line_to(r2 * 2, r)
cr.line_to(r2, r * 2)
cr.line_to(0, r)
cr.close_path()
cr.stroke()
@represents(UML.ForkNode)
class ForkNodeItem(UML.Presentation, Item):
"""
Representation of fork and join node.
"""
def __init__(self, id=None, model=None):
super().__init__(id, model)
h1, h2 = Handle(), Handle()
self._handles.append(h1)
self._handles.append(h2)
self._ports.append(LinePort(h1.pos, h2.pos))
self._combined = None
self.shape = IconBox(
Box(style={"min-width": 0, "min-height": 45}, draw=self.draw_fork_node),
Text(
text=lambda: stereotypes_str(self.subject),
style={"min-width": 0, "min-height": 0},
),
EditableText(text=lambda: self.subject and self.subject.name or ""),
Text(
text=lambda: isinstance(self.subject, UML.JoinNode)
and self.subject.joinSpec not in (None, DEFAULT_JOIN_SPEC)
and f"{{ joinSpec = {self.subject.joinSpec} }}"
or "",
style={"min-width": 0, "min-height": 0},
),
)
self.watch("subject[NamedElement].name")
self.watch("subject.appliedStereotype.classifier.name")
self.watch("subject[JoinNode].joinSpec")
def save(self, save_func):
save_func("matrix", tuple(self.matrix))
save_func("height", float(self._handles[1].pos.y))
if self._combined:
save_func("combined", self._combined, reference=True)
super().save(save_func)
def load(self, name, value):
if name == "matrix":
self.matrix = ast.literal_eval(value)
elif name == "height":
self._handles[1].pos.y = ast.literal_eval(value)
elif name == "combined":
self._combined = value
else:
# DiagramItem.load(self, name, value)
super().load(name, value)
@observed
def _set_combined(self, value):
# self.preserve_property('combined')
self._combined = value
combined = reversible_property(lambda s: s._combined, _set_combined)
def setup_canvas(self):
assert self.canvas
super().setup_canvas()
h1, h2 = self._handles
cadd = self.canvas.solver.add_constraint
c1 = EqualsConstraint(a=h1.pos.x, b=h2.pos.x)
c2 = LessThanConstraint(smaller=h1.pos.y, bigger=h2.pos.y, delta=30)
self.__constraints = (cadd(c1), cadd(c2))
list(map(self.canvas.solver.add_constraint, self.__constraints))
def teardown_canvas(self):
assert self.canvas
super().teardown_canvas()
list(map(self.canvas.solver.remove_constraint, self.__constraints))
def pre_update(self, context):
cr = context.cairo
_, h2 = self.handles()
_, height = self.shape.size(cr)
h2.pos.y = max(h2.pos.y, height)
def draw(self, context):
h1, h2 = self.handles()
height = h2.pos.y - h1.pos.y
self.shape.draw(context, Rectangle(0, 0, 1, height))
def draw_fork_node(self, _box, context, _bounding_box):
"""
Draw vertical line - symbol of fork and join nodes. Join
specification is also drawn above the item.
"""
cr = context.cairo
cr.set_line_width(6)
h1, h2 = self._handles
cr.move_to(h1.pos.x, h1.pos.y)
cr.line_to(h2.pos.x, h2.pos.y)
cr.stroke()
def point(self, pos):
h1, h2 = self._handles
d, p = distance_line_point(h1.pos, h2.pos, pos)
# Substract line_width / 2
return d - 3
```
#### File: gaphor/diagram/diagramtoolbox.py
```python
from typing import Optional, Sequence, Tuple
from gaphas.item import SE
from gaphor import UML, diagram
from gaphor.core import gettext
from gaphor.diagram.diagramtools import (
DefaultTool,
PlacementTool,
TransactionalToolChain,
)
from gaphor.UML.event import DiagramItemCreated
__all__ = ["DiagramToolbox", "TOOLBOX_ACTIONS"]
# Actions: ((section (name, label, icon_name, shortcut)), ...)
TOOLBOX_ACTIONS: Sequence[Tuple[str, Sequence[Tuple[str, str, str, Optional[str]]]]] = (
(
gettext("General"),
(
(
"toolbox-pointer",
gettext("Pointer"),
"gaphor-pointer-symbolic",
"Escape",
),
("toolbox-line", gettext("Line"), "gaphor-line-symbolic", "l"),
("toolbox-box", gettext("Box"), "gaphor-box-symbolic", "b"),
("toolbox-ellipse", gettext("Ellipse"), "gaphor-ellipse-symbolic", "e"),
("toolbox-comment", gettext("Comment"), "gaphor-comment-symbolic", "k"),
(
"toolbox-comment-line",
gettext("Comment line"),
"gaphor-comment-line-symbolic",
"<Shift>K",
),
),
),
(
gettext("Classes"),
(
("toolbox-class", gettext("Class"), "gaphor-class-symbolic", "c"),
(
"toolbox-interface",
gettext("Interface"),
"gaphor-interface-symbolic",
"i",
),
("toolbox-package", gettext("Package"), "gaphor-package-symbolic", "p"),
(
"toolbox-association",
gettext("Association"),
"gaphor-association-symbolic",
"<Shift>A",
),
(
"toolbox-dependency",
gettext("Dependency"),
"gaphor-dependency-symbolic",
"<Shift>D",
),
(
"toolbox-generalization",
gettext("Generalization"),
"gaphor-generalization-symbolic",
"<Shift>G",
),
(
"toolbox-implementation",
gettext("Implementation"),
"gaphor-implementation-symbolic",
"<Shift>I",
),
),
),
(
gettext("Components"),
(
(
"toolbox-component",
gettext("Component"),
"gaphor-component-symbolic",
"o",
),
("toolbox-artifact", gettext("Artifact"), "gaphor-artifact-symbolic", "h",),
("toolbox-node", gettext("Node"), "gaphor-node-symbolic", "n"),
("toolbox-device", gettext("Device"), "gaphor-device-symbolic", "d"),
(
"toolbox-connector",
gettext("Connector"),
"gaphor-connector-symbolic",
"<Shift>C",
),
),
),
(
gettext("Actions"),
(
("toolbox-action", gettext("Action"), "gaphor-action-symbolic", "a"),
(
"toolbox-initial-node",
gettext("Initial node"),
"gaphor-initial-node-symbolic",
"j",
),
(
"toolbox-activity-final-node",
gettext("Activity final node"),
"gaphor-activity-final-node-symbolic",
"f",
),
(
"toolbox-flow-final-node",
gettext("Flow final node"),
"gaphor-flow-final-node-symbolic",
"w",
),
(
"toolbox-decision-node",
gettext("Decision/merge node"),
"gaphor-decision-node-symbolic",
"g",
),
(
"toolbox-fork-node",
gettext("Fork/join node"),
"gaphor-fork-node-symbolic",
"<Shift>R",
),
(
"toolbox-object-node",
gettext("Object node"),
"gaphor-object-node-symbolic",
"<Shift>O",
),
(
"toolbox-partition",
gettext("Partition"),
"gaphor-partition-symbolic",
"<Shift>P",
),
(
"toolbox-flow",
gettext("Control/object flow"),
"gaphor-control-flow-symbolic",
"<Shift>F",
),
(
"toolbox-send-signal-action",
gettext("Send signal action"),
"gaphor-send-signal-action-symbolic",
None,
),
(
"toolbox-accept-event-action",
gettext("Accept event action"),
"gaphor-accept-event-action-symbolic",
None,
),
),
),
(
gettext("Interactions"),
(
("toolbox-lifeline", gettext("Lifeline"), "gaphor-lifeline-symbolic", "v",),
("toolbox-message", gettext("Message"), "gaphor-message-symbolic", "M"),
(
"toolbox-interaction",
gettext("Interaction"),
"gaphor-interaction-symbolic",
"<Shift>N",
),
),
),
(
gettext("States"),
(
("toolbox-state", gettext("State"), "gaphor-state-symbolic", "s"),
(
"toolbox-initial-pseudostate",
gettext("Initial Pseudostate"),
"gaphor-initial-pseudostate-symbolic",
"<Shift>S",
),
(
"toolbox-final-state",
gettext("Final State"),
"gaphor-final-state-symbolic",
"x",
),
(
"toolbox-history-pseudostate",
gettext("History Pseudostate"),
"gaphor-pseudostate-symbolic",
"q",
),
(
"toolbox-transition",
gettext("Transition"),
"gaphor-transition-symbolic",
"<Shift>T",
),
),
),
(
gettext("Use Cases"),
(
("toolbox-use-case", gettext("Use case"), "gaphor-use-case-symbolic", "u",),
("toolbox-actor", gettext("Actor"), "gaphor-actor-symbolic", "t"),
(
"toolbox-use-case-association",
gettext("Association"),
"gaphor-association-symbolic",
"<Shift>B",
),
(
"toolbox-include",
gettext("Include"),
"gaphor-include-symbolic",
"<Shift>U",
),
(
"toolbox-extend",
gettext("Extend"),
"gaphor-extend-symbolic",
"<Shift>X",
),
),
),
(
gettext("Profiles"),
(
("toolbox-profile", gettext("Profile"), "gaphor-profile-symbolic", "r"),
(
"toolbox-metaclass",
gettext("Metaclass"),
"gaphor-metaclass-symbolic",
"m",
),
(
"toolbox-stereotype",
gettext("Stereotype"),
"gaphor-stereotype-symbolic",
"z",
),
(
"toolbox-extension",
gettext("Extension"),
"gaphor-extension-symbolic",
"<Shift>E",
),
),
),
)
def tooliter(toolbox_actions):
"""
Iterate toolbox items, irregardless section headers
"""
for name, section in toolbox_actions:
yield from section
class DiagramToolbox:
"""
Composite class for DiagramPage.
See diagrampage.py.
"""
def __init__(self, diagram, view, element_factory, event_manager):
self.diagram = diagram
self.view = view
self.element_factory = element_factory
self.event_manager = event_manager
def get_tool(self, tool_name):
"""
Return a tool associated with an id (action name).
"""
return getattr(self, tool_name.replace("-", "_"))()
action_list = list(zip(*list(tooliter(TOOLBOX_ACTIONS))))
def _item_factory(self, item_class, subject_class=None, config_func=None):
"""
``config_func`` may be a function accepting the newly created item.
"""
def factory_method(
parent: Optional[UML.Presentation] = None,
) -> UML.Presentation:
if subject_class:
subject = self.element_factory.create(subject_class)
else:
subject = None
item: UML.Presentation = self.diagram.create(
item_class, subject=subject, parent=parent
)
if config_func:
config_func(item)
return item
factory_method.item_class = item_class # type: ignore[attr-defined] # noqa: F821
return factory_method
def _namespace_config(self, new_item):
subject = new_item.subject
subject.package = self.diagram.namespace
subject.name = f"New{type(subject).__name__}"
##
## Toolbox actions
##
def toolbox_pointer(self):
if self.view:
return DefaultTool(self.event_manager)
# @tool(diagram.general.Line, "toolbox-line", gettext("Line"), "gaphor-line-symbolic", "l")
def toolbox_line(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.general.Line),
event_manager=self.event_manager,
)
def toolbox_box(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.general.Box),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_ellipse(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.general.Ellipse),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_comment(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.general.CommentItem, UML.Comment),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_comment_line(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.general.CommentLineItem),
event_manager=self.event_manager,
)
# Classes:
def toolbox_class(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.classes.ClassItem, UML.Class, config_func=self._namespace_config
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_interface(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.classes.InterfaceItem,
UML.Interface,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_package(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.classes.PackageItem,
UML.Package,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_association(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.classes.AssociationItem),
event_manager=self.event_manager,
)
def toolbox_dependency(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.classes.DependencyItem),
event_manager=self.event_manager,
)
def toolbox_generalization(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.classes.GeneralizationItem),
event_manager=self.event_manager,
)
def toolbox_implementation(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.classes.ImplementationItem),
event_manager=self.event_manager,
)
# Components:
def toolbox_component(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.components.ComponentItem,
UML.Component,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_artifact(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.components.ArtifactItem,
UML.Artifact,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_node(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.components.NodeItem,
UML.Node,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_device(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.components.NodeItem,
UML.Device,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_connector(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.components.ConnectorItem),
event_manager=self.event_manager,
)
# Actions:
def toolbox_action(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.actions.ActionItem,
UML.Action,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_send_signal_action(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.actions.SendSignalActionItem,
UML.SendSignalAction,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_accept_event_action(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.actions.AcceptEventActionItem,
UML.AcceptEventAction,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_initial_node(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.actions.InitialNodeItem, UML.InitialNode
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_activity_final_node(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.actions.ActivityFinalNodeItem, UML.ActivityFinalNode
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_flow_final_node(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.actions.FlowFinalNodeItem, UML.FlowFinalNode
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_decision_node(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.actions.DecisionNodeItem, UML.DecisionNode
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_fork_node(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.actions.ForkNodeItem, UML.JoinNode),
handle_index=1,
event_manager=self.event_manager,
)
def toolbox_object_node(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.actions.ObjectNodeItem,
UML.ObjectNode,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_partition(self):
# note no subject, which is created by grouping adapter
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.actions.PartitionItem),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_flow(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.actions.FlowItem),
event_manager=self.event_manager,
)
# Interactions:
def toolbox_interaction(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.interactions.InteractionItem,
UML.Interaction,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_lifeline(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.interactions.LifelineItem,
UML.Lifeline,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_message(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.interactions.MessageItem),
event_manager=self.event_manager,
)
# States:
def toolbox_state(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.states.StateItem, UML.State, config_func=self._namespace_config
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_initial_pseudostate(self):
def set_state(item):
item.subject.kind = "initial"
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.states.InitialPseudostateItem, UML.Pseudostate, set_state
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_history_pseudostate(self):
def set_state(item):
item.subject.kind = "shallowHistory"
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.states.HistoryPseudostateItem, UML.Pseudostate, set_state
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_final_state(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.states.FinalStateItem, UML.FinalState
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_transition(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.states.TransitionItem),
event_manager=self.event_manager,
)
# Use cases:
def toolbox_use_case(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.usecases.UseCaseItem,
UML.UseCase,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_actor(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.usecases.ActorItem,
UML.Actor,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_use_case_association(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.classes.AssociationItem),
event_manager=self.event_manager,
)
def toolbox_include(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.usecases.IncludeItem),
event_manager=self.event_manager,
)
def toolbox_extend(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.usecases.ExtendItem),
event_manager=self.event_manager,
)
# Profiles:
def toolbox_profile(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.classes.PackageItem,
UML.Profile,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_metaclass(self):
def metaclass_config(new_item):
self._namespace_config(new_item)
new_item.subject.name = "Class"
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.classes.ClassItem, UML.Class, config_func=metaclass_config
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_stereotype(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(
diagram.classes.ClassItem,
UML.Stereotype,
config_func=self._namespace_config,
),
handle_index=SE,
event_manager=self.event_manager,
)
def toolbox_extension(self):
return PlacementTool(
self.view,
item_factory=self._item_factory(diagram.profiles.ExtensionItem),
event_manager=self.event_manager,
)
```
#### File: gaphor/diagram/presentation.py
```python
import ast
from typing import Optional
import gaphas
from gaphas.geometry import Rectangle, distance_rectangle_point
from gaphor.diagram.text import TextAlign, text_point_at_line
from gaphor.UML.presentation import Presentation, S
class Named:
"""
Marker for any NamedElement presentations.
"""
class Classified(Named):
"""
Marker for Classifier presentations.
"""
def from_package_str(item):
"""
Display name space info when it is different, then diagram's or
parent's namespace.
"""
subject = item.subject
canvas = item.canvas
if not subject or not canvas:
return False
namespace = subject.namespace
parent = canvas.get_parent(item)
# if there is a parent (i.e. interaction)
if parent and parent.subject and parent.subject.namespace is not namespace:
return False
return (
f"(from {namespace.name})" if namespace is not canvas.diagram.namespace else ""
)
# Note: the official documentation is using the terms "Shape" and "Edge" for element and line.
class ElementPresentation(Presentation[S], gaphas.Element):
"""
Presentation for Gaphas Element (box-like) items.
To create a shape (boxes, text), assign a shape to `self.shape`. If the
shape can change, for example, because styling needs to change, implement
the method `update_shapes()` and set self.shape there.
"""
width: int
height: int
def __init__(self, id=None, model=None, shape=None):
super().__init__(id, model)
self._shape = shape
def _set_shape(self, shape):
self._shape = shape
self.request_update()
shape = property(lambda s: s._shape, _set_shape)
def update_shapes(self, event=None):
"""
Updating the shape configuration, e.g. when extra elements have to
be drawn or when styling changes.
"""
def pre_update(self, context):
cr = context.cairo
self.min_width, self.min_height = self.shape.size(cr)
def draw(self, context):
self._shape.draw(context, Rectangle(0, 0, self.width, self.height))
def setup_canvas(self):
super().setup_canvas()
self.subscribe_all()
# Invoke here, since we do not receive events, unless we're attached to a canvas
self.update_shapes()
def teardown_canvas(self):
self.unsubscribe_all()
super().teardown_canvas()
def save(self, save_func):
save_func("matrix", tuple(self.matrix))
for prop in ("width", "height"):
save_func(prop, getattr(self, prop))
super().save(save_func)
def load(self, name, value):
if name == "matrix":
self.matrix = ast.literal_eval(value)
elif name in ("width", "height"):
setattr(self, name, ast.literal_eval(value))
else:
super().load(name, value)
def postload(self):
super().postload()
self.update_shapes()
class LinePresentation(Presentation[S], gaphas.Line):
def __init__(
self,
id=None,
model=None,
style={},
shape_head=None,
shape_middle=None,
shape_tail=None,
):
super().__init__(id, model)
self._style = {"dash-style": (), "line-width": 2, **style}
self.shape_head = shape_head
self.shape_middle = shape_middle
self.shape_tail = shape_tail
self.fuzziness = 2
self._shape_head_rect = None
self._shape_middle_rect = None
self._shape_tail_rect = None
canvas: Optional[gaphas.Canvas]
head = property(lambda self: self._handles[0])
tail = property(lambda self: self._handles[-1])
def _set_style(self, style):
self._style.update(style)
style = property(
lambda self: self._style.__getitem__,
_set_style,
doc="""A line, contrary to an element, has some styling of it's own.""",
)
def post_update(self, context):
def shape_bounds(shape, align):
if shape:
size = shape.size(cr)
x, y = text_point_at_line(points, size, align)
return Rectangle(x, y, *size)
super().post_update(context)
cr = context.cairo
points = [h.pos for h in self.handles()]
self._shape_head_rect = shape_bounds(self.shape_head, TextAlign.LEFT)
self._shape_middle_rect = shape_bounds(self.shape_middle, TextAlign.CENTER)
self._shape_tail_rect = shape_bounds(self.shape_tail, TextAlign.RIGHT)
def point(self, pos):
"""Given a point (x, y) return the distance to the canvas item.
"""
d0 = super().point(pos)
ds = [
distance_rectangle_point(shape, pos)
for shape in (
self._shape_head_rect,
self._shape_middle_rect,
self._shape_tail_rect,
)
if shape
]
return min(d0, *ds) if ds else d0
def draw(self, context):
cr = context.cairo
cr.set_line_width(self.style("line-width"))
if self.style("dash-style"):
cr.set_dash(self.style("dash-style"), 0)
super().draw(context)
for shape, rect in (
(self.shape_head, self._shape_head_rect),
(self.shape_middle, self._shape_middle_rect),
(self.shape_tail, self._shape_tail_rect),
):
if shape:
shape.draw(context, rect)
def setup_canvas(self):
super().setup_canvas()
self.subscribe_all()
def teardown_canvas(self):
self.unsubscribe_all()
super().teardown_canvas()
def save(self, save_func):
def save_connection(name, handle):
assert self.canvas
c = self.canvas.get_connection(handle)
if c:
save_func(name, c.connected, reference=True)
super().save(save_func)
save_func("matrix", tuple(self.matrix))
for prop in ("orthogonal", "horizontal"):
save_func(prop, getattr(self, prop))
points = [tuple(map(float, h.pos)) for h in self.handles()]
save_func("points", points)
save_connection("head-connection", self.head)
save_connection("tail-connection", self.tail)
def load(self, name, value):
if name == "matrix":
self.matrix = ast.literal_eval(value)
elif name == "points":
points = ast.literal_eval(value)
for x in range(len(points) - 2):
h = self._create_handle((0, 0))
self._handles.insert(1, h)
for i, p in enumerate(points):
self.handles()[i].pos = p
# Update connection ports of the line. Only handles are saved
# in Gaphor file therefore ports need to be recreated after
# handles information is loaded.
self._update_ports()
elif name == "orthogonal":
self._load_orthogonal = ast.literal_eval(value)
elif name == "horizontal":
self.horizontal = ast.literal_eval(value)
elif name in ("head_connection", "head-connection"):
self._load_head_connection = value
elif name in ("tail_connection", "tail-connection"):
self._load_tail_connection = value
else:
super().load(name, value)
def postload(self):
assert self.canvas
def get_sink(handle, item):
assert self.canvas
hpos = self.canvas.get_matrix_i2i(self, item).transform_point(*handle.pos)
port = None
dist = 10e6
for p in item.ports():
pos, d = p.glue(hpos)
if not port or d < dist:
port = p
dist = d
return gaphas.aspect.ConnectionSink(item, port)
def postload_connect(handle, item):
connector = gaphas.aspect.Connector(self, handle)
sink = get_sink(handle, item)
connector.connect(sink)
if hasattr(self, "_load_orthogonal"):
# Ensure there are enough handles
if self._load_orthogonal and len(self._handles) < 3:
p0 = self._handles[-1].pos
self._handles.insert(1, self._create_handle(p0))
self.orthogonal = self._load_orthogonal
del self._load_orthogonal
# First update matrix and solve constraints (NE and SW handle are
# lazy and are resolved by the constraint solver rather than set
# directly.
self.canvas.update_matrix(self)
self.canvas.solver.solve()
if hasattr(self, "_load_head_connection"):
postload_connect(self.head, self._load_head_connection)
del self._load_head_connection
if hasattr(self, "_load_tail_connection"):
postload_connect(self.tail, self._load_tail_connection)
del self._load_tail_connection
super().postload()
```
#### File: project-makehuman/gaphor/__init__.py
```python
__version__ = "1.1.1"
__all__ = ["main"]
import logging
from optparse import OptionParser
from gaphor.application import Application
LOG_FORMAT = "%(name)s %(levelname)s %(message)s"
def main():
"""Start Gaphor from the command line. This function creates an option
parser for retrieving arguments and options from the command line. This
includes a Gaphor model to load.
The application is then initialized, passing along the option parser. This
provides plugins and services with access to the command line options
and may add their own."""
parser = OptionParser()
parser.add_option("-p", "--profiler", action="store_true", help="Run in profiler")
parser.add_option(
"-q",
"--quiet",
dest="quiet",
help="Quiet output",
default=False,
action="store_true",
)
parser.add_option(
"-v",
"--verbose",
dest="verbose",
help="Verbose output",
default=False,
action="store_true",
)
options, args = parser.parse_args()
if options.verbose:
logging.basicConfig(level=logging.DEBUG, format=LOG_FORMAT)
elif options.quiet:
logging.basicConfig(level=logging.WARNING, format=LOG_FORMAT)
else:
logging.basicConfig(level=logging.INFO, format=LOG_FORMAT)
model = None
try:
model = args[0]
except IndexError:
pass
if options.profiler:
import cProfile
import pstats
cProfile.runctx(
"Application.run(model)", globals(), locals(), filename="gaphor.prof"
)
profile_stats = pstats.Stats("gaphor.prof")
profile_stats.strip_dirs().sort_stats("time").print_stats(50)
else:
Application.run(model)
```
#### File: gaphor/tools/gaphorconvert.py
```python
import optparse
import os
import re
import sys
import cairo
from gaphas.painter import Context, ItemPainter
from gaphas.view import View
import gaphor.UML as UML
from gaphor.application import Application
from gaphor.storage import storage
def pkg2dir(package):
"""
Return directory path from UML package class.
"""
name = []
while package:
name.insert(0, package.name)
package = package.package
return "/".join(name)
def paint(view, cr):
view.painter.paint(Context(cairo=cr, items=view.canvas.get_all_items(), area=None))
def main(argv=sys.argv[1:]):
def message(msg):
"""
Print message if user set verbose mode.
"""
if options.verbose:
print(msg, file=sys.stderr)
usage = "usage: %prog [options] file1 file2..."
parser = optparse.OptionParser(usage=usage)
parser.add_option(
"-v", "--verbose", dest="verbose", action="store_true", help="verbose output"
)
parser.add_option(
"-u",
"--use-underscores",
dest="underscores",
action="store_true",
help="use underscores instead of spaces for output filenames",
)
parser.add_option(
"-d", "--dir", dest="dir", metavar="directory", help="output to directory"
)
parser.add_option(
"-f",
"--format",
dest="format",
metavar="format",
help="output file format, default pdf",
default="pdf",
choices=["pdf", "svg", "png"],
)
parser.add_option(
"-r",
"--regex",
dest="regex",
metavar="regex",
help="process diagrams which name matches given regular expresion;"
" name includes package name; regular expressions are case insensitive",
)
(options, args) = parser.parse_args(argv)
if not args:
parser.print_help()
Application.init(
services=["event_manager", "component_registry", "element_factory"]
)
factory = Application.get_service("element_factory")
name_re = None
if options.regex:
name_re = re.compile(options.regex, re.I)
# we should have some gaphor files to be processed at this point
for model in args:
message(f"loading model {model}")
storage.load(model, factory)
message("ready for rendering")
for diagram in factory.select(lambda e: e.isKindOf(UML.Diagram)):
odir = pkg2dir(diagram.package)
# just diagram name
dname = diagram.name
# full diagram name including package path
pname = f"{odir}/{dname}"
if options.underscores:
odir = odir.replace(" ", "_")
dname = dname.replace(" ", "_")
if name_re and not name_re.search(pname):
message(f"skipping {pname}")
continue
if options.dir:
odir = f"{options.dir}/{odir}"
outfilename = f"{odir}/{dname}.{options.format}"
if not os.path.exists(odir):
message(f"creating dir {odir}")
os.makedirs(odir)
message(f"rendering: {pname} -> {outfilename}...")
view = View(diagram.canvas)
view.painter = ItemPainter()
tmpsurface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 0, 0)
tmpcr = cairo.Context(tmpsurface)
view.update_bounding_box(tmpcr)
tmpcr.show_page()
tmpsurface.flush()
w, h = view.bounding_box.width, view.bounding_box.height
if options.format == "pdf":
surface = cairo.PDFSurface(outfilename, w, h)
elif options.format == "svg":
surface = cairo.SVGSurface(outfilename, w, h)
elif options.format == "png":
surface = cairo.ImageSurface(
cairo.FORMAT_ARGB32, int(w + 1), int(h + 1)
)
else:
assert False, f"unknown format {options.format}"
cr = cairo.Context(surface)
view.matrix.translate(-view.bounding_box.x, -view.bounding_box.y)
paint(view, cr)
cr.show_page()
if options.format == "png":
surface.write_to_png(outfilename)
surface.flush()
surface.finish()
```
#### File: ui/tests/test_mainwindow.py
```python
import pytest
from gaphor import UML
from gaphor.application import Application
from gaphor.ui.abc import UIComponent
from gaphor.ui.event import DiagramOpened
@pytest.fixture
def application():
Application.init(
services=[
"event_manager",
"component_registry",
"element_factory",
"properties",
"main_window",
"namespace",
"diagrams",
"toolbox",
"elementeditor",
"export_menu",
"tools_menu",
]
)
yield Application
Application.shutdown()
def get_current_diagram(app):
return app.component_registry.get(UIComponent, "diagrams").get_current_diagram()
def test_creation(application):
# MainWindow should be created as resource
main_w = application.get_service("main_window")
main_w.open()
assert get_current_diagram(application) is None
def test_show_diagram(application):
element_factory = application.get_service("element_factory")
diagram = element_factory.create(UML.Diagram)
main_w = application.get_service("main_window")
main_w.open()
event_manager = application.get_service("event_manager")
event_manager.handle(DiagramOpened(diagram))
assert get_current_diagram(application) == diagram
```
#### File: ui/tests/test_recentfiles.py
```python
import pytest
from gaphor.services.eventmanager import EventManager
from gaphor.ui.event import FileLoaded
from gaphor.ui.recentfiles import RecentFiles
class RecentManagerStub:
def __init__(self):
self.items = []
def add_full(self, uri, meta):
self.items.append(uri)
@pytest.fixture
def event_manager():
return EventManager()
def test_add_new_recent_file(event_manager):
recent_manager = RecentManagerStub()
RecentFiles(event_manager, recent_manager)
event_manager.handle(FileLoaded(None, "testfile.gaphor"))
assert len(recent_manager.items) == 1
assert recent_manager.items[0].startswith("file:///"), recent_manager.items[0]
```
#### File: gaphor/UML/event.py
```python
from gaphor.event import ServiceEvent
class ElementUpdated:
"""
Generic event fired when element state changes.
"""
def __init__(self, element, property):
self.element = element
self.property = property
class AttributeUpdated(ElementUpdated):
"""A UML attribute has changed value."""
def __init__(self, element, attribute, old_value, new_value):
"""Constructor. The element parameter is the element with the
changing attribute. The attribute parameter is the parameter
element that changed. The old_value is the old value of the attribute
and the new_value is the new value of the attribute."""
super().__init__(element, attribute)
self.old_value = old_value
self.new_value = new_value
class AssociationUpdated(ElementUpdated):
"""An association UML element has changed."""
def __init__(self, element, association):
"""Constructor. The element parameter is the element the association
is changing from. The association parameter is the changed
association element."""
super().__init__(element, association)
class AssociationSet(AssociationUpdated):
"""An association element has been set."""
def __init__(self, element, association, old_value, new_value):
"""Constructor. The element parameter is the element setting the
association element. The association parameter is the association
element being set. The old_value parameter is the old association
and the new_value parameter is the new association."""
AssociationUpdated.__init__(self, element, association)
self.old_value = old_value
self.new_value = new_value
class AssociationAdded(AssociationUpdated):
"""An association element has been added."""
def __init__(self, element, association, new_value):
"""Constructor. The element parameter is the element the association
has been added to. The association parameter is the association
element being added."""
AssociationUpdated.__init__(self, element, association)
self.new_value = new_value
class AssociationDeleted(AssociationUpdated):
"""An association element has been deleted."""
def __init__(self, element, association, old_value):
"""Constructor. The element parameter is the element the association
has been deleted from. The association parameter is the deleted
association element."""
AssociationUpdated.__init__(self, element, association)
self.old_value = old_value
class DerivedUpdated(AssociationUpdated):
"""A derived property has changed."""
class DerivedSet(AssociationSet, DerivedUpdated):
"""A generic derived set event."""
def __init__(self, element, association, old_value, new_value):
"""Constructor. The element parameter is the element to which the
derived set belongs. The association parameter is the association
of the derived set."""
super().__init__(element, association, old_value, new_value)
class DerivedAdded(AssociationAdded, DerivedUpdated):
"""A derived property has been added."""
def __init__(self, element, association, new_value):
"""Constructor. The element parameter is the element to which the
derived property belongs. The association parameter is the
association of the derived property."""
super().__init__(element, association, new_value)
class DerivedDeleted(AssociationDeleted, DerivedUpdated):
"""A derived property has been deleted."""
def __init__(self, element, association, old_value):
"""Constructor. The element parameter is the element to which the
derived property belongs. The association parameter is the
association of the derived property."""
super().__init__(element, association, old_value)
class RedefinedSet(AssociationSet):
"""A redefined property has been set."""
def __init__(self, element, association, old_value, new_value):
"""Constructor. The element parameter is the element to which the
property belongs. The association parameter is association of the
property."""
super().__init__(element, association, old_value, new_value)
class RedefinedAdded(AssociationAdded):
"""A redefined property has been added."""
def __init__(self, element, association, new_value):
"""Constructor. The element parameter is the element to which the
property belongs. The association parameter is the association of
the property."""
super().__init__(element, association, new_value)
class RedefinedDeleted(AssociationDeleted):
"""A redefined property has been deleted."""
def __init__(self, element, association, old_value):
"""Constructor. The element parameter is the element to which the
property belongs. The association parameter is the association of
the property."""
super().__init__(element, association, old_value)
class ElementCreated(ServiceEvent):
"""An element has been created."""
def __init__(self, service, element):
"""Constructor. The service parameter is the service responsible
for creating the element. The element parameter is the element being
created."""
super().__init__(service)
self.element = element
class DiagramItemCreated(ElementCreated):
"""A diagram item has been created."""
def __init__(self, service, element):
"""Constructor. The element parameter is the element being created."""
super().__init__(service, element)
class ElementDeleted(ServiceEvent):
"""An element has been deleted."""
def __init__(self, service, element):
"""Constructor. The service parameter is the service responsible for
deleting the element. The element parameter is the element being
deleted."""
super().__init__(service)
self.element = element
class ModelReady(ServiceEvent):
"""A generic element factory event."""
def __init__(self, service):
"""Constructor. The service parameter is the service the emitted the
event."""
super().__init__(service)
class ModelFlushed(ServiceEvent):
"""The element factory has been flushed."""
def __init__(self, service):
"""Constructor. The service parameter is the service responsible for
flushing the factory."""
super().__init__(service)
```
#### File: project-makehuman/tests/test_issue_132.py
```python
from gaphor import UML
from gaphor.core import transactional
from gaphor.tests import TestCase
class UndoRedoBugTestCase(TestCase):
services = TestCase.services + ["undo_manager"]
def setUp(self):
super().setUp()
self.undo_manager = self.get_service("undo_manager")
@transactional
def create_with_attribute(self):
self.class_ = self.element_factory.create(UML.Class)
self.attribute = self.element_factory.create(UML.Property)
self.class_.ownedAttribute = self.attribute
# Fix: Remove operation should be transactional ;)
@transactional
def remove_attribute(self):
self.attribute.unlink()
def test_bug_with_attribute(self):
"""
Does not trigger the error.
"""
self.create_with_attribute()
assert len(self.class_.ownedAttribute) == 1
assert self.attribute.namespace is self.class_, self.attribute.namespace
self.remove_attribute()
assert len(self.class_.ownedAttribute) == 0
assert self.attribute.namespace is None
assert self.undo_manager.can_undo()
self.undo_manager.undo_transaction()
assert self.attribute in self.class_.ownedAttribute
self.undo_manager.redo_transaction()
# vi:sw=4:et:ai
```
#### File: utils/i18n/build_pot.py
```python
import glob
import os.path
import sys
import tokenize
from distutils.core import Command
from utils.i18n import pygettext
# from pygettext.main():
class Options:
# constants
GNU = 1
SOLARIS = 2
# defaults
extractall = 0 # FIXME: currently this option has no effect at all.
keywords = []
writelocations = 1
locationstyle = GNU
verbose = 0
width = 78
excludefilename = ""
docstrings = 0
nodocstrings = {}
toexclude = []
class build_pot(Command):
description = "Generate a .po template file (.pot) from python source files"
user_options = [
("msgmerge=", None, "location of the msgmerge program"),
("extract-all", "a", ""),
("default-domain=", "d", ""),
("escape", "E", ""),
("docstrings", "D", ""),
("keyword=", "k", "Comma separated list of keywords"),
("no-default-keywords", "K", ""),
("add-location", "n", ""),
("no-location", None, ""),
("style=", "S", 'POT file style "gnu" or "solaris"'),
("output=", "o", ""),
("output-dir=", "p", ""),
("width=", "w", ""),
("exclude-file=", "x", ""),
("all-linguas=", None, ""),
# ('no-docstrings=', 'X', ''),
]
boolean_options = [
"extract-all",
"escape",
"docstrings",
"no-default-keywords",
"add-location",
"no-location",
"no-docstrings",
]
# constants
GNU = 1
SOLARIS = 2
def initialize_options(self):
self.podir = "po"
self.msgmerge = "msgmerge"
self.options = Options()
# defaults for variable parsing:
self.escape = 0
self.width = 78
self.extract_all = 0 # doesn't do anything yet
self.default_domain = None
self.keyword = None
self.no_default_keywords = 0
self.no_location = 0
self.style = None
self.output = None
self.output_dir = None
self.docstrings = 0
self.exclude_file = None
# self.no_docstrings = None
self.all_linguas = []
def finalize_options(self):
options = self.options
self.name = self.distribution.get_name()
# Build default options for the TokenEater
if self.default_domain:
self.output = self.default_domain + ".pot"
if self.keyword:
options.keywords.extend(self.keyword.split(","))
if self.no_default_keywords:
options.keywords = []
if self.no_location:
options.writelocations = 0
if self.style:
if self.style == "gnu":
options.locationstyle = self.GNU
elif self.style == "solaris":
options.locationstyle = self.SOLARIS
else:
raise SystemExit(f"Invalid value for --style: {self.style}")
if not self.output:
self.output = self.distribution.get_name() + ".pot"
if not self.output_dir:
self.output_dir = self.podir
if self.docstrings:
options.docstrings = 1
options.width = int(self.width)
if self.exclude_file:
try:
fp = open(self.exclude_file)
options.toexclude = fp.readlines()
fp.close()
except OSError:
raise SystemExit(f"Can't read --exclude-file: {self.exclude_file}")
# skip: self.no_docstrings
if self.all_linguas:
self.all_linguas = self.all_linguas.split(",")
# calculate escapes
pygettext.make_escapes(self.escape)
# calculate all keywords
options.keywords.append("_")
if self.output_dir:
self.output = os.path.join(self.output_dir, self.output)
self.packages = self.distribution.packages
# self.all_linguas = self.distribution.get_all_linguas()
# self.all_linguas = self.distribution.options['po']['all_linguas']
def run(self):
create_pot_file(self.packages, self.output, self.options, verbose=self.verbose)
merge_files(
self.all_linguas,
self.msgmerge,
self.output,
self.output_dir,
verbose=self.verbose,
)
def create_pot_file(packages, pot_file, options=Options(), verbose=False):
"""
Create a new .pot file. This is basically a rework of the
main function of pygettext.
"""
source_files = []
for p in packages:
pathlist = p.split(".")
path = os.path.join(*pathlist)
source_files.extend(glob.glob(os.path.join(path, "*.py")))
# slurp through all the files
eater = pygettext.TokenEater(options)
for filename in source_files:
if verbose:
print(f"Working on {filename}")
fp = open(filename, "rb")
try:
eater.set_filename(filename)
try:
tokens = tokenize.tokenize(fp.readline)
for _token in tokens:
eater(*_token)
except tokenize.TokenError as e:
print(f"{e[0]}: {filename}, line {e[1][0]:d}, column {e[1][1]:d}")
finally:
fp.close()
if pot_file == "-":
fp = sys.stdout
else:
fp = open(pot_file, "w")
try:
eater.write(fp)
finally:
if fp is not sys.stdout:
fp.close()
def merge_files(all_linguas, msgmerge, pot_file, output_dir, verbose=False):
if not all_linguas:
return
for lingua in all_linguas:
d = {
"msgmerge": msgmerge,
"po": os.path.join(output_dir, lingua + ".po"),
"pot": pot_file,
}
if verbose:
print(f"Merging {d['pot']} and {d['po']} ")
res = os.system(f"{d['msgmerge']} {d['po']} {d['pot']} -o {d['po']}")
if res:
raise SystemExit("error while running msgmerge.")
if __name__ == "__main__":
from setuptools import find_packages
from utils.i18n import LINGUAS
packages = find_packages(exclude=["utils*", "docs", "tests"])
output_dir = "po"
pot_file = os.path.join(output_dir, "gaphor.pot")
create_pot_file(packages, pot_file, verbose=True)
merge_files(LINGUAS, "msgmerge", pot_file, output_dir=output_dir, verbose=True)
``` |
{
"source": "989onan/cats-blender-plugin",
"score": 2
} |
#### File: cats-blender-plugin/ui/scale.py
```python
import bpy
import addon_utils
from importlib import import_module
from importlib.util import find_spec
from .main import ToolPanel
from ..tools import scale as Scaler
from ..tools.translations import t
from ..tools.register import register_wrap
draw_imscale_ui = None
imscale_is_disabled = False
old_imscale_version = False
def check_for_imscale():
global draw_imscale_ui, old_imscale_version, imscale_is_disabled
draw_imscale_ui = None
if find_spec("immersive_scaler") and find_spec("immersive_scaler.immersive_scaler"):
import immersive_scaler.immersive_scaler as imscale
draw_imscale_ui = imscale.ui.draw_ui
return
for mod in addon_utils.modules():
if mod.bl_info['name'] == "Immersive Scaler":
# print(mod.__name__, mod.bl_info['version'])
# print(addon_utils.check(mod.__name__))
if mod.bl_info['version'] < (0, 2, 7):
old_imscale_version = True
# print('TOO OLD!')
continue
if not addon_utils.check(mod.__name__)[0]:
imscale_is_disabled = True
# print('DISABLED!')
continue
# print('FOUND!')
old_imscale_version = False
imscale_is_disabled = False
draw_imscale_ui = getattr(import_module(mod.__name__ + '.ui'), 'draw_ui')
break
@register_wrap
class ScalingPanel(ToolPanel, bpy.types.Panel):
bl_idname = 'VIEW3D_PT_scale_v2'
bl_label = t('ScalingPanel.label')
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
box = layout.box()
col = box.column(align=True)
row = col.row(align=True)
row.operator(Scaler.ImmersiveScalerHelpButton.bl_idname, icon='QUESTION')
# Installed but disabled
if imscale_is_disabled:
box = layout.box()
col = box.column(align=True)
row = col.row(align=True)
row.scale_y = 0.75
row.label(text=t('ScalingPanel.imscaleDisabled1'))
row = col.row(align=True)
row.scale_y = 0.75
row.label(text=t('ScalingPanel.imscaleDisabled2'))
col.separator()
row = col.row(align=True)
row.operator(Scaler.EnableIMScale.bl_idname, icon='CHECKBOX_HLT')
check_for_imscale()
return None
# Currently, instructions for an old version are the same as
# it not being installed - a manual install either way.
if old_imscale_version:
box = layout.box()
col = box.column(align=True)
row = col.row(align=True)
row.scale_y = 0.75
row.label(text=t('ScalingPanel.imscaleOldVersion1'))
row = col.row(align=True)
row.scale_y = 0.75
row.label(text=t('ScalingPanel.imscaleNotInstalled2'))
col.separator()
row = col.row(align=True)
row.operator(Scaler.ImmersiveScalerButton.bl_idname, icon='CHECKBOX_HLT')
check_for_imscale()
return None
# Imscale is not found
if not draw_imscale_ui:
box = layout.box()
col = box.column(align=True)
row = col.row(align=True)
row.scale_y = 0.75
row.label(text=t('ScalingPanel.imscaleNotInstalled1'))
row = col.row(align=True)
row.scale_y = 0.75
row.label(text=t('ScalingPanel.imscaleNotInstalled2'))
col.separator()
row = col.row(align=True)
row.operator(Scaler.ImmersiveScalerButton.bl_idname, icon='CHECKBOX_HLT')
check_for_imscale()
return None
check_for_imscale()
return None
# imscale = __import__('immersive_scaler')
return draw_imscale_ui(context, layout)
```
#### File: cats-blender-plugin/ui/visemes.py
```python
import bpy
from .main import ToolPanel
from ..tools import common as Common
from ..tools import viseme as Viseme
from ..tools.register import register_wrap
from ..tools.translations import t
@register_wrap
class SearchMenuOperatorMouthA(bpy.types.Operator):
bl_description = t('Scene.mouth_a.desc')
bl_idname = "scene.search_menu_mouth_a"
bl_label = ""
bl_property = "my_enum"
my_enum: bpy.props.EnumProperty(name="shapekeys", description=t('Scene.mouth_a.desc'), items=Common.get_shapekeys_mouth_ah) #default, change after making operator in UI like shown below.7
def execute(self, context):
context.scene.mouth_a = self.my_enum
print(context.scene.mouth_a)
return {'FINISHED'}
def invoke(self, context, event):
wm = context.window_manager
wm.invoke_search_popup(self)
return {'FINISHED'}
@register_wrap
class SearchMenuOperatorMouthO(bpy.types.Operator):
bl_description = t('Scene.mouth_o.desc')
bl_idname = "scene.search_menu_mouth_o"
bl_label = ""
bl_property = "my_enum"
my_enum: bpy.props.EnumProperty(name="shapekeys", description=t('Scene.mouth_o.desc'), items=Common.get_shapekeys_mouth_oh) #default, change after making operator in UI like shown below.7
def execute(self, context):
context.scene.mouth_o = self.my_enum
print(context.scene.mouth_o)
return {'FINISHED'}
def invoke(self, context, event):
wm = context.window_manager
wm.invoke_search_popup(self)
return {'FINISHED'}
@register_wrap
class SearchMenuOperatorMouthCH(bpy.types.Operator):
bl_description = t('Scene.mouth_ch.desc')
bl_idname = "scene.search_menu_mouth_ch"
bl_label = ""
bl_property = "my_enum"
my_enum: bpy.props.EnumProperty(name="shapekeys", description=t('Scene.mouth_ch.desc'), items=Common.get_shapekeys_mouth_ch) #default, change after making operator in UI like shown below.7
def execute(self, context):
context.scene.mouth_ch = self.my_enum
print(context.scene.mouth_ch)
return {'FINISHED'}
def invoke(self, context, event):
wm = context.window_manager
wm.invoke_search_popup(self)
return {'FINISHED'}
@register_wrap
class VisemePanel(ToolPanel, bpy.types.Panel):
bl_idname = 'VIEW3D_PT_viseme_v3'
bl_label = t('VisemePanel.label')
bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
layout = self.layout
box = layout.box()
col = box.column(align=True)
mesh_count = len(Common.get_meshes_objects(check=False))
if mesh_count == 0:
row = col.row(align=True)
row.scale_y = 1.1
row.label(text=t('VisemePanel.error.noMesh'), icon='ERROR')
col.separator()
elif mesh_count > 1:
row = col.row(align=True)
row.scale_y = 1.1
row.prop(context.scene, 'mesh_name_viseme', icon='MESH_DATA')
col.separator()
row = col.row(align=True)
row.scale_y = 1.1
row.label(text=t('Scene.mouth_a.label')+":")
row.operator(SearchMenuOperatorMouthA.bl_idname, text = context.scene.mouth_a, icon='SHAPEKEY_DATA')
row = col.row(align=True)
row.scale_y = 1.1
row.label(text=t('Scene.mouth_o.label')+":")
row.operator(SearchMenuOperatorMouthO.bl_idname, text = context.scene.mouth_o, icon='SHAPEKEY_DATA')
row = col.row(align=True)
row.scale_y = 1.1
row.label(text=t('Scene.mouth_ch.label')+":")
row.operator(SearchMenuOperatorMouthCH.bl_idname, text = context.scene.mouth_ch, icon='SHAPEKEY_DATA')
col.separator()
row = col.row(align=True)
row.prop(context.scene, 'shape_intensity')
col.separator()
row = col.row(align=True)
row.operator(Viseme.AutoVisemeButton.bl_idname, icon='TRIA_RIGHT')
``` |
{
"source": "989onan/VRM_Addon_for_Blender",
"score": 2
} |
#### File: editor/vrm0/panel.py
```python
import bpy
from bpy.app.translations import pgettext
from ...common.human_bone import HumanBone, HumanBones
from .. import operator, search
from ..extension import VrmAddonArmatureExtensionPropertyGroup
from ..migration import migrate
from ..panel import VRM_PT_vrm_armature_object_property
from . import operator as vrm0_operator
from .property_group import (
Vrm0BlendShapeMasterPropertyGroup,
Vrm0FirstPersonPropertyGroup,
Vrm0HumanoidPropertyGroup,
Vrm0MetaPropertyGroup,
Vrm0SecondaryAnimationPropertyGroup,
)
def bone_prop_search(
layout: bpy.types.UILayout,
human_bone: HumanBone,
icon: str,
humanoid_props: Vrm0HumanoidPropertyGroup,
) -> None:
props = None
for human_bone_props in humanoid_props.human_bones:
if human_bone_props.bone == human_bone.name.value:
props = human_bone_props
break
if not props:
return
layout.prop_search(
props.node,
"value",
props,
"node_candidates",
text="",
translate=False,
icon=icon,
)
def draw_vrm0_humanoid_layout(
armature: bpy.types.Object,
layout: bpy.types.UILayout,
humanoid_props: Vrm0HumanoidPropertyGroup,
) -> None:
if migrate(armature.name, defer=True):
Vrm0HumanoidPropertyGroup.check_last_bone_names_and_update(armature.data.name)
data = armature.data
armature_box = layout
t_pose_box = armature_box.box()
column = t_pose_box.row().column()
column.label(text="VRM T-Pose", icon="OUTLINER_OB_ARMATURE")
column.label(text="Pose Library")
column.prop_search(
humanoid_props, "pose_library", bpy.data, "actions", text="", translate=False
)
column.label(text="Pose")
if (
humanoid_props.pose_library
and humanoid_props.pose_library.name in bpy.data.actions
):
column.prop_search(
humanoid_props,
"pose_marker_name",
humanoid_props.pose_library,
"pose_markers",
text="",
translate=False,
)
else:
pose_marker_name_empty_box = column.box()
pose_marker_name_empty_box.scale_y = 0.5
pose_marker_name_empty_box.label(text="Current Pose")
armature_box.operator(
operator.VRM_OT_save_human_bone_mappings.bl_idname, icon="EXPORT"
)
armature_box.operator(
operator.VRM_OT_load_human_bone_mappings.bl_idname, icon="IMPORT"
)
if operator.VRM_OT_simplify_vroid_bones.vroid_bones_exist(data):
simplify_vroid_bones_op = armature_box.operator(
operator.VRM_OT_simplify_vroid_bones.bl_idname,
text=pgettext(operator.VRM_OT_simplify_vroid_bones.bl_label),
icon="GREASEPENCIL",
)
simplify_vroid_bones_op.armature_name = armature.name
split_factor = 0.2
requires_box = armature_box.box()
requires_box.label(text="VRM Required Bones", icon="ARMATURE_DATA")
row = requires_box.row().split(factor=split_factor)
column = row.column()
column.label(text=HumanBones.HEAD.label)
column.label(text=HumanBones.NECK.label)
column.label(text=HumanBones.CHEST.label)
column.label(text=HumanBones.SPINE.label)
column.label(text=HumanBones.HIPS.label)
column = row.column()
icon = "USER"
bone_prop_search(column, HumanBones.HEAD, icon, humanoid_props)
bone_prop_search(column, HumanBones.NECK, icon, humanoid_props)
bone_prop_search(column, HumanBones.CHEST, icon, humanoid_props)
bone_prop_search(column, HumanBones.SPINE, icon, humanoid_props)
bone_prop_search(column, HumanBones.HIPS, icon, humanoid_props)
row = requires_box.row().split(factor=split_factor)
column = row.column()
column.label(text="")
column.label(text=HumanBones.LEFT_UPPER_ARM.label_no_left_right)
column.label(text=HumanBones.LEFT_LOWER_ARM.label_no_left_right)
column.label(text=HumanBones.LEFT_HAND.label_no_left_right)
column.separator()
column.label(text=HumanBones.LEFT_UPPER_LEG.label_no_left_right)
column.label(text=HumanBones.LEFT_LOWER_LEG.label_no_left_right)
column.label(text=HumanBones.LEFT_FOOT.label_no_left_right)
column = row.column()
column.label(text="Right")
icon = "VIEW_PAN"
bone_prop_search(column, HumanBones.RIGHT_UPPER_ARM, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_LOWER_ARM, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_HAND, icon, humanoid_props)
column.separator()
icon = "MOD_DYNAMICPAINT"
bone_prop_search(column, HumanBones.RIGHT_UPPER_LEG, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_LOWER_LEG, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_FOOT, icon, humanoid_props)
column = row.column()
column.label(text="Left")
icon = "VIEW_PAN"
bone_prop_search(column, HumanBones.LEFT_UPPER_ARM, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_LOWER_ARM, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_HAND, icon, humanoid_props)
column.separator()
icon = "MOD_DYNAMICPAINT"
bone_prop_search(column, HumanBones.LEFT_UPPER_LEG, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_LOWER_LEG, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_FOOT, icon, humanoid_props)
defines_box = armature_box.box()
defines_box.label(text="VRM Optional Bones", icon="BONE_DATA")
row = defines_box.row().split(factor=split_factor)
icon = "HIDE_OFF"
column = row.column()
column.label(text="")
column.label(text=HumanBones.LEFT_EYE.label_no_left_right)
column = row.column()
column.label(text="Right")
bone_prop_search(column, HumanBones.RIGHT_EYE, icon, humanoid_props)
column = row.column()
column.label(text="Left")
bone_prop_search(column, HumanBones.LEFT_EYE, icon, humanoid_props)
row = defines_box.row().split(factor=split_factor)
column = row.column()
column.label(text=HumanBones.JAW.label)
column.label(text=HumanBones.UPPER_CHEST.label)
column = row.column()
icon = "USER"
bone_prop_search(column, HumanBones.JAW, icon, humanoid_props)
bone_prop_search(column, HumanBones.UPPER_CHEST, icon, humanoid_props)
split_factor = 0.5
row = defines_box.row().split(factor=split_factor)
column = row.column()
column.label(text=HumanBones.RIGHT_SHOULDER.label)
column.label(text=HumanBones.RIGHT_THUMB_PROXIMAL.label)
column.label(text=HumanBones.RIGHT_THUMB_INTERMEDIATE.label)
column.label(text=HumanBones.RIGHT_THUMB_DISTAL.label)
column.label(text=HumanBones.RIGHT_INDEX_PROXIMAL.label)
column.label(text=HumanBones.RIGHT_INDEX_INTERMEDIATE.label)
column.label(text=HumanBones.RIGHT_INDEX_DISTAL.label)
column.label(text=HumanBones.RIGHT_MIDDLE_PROXIMAL.label)
column.label(text=HumanBones.RIGHT_MIDDLE_INTERMEDIATE.label)
column.label(text=HumanBones.RIGHT_MIDDLE_DISTAL.label)
column.label(text=HumanBones.RIGHT_RING_PROXIMAL.label)
column.label(text=HumanBones.RIGHT_RING_INTERMEDIATE.label)
column.label(text=HumanBones.RIGHT_RING_DISTAL.label)
column.label(text=HumanBones.RIGHT_LITTLE_PROXIMAL.label)
column.label(text=HumanBones.RIGHT_LITTLE_INTERMEDIATE.label)
column.label(text=HumanBones.RIGHT_LITTLE_DISTAL.label)
column.label(text=HumanBones.RIGHT_TOES.label)
column = row.column()
icon = "USER"
bone_prop_search(column, HumanBones.RIGHT_SHOULDER, icon, humanoid_props)
icon = "VIEW_PAN"
bone_prop_search(column, HumanBones.RIGHT_THUMB_PROXIMAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_THUMB_INTERMEDIATE, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_THUMB_DISTAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_INDEX_PROXIMAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_INDEX_INTERMEDIATE, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_INDEX_DISTAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_MIDDLE_PROXIMAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_MIDDLE_INTERMEDIATE, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_MIDDLE_DISTAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_RING_PROXIMAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_RING_INTERMEDIATE, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_RING_DISTAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_LITTLE_PROXIMAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_LITTLE_INTERMEDIATE, icon, humanoid_props)
bone_prop_search(column, HumanBones.RIGHT_LITTLE_DISTAL, icon, humanoid_props)
icon = "MOD_DYNAMICPAINT"
bone_prop_search(column, HumanBones.RIGHT_TOES, icon, humanoid_props)
row = defines_box.row().split(factor=split_factor)
column = row.column()
column.label(text=HumanBones.LEFT_SHOULDER.label)
column.label(text=HumanBones.LEFT_THUMB_PROXIMAL.label)
column.label(text=HumanBones.LEFT_THUMB_INTERMEDIATE.label)
column.label(text=HumanBones.LEFT_THUMB_DISTAL.label)
column.label(text=HumanBones.LEFT_INDEX_PROXIMAL.label)
column.label(text=HumanBones.LEFT_INDEX_INTERMEDIATE.label)
column.label(text=HumanBones.LEFT_INDEX_DISTAL.label)
column.label(text=HumanBones.LEFT_MIDDLE_PROXIMAL.label)
column.label(text=HumanBones.LEFT_MIDDLE_INTERMEDIATE.label)
column.label(text=HumanBones.LEFT_MIDDLE_DISTAL.label)
column.label(text=HumanBones.LEFT_RING_PROXIMAL.label)
column.label(text=HumanBones.LEFT_RING_INTERMEDIATE.label)
column.label(text=HumanBones.LEFT_RING_DISTAL.label)
column.label(text=HumanBones.LEFT_LITTLE_PROXIMAL.label)
column.label(text=HumanBones.LEFT_LITTLE_INTERMEDIATE.label)
column.label(text=HumanBones.LEFT_LITTLE_DISTAL.label)
column.label(text=HumanBones.LEFT_TOES.label)
column = row.column()
icon = "USER"
bone_prop_search(column, HumanBones.LEFT_SHOULDER, icon, humanoid_props)
icon = "VIEW_PAN"
bone_prop_search(column, HumanBones.LEFT_THUMB_PROXIMAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_THUMB_INTERMEDIATE, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_THUMB_DISTAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_INDEX_PROXIMAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_INDEX_INTERMEDIATE, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_INDEX_DISTAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_MIDDLE_PROXIMAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_MIDDLE_INTERMEDIATE, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_MIDDLE_DISTAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_RING_PROXIMAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_RING_INTERMEDIATE, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_RING_DISTAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_LITTLE_PROXIMAL, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_LITTLE_INTERMEDIATE, icon, humanoid_props)
bone_prop_search(column, HumanBones.LEFT_LITTLE_DISTAL, icon, humanoid_props)
icon = "MOD_DYNAMICPAINT"
bone_prop_search(column, HumanBones.LEFT_TOES, icon, humanoid_props)
layout.label(text="Arm", icon="VIEW_PAN", translate=False) # TODO: 翻訳
layout.prop(
humanoid_props,
"arm_stretch",
)
layout.prop(humanoid_props, "upper_arm_twist")
layout.prop(humanoid_props, "lower_arm_twist")
layout.separator()
layout.label(text="Leg", icon="MOD_DYNAMICPAINT")
layout.prop(humanoid_props, "leg_stretch")
layout.prop(humanoid_props, "upper_leg_twist")
layout.prop(humanoid_props, "lower_leg_twist")
layout.prop(humanoid_props, "feet_spacing")
layout.separator()
layout.prop(humanoid_props, "has_translation_dof")
class VRM_PT_vrm0_humanoid_armature_object_property(bpy.types.Panel): # type: ignore[misc] # noqa: N801
bl_idname = "VRM_PT_vrm0_humanoid_armature_object_property"
bl_label = "VRM 0.x Humanoid"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "object"
bl_options = {"DEFAULT_CLOSED"}
bl_parent_id = VRM_PT_vrm_armature_object_property.bl_idname
@classmethod
def poll(cls, context: bpy.types.Context) -> bool:
return bool(
context.active_object
and context.active_object.type == "ARMATURE"
and hasattr(context.active_object.data, "vrm_addon_extension")
)
def draw_header(self, _context: bpy.types.Context) -> None:
self.layout.label(icon="ARMATURE_DATA")
def draw(self, context: bpy.types.Context) -> None:
ext = context.active_object.data.vrm_addon_extension
if isinstance(ext, VrmAddonArmatureExtensionPropertyGroup):
draw_vrm0_humanoid_layout(
context.active_object, self.layout, ext.vrm0.humanoid
)
class VRM_PT_vrm0_humanoid_ui(bpy.types.Panel): # type: ignore[misc] # noqa: N801
bl_idname = "VRM_PT_vrm0_humanoid_ui"
bl_label = "VRM 0.x Humanoid"
bl_space_type = "VIEW_3D"
bl_region_type = "UI"
bl_category = "VRM"
bl_options = {"DEFAULT_CLOSED"}
@classmethod
def poll(cls, context: bpy.types.Context) -> bool:
return search.armature_exists(context)
def draw_header(self, _context: bpy.types.Context) -> None:
self.layout.label(icon="USER")
def draw(self, context: bpy.types.Context) -> None:
armature = search.current_armature(context)
if (
armature
and hasattr(armature.data, "vrm_addon_extension")
and isinstance(
armature.data.vrm_addon_extension,
VrmAddonArmatureExtensionPropertyGroup,
)
):
draw_vrm0_humanoid_layout(
armature, self.layout, armature.data.vrm_addon_extension.vrm0.humanoid
)
def draw_vrm0_first_person_layout(
armature: bpy.types.Object,
context: bpy.types.Context,
layout: bpy.types.UILayout,
first_person_props: Vrm0FirstPersonPropertyGroup,
) -> None:
migrate(armature.name, defer=True)
blend_data = context.blend_data
layout.prop_search(
first_person_props.first_person_bone, "value", armature.data, "bones"
)
layout.prop(first_person_props, "first_person_bone_offset", icon="BONE_DATA")
layout.prop(first_person_props, "look_at_type_name")
box = layout.box()
box.label(text="Mesh Annotations", icon="FULLSCREEN_EXIT")
for mesh_annotation_index, mesh_annotation in enumerate(
first_person_props.mesh_annotations
):
row = box.row()
row.prop_search(mesh_annotation.mesh, "value", blend_data, "meshes")
row.prop(mesh_annotation, "first_person_flag")
remove_mesh_annotation_op = row.operator(
vrm0_operator.VRM_OT_remove_vrm0_first_person_mesh_annotation.bl_idname,
text="Remove",
icon="REMOVE",
)
remove_mesh_annotation_op.armature_name = armature.name
remove_mesh_annotation_op.mesh_annotation_index = mesh_annotation_index
add_mesh_annotation_op = box.operator(
vrm0_operator.VRM_OT_add_vrm0_first_person_mesh_annotation.bl_idname
)
add_mesh_annotation_op.armature_name = armature.name
box = layout.box()
box.label(text="Look At Horizontal Inner", icon="FULLSCREEN_EXIT")
box.prop(first_person_props.look_at_horizontal_inner, "curve")
box.prop(first_person_props.look_at_horizontal_inner, "x_range")
box.prop(first_person_props.look_at_horizontal_inner, "y_range")
box = layout.box()
box.label(text="Look At Horizontal Outer", icon="FULLSCREEN_ENTER")
box.prop(first_person_props.look_at_horizontal_outer, "curve")
box.prop(first_person_props.look_at_horizontal_outer, "x_range")
box.prop(first_person_props.look_at_horizontal_outer, "y_range")
box = layout.box()
box.label(text="Look At Vertical Up", icon="TRIA_UP")
box.prop(first_person_props.look_at_vertical_up, "curve")
box.prop(first_person_props.look_at_vertical_up, "x_range")
box.prop(first_person_props.look_at_vertical_up, "y_range")
box = layout.box()
box.label(text="Look At Vertical Down", icon="TRIA_DOWN")
box.prop(first_person_props.look_at_vertical_down, "curve")
box.prop(first_person_props.look_at_vertical_down, "x_range")
box.prop(first_person_props.look_at_vertical_down, "y_range")
class VRM_PT_vrm0_first_person_armature_object_property(bpy.types.Panel): # type: ignore[misc] # noqa: N801
bl_idname = "VRM_PT_vrm0_first_person_armature_object_property"
bl_label = "VRM 0.x First Person"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "object"
bl_options = {"DEFAULT_CLOSED"}
bl_parent_id = VRM_PT_vrm_armature_object_property.bl_idname
@classmethod
def poll(cls, context: bpy.types.Context) -> bool:
return bool(
context.active_object
and context.active_object.type == "ARMATURE"
and hasattr(context.active_object.data, "vrm_addon_extension")
)
def draw_header(self, _context: bpy.types.Context) -> None:
self.layout.label(icon="HIDE_OFF")
def draw(self, context: bpy.types.Context) -> None:
ext = context.active_object.data.vrm_addon_extension
if isinstance(ext, VrmAddonArmatureExtensionPropertyGroup):
draw_vrm0_first_person_layout(
context.active_object,
context,
self.layout,
ext.vrm0.first_person,
)
class VRM_PT_vrm0_first_person_ui(bpy.types.Panel): # type: ignore[misc] # noqa: N801
bl_idname = "VRM_PT_vrm0_first_person_ui"
bl_label = "VRM 0.x First Person"
bl_space_type = "VIEW_3D"
bl_region_type = "UI"
bl_category = "VRM"
bl_options = {"DEFAULT_CLOSED"}
@classmethod
def poll(cls, context: bpy.types.Context) -> bool:
return search.armature_exists(context)
def draw_header(self, _context: bpy.types.Context) -> None:
self.layout.label(icon="HIDE_OFF")
def draw(self, context: bpy.types.Context) -> None:
armature = search.current_armature(context)
if (
armature
and hasattr(armature.data, "vrm_addon_extension")
and isinstance(
armature.data.vrm_addon_extension,
VrmAddonArmatureExtensionPropertyGroup,
)
):
draw_vrm0_first_person_layout(
armature,
context,
self.layout,
armature.data.vrm_addon_extension.vrm0.first_person,
)
def draw_vrm0_blend_shape_master_layout(
armature: bpy.types.Object,
context: bpy.types.Context,
layout: bpy.types.UILayout,
blend_shape_master_props: Vrm0BlendShapeMasterPropertyGroup,
) -> None:
migrate(armature.name, defer=True)
blend_data = context.blend_data
for blend_shape_group_index, blend_shape_group_props in enumerate(
blend_shape_master_props.blend_shape_groups
):
row = layout.row()
row.alignment = "LEFT"
row.prop(
blend_shape_group_props,
"show_expanded",
icon="TRIA_DOWN" if blend_shape_group_props.show_expanded else "TRIA_RIGHT",
emboss=False,
text=blend_shape_group_props.name
+ " / "
+ blend_shape_group_props.preset_name,
translate=False,
)
if not blend_shape_group_props.show_expanded:
continue
box = layout.box()
box.prop(blend_shape_group_props, "name")
box.prop(blend_shape_group_props, "preset_name")
box.prop(blend_shape_group_props, "is_binary", icon="IPO_CONSTANT")
box.separator()
row = box.row()
row.alignment = "LEFT"
row.prop(
blend_shape_group_props,
"show_expanded_binds",
icon="TRIA_DOWN"
if blend_shape_group_props.show_expanded_binds
else "TRIA_RIGHT",
emboss=False,
)
if blend_shape_group_props.show_expanded_binds:
for bind_index, bind_props in enumerate(blend_shape_group_props.binds):
bind_box = box.box()
bind_box.prop_search(
bind_props.mesh, "value", blend_data, "meshes", text="Mesh"
)
if (
bind_props.mesh.value
and bind_props.mesh.value in blend_data.meshes
and blend_data.meshes[bind_props.mesh.value]
and blend_data.meshes[bind_props.mesh.value].shape_keys
and blend_data.meshes[bind_props.mesh.value].shape_keys.key_blocks
and blend_data.meshes[
bind_props.mesh.value
].shape_keys.key_blocks.keys()
):
bind_box.prop_search(
bind_props,
"index",
blend_data.meshes[bind_props.mesh.value].shape_keys,
"key_blocks",
text="Shape key",
)
bind_box.prop(bind_props, "weight")
remove_blend_shape_bind_op = bind_box.operator(
vrm0_operator.VRM_OT_remove_vrm0_blend_shape_bind.bl_idname,
icon="REMOVE",
)
remove_blend_shape_bind_op.armature_name = armature.name
remove_blend_shape_bind_op.blend_shape_group_index = (
blend_shape_group_index
)
remove_blend_shape_bind_op.bind_index = bind_index
add_blend_shape_bind_op = box.operator(
vrm0_operator.VRM_OT_add_vrm0_blend_shape_bind.bl_idname, icon="ADD"
)
add_blend_shape_bind_op.armature_name = armature.name
add_blend_shape_bind_op.blend_shape_group_index = blend_shape_group_index
row = box.row()
row.alignment = "LEFT"
row.prop(
blend_shape_group_props,
"show_expanded_material_values",
icon="TRIA_DOWN"
if blend_shape_group_props.show_expanded_material_values
else "TRIA_RIGHT",
emboss=False,
)
if blend_shape_group_props.show_expanded_material_values:
for material_value_index, material_value_props in enumerate(
blend_shape_group_props.material_values
):
material_value_box = box.box()
material_value_box.prop_search(
material_value_props, "material", blend_data, "materials"
)
material_value_box.prop(material_value_props, "property_name")
for (
target_value_index,
target_value_props,
) in enumerate(material_value_props.target_value):
target_value_row = material_value_box.split(align=True, factor=0.7)
target_value_row.prop(
target_value_props, "value", text=f"Value {target_value_index}"
)
remove_target_value_op = target_value_row.operator(
vrm0_operator.VRM_OT_remove_vrm0_material_value_bind_target_value.bl_idname,
text="Remove",
icon="REMOVE",
)
remove_target_value_op.armature_name = armature.name
remove_target_value_op.blend_shape_group_index = (
blend_shape_group_index
)
remove_target_value_op.material_value_index = material_value_index
remove_target_value_op.target_value_index = target_value_index
add_target_value_op = material_value_box.operator(
vrm0_operator.VRM_OT_add_vrm0_material_value_bind_target_value.bl_idname,
icon="ADD",
)
add_target_value_op.armature_name = armature.name
add_target_value_op.blend_shape_group_index = blend_shape_group_index
add_target_value_op.material_value_index = material_value_index
remove_material_value_op = material_value_box.operator(
vrm0_operator.VRM_OT_remove_vrm0_material_value_bind.bl_idname,
icon="REMOVE",
)
remove_material_value_op.armature_name = armature.name
remove_material_value_op.blend_shape_group_index = (
blend_shape_group_index
)
remove_material_value_op.material_value_index = material_value_index
add_material_value_op = box.operator(
vrm0_operator.VRM_OT_add_vrm0_material_value_bind.bl_idname, icon="ADD"
)
add_material_value_op.armature_name = armature.name
add_material_value_op.blend_shape_group_index = blend_shape_group_index
remove_blend_shape_group_op = box.operator(
vrm0_operator.VRM_OT_remove_vrm0_blend_shape_group.bl_idname, icon="REMOVE"
)
remove_blend_shape_group_op.armature_name = armature.name
remove_blend_shape_group_op.blend_shape_group_index = blend_shape_group_index
add_blend_shape_group_op = layout.operator(
vrm0_operator.VRM_OT_add_vrm0_blend_shape_group.bl_idname, icon="ADD"
)
add_blend_shape_group_op.name = "New"
add_blend_shape_group_op.armature_name = armature.name
class VRM_PT_vrm0_blend_shape_master_armature_object_property(bpy.types.Panel): # type: ignore[misc] # noqa: N801
bl_idname = "VRM_PT_vrm0_blend_shape_master_armature_object_property"
bl_label = "VRM 0.x Blend Shape Proxy"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "object"
bl_options = {"DEFAULT_CLOSED"}
bl_parent_id = VRM_PT_vrm_armature_object_property.bl_idname
@classmethod
def poll(cls, context: bpy.types.Context) -> bool:
return bool(
context.active_object
and context.active_object.type == "ARMATURE"
and hasattr(context.active_object.data, "vrm_addon_extension")
)
def draw_header(self, _context: bpy.types.Context) -> None:
self.layout.label(icon="SHAPEKEY_DATA")
def draw(self, context: bpy.types.Context) -> None:
ext = context.active_object.data.vrm_addon_extension
if isinstance(ext, VrmAddonArmatureExtensionPropertyGroup):
draw_vrm0_blend_shape_master_layout(
context.active_object, context, self.layout, ext.vrm0.blend_shape_master
)
class VRM_PT_vrm0_blend_shape_master_ui(bpy.types.Panel): # type: ignore[misc] # noqa: N801
bl_idname = "VRM_PT_vrm0_blend_shape_master_ui"
bl_label = "VRM 0.x Blend Shape Proxy"
bl_space_type = "VIEW_3D"
bl_region_type = "UI"
bl_category = "VRM"
bl_options = {"DEFAULT_CLOSED"}
@classmethod
def poll(cls, context: bpy.types.Context) -> bool:
return search.armature_exists(context)
def draw_header(self, _context: bpy.types.Context) -> None:
self.layout.label(icon="SHAPEKEY_DATA")
def draw(self, context: bpy.types.Context) -> None:
armature = search.current_armature(context)
if (
armature
and hasattr(armature.data, "vrm_addon_extension")
and isinstance(
armature.data.vrm_addon_extension,
VrmAddonArmatureExtensionPropertyGroup,
)
):
draw_vrm0_blend_shape_master_layout(
armature,
context,
self.layout,
armature.data.vrm_addon_extension.vrm0.blend_shape_master,
)
def draw_vrm0_secondary_animation_layout(
armature: bpy.types.Object,
layout: bpy.types.UILayout,
secondary_animation: Vrm0SecondaryAnimationPropertyGroup,
) -> None:
migrate(armature.name, defer=True)
data = armature.data
bone_groups_box = layout.box()
bone_groups_box.label(text="Spring Bone Groups", icon="GROUP_BONE")
for bone_group_index, bone_group_props in enumerate(
secondary_animation.bone_groups
):
row = bone_groups_box.row()
row.alignment = "LEFT"
text = ""
if bone_group_props.bones:
text = (
"("
+ ", ".join(map(lambda bone: str(bone.value), bone_group_props.bones))
+ ")"
)
if bone_group_props.center.value:
if text:
text = " - " + text
text = bone_group_props.center.value + text
if bone_group_props.comment:
if text:
text = " / " + text
text = bone_group_props.comment + text
if not text:
text = "(EMPTY)"
row.prop(
bone_group_props,
"show_expanded",
icon="TRIA_DOWN" if bone_group_props.show_expanded else "TRIA_RIGHT",
emboss=False,
text=text,
translate=False,
)
if not bone_group_props.show_expanded:
continue
box = bone_groups_box.box()
row = box.row()
box.prop(bone_group_props, "comment", icon="BOOKMARKS")
box.prop(bone_group_props, "stiffiness", icon="RIGID_BODY_CONSTRAINT")
box.prop(bone_group_props, "drag_force", icon="FORCE_DRAG")
box.separator()
box.prop(bone_group_props, "gravity_power", icon="OUTLINER_OB_FORCE_FIELD")
box.prop(bone_group_props, "gravity_dir", icon="OUTLINER_OB_FORCE_FIELD")
box.separator()
box.prop_search(
bone_group_props.center,
"value",
data,
"bones",
icon="PIVOT_MEDIAN",
text="Center Bone",
)
box.prop(
bone_group_props,
"hit_radius",
icon="MOD_PHYSICS",
)
box.separator()
row = box.row()
row.alignment = "LEFT"
row.prop(
bone_group_props,
"show_expanded_bones",
icon="TRIA_DOWN" if bone_group_props.show_expanded_bones else "TRIA_RIGHT",
emboss=False,
)
if bone_group_props.show_expanded_bones:
for bone_index, bone in enumerate(bone_group_props.bones):
bone_row = box.split(align=True, factor=0.7)
bone_row.prop_search(bone, "value", data, "bones", text="")
remove_bone_op = bone_row.operator(
vrm0_operator.VRM_OT_remove_vrm0_secondary_animation_group_bone.bl_idname,
icon="REMOVE",
text="Remove",
)
remove_bone_op.armature_name = armature.name
remove_bone_op.bone_group_index = bone_group_index
remove_bone_op.bone_index = bone_index
add_bone_op = box.operator(
vrm0_operator.VRM_OT_add_vrm0_secondary_animation_group_bone.bl_idname,
icon="ADD",
)
add_bone_op.armature_name = armature.name
add_bone_op.bone_group_index = bone_group_index
row = box.row()
row.alignment = "LEFT"
row.prop(
bone_group_props,
"show_expanded_collider_groups",
icon="TRIA_DOWN"
if bone_group_props.show_expanded_collider_groups
else "TRIA_RIGHT",
emboss=False,
)
if bone_group_props.show_expanded_collider_groups:
for collider_group_index, collider_group in enumerate(
bone_group_props.collider_groups
):
collider_group_row = box.split(align=True, factor=0.7)
collider_group_row.prop_search(
collider_group,
"value",
secondary_animation,
"collider_groups",
text="",
)
remove_collider_group_op = collider_group_row.operator(
vrm0_operator.VRM_OT_remove_vrm0_secondary_animation_group_collider_group.bl_idname,
icon="REMOVE",
text="Remove",
)
remove_collider_group_op.armature_name = armature.name
remove_collider_group_op.bone_group_index = bone_group_index
remove_collider_group_op.collider_group_index = collider_group_index
add_collider_group_op = box.operator(
vrm0_operator.VRM_OT_add_vrm0_secondary_animation_group_collider_group.bl_idname,
icon="ADD",
)
add_collider_group_op.armature_name = armature.name
add_collider_group_op.bone_group_index = bone_group_index
remove_bone_group_op = box.operator(
vrm0_operator.VRM_OT_remove_vrm0_secondary_animation_group.bl_idname,
icon="REMOVE",
)
remove_bone_group_op.armature_name = armature.name
remove_bone_group_op.bone_group_index = bone_group_index
add_bone_group_op = bone_groups_box.operator(
vrm0_operator.VRM_OT_add_vrm0_secondary_animation_group.bl_idname, icon="ADD"
)
add_bone_group_op.armature_name = armature.name
collider_groups_box = layout.box()
collider_groups_box.label(text="Collider Groups", icon="SPHERE")
for collider_group_index, collider_group_props in enumerate(
secondary_animation.collider_groups
):
row = collider_groups_box.row()
row.alignment = "LEFT"
row.prop(
collider_group_props,
"show_expanded",
icon="TRIA_DOWN" if collider_group_props.show_expanded else "TRIA_RIGHT",
emboss=False,
text=collider_group_props.name,
translate=False,
)
if not collider_group_props.show_expanded:
continue
box = collider_groups_box.box()
row = box.row()
box.label(text=collider_group_props.name)
box.prop_search(collider_group_props.node, "value", armature.data, "bones")
for collider_index, collider_props in enumerate(collider_group_props.colliders):
collider_row = box.split(align=True, factor=0.5)
collider_row.prop(
collider_props.blender_object, "name", icon="MESH_UVSPHERE", text=""
)
collider_row.prop(
collider_props.blender_object, "empty_display_size", text=""
)
remove_collider_op = collider_row.operator(
vrm0_operator.VRM_OT_remove_vrm0_secondary_animation_collider_group_collider.bl_idname,
icon="REMOVE",
text="Remove",
)
remove_collider_op.armature_name = armature.name
remove_collider_op.collider_group_index = collider_group_index
remove_collider_op.collider_index = collider_index
add_collider_op = box.operator(
vrm0_operator.VRM_OT_add_vrm0_secondary_animation_collider_group_collider.bl_idname,
icon="ADD",
)
add_collider_op.armature_name = armature.name
add_collider_op.collider_group_index = collider_group_index
add_collider_op.bone_name = collider_group_props.node.value
remove_collider_group_op = box.operator(
vrm0_operator.VRM_OT_remove_vrm0_secondary_animation_collider_group.bl_idname,
icon="REMOVE",
)
remove_collider_group_op.armature_name = armature.name
remove_collider_group_op.collider_group_index = collider_group_index
add_collider_group_op = collider_groups_box.operator(
vrm0_operator.VRM_OT_add_vrm0_secondary_animation_collider_group.bl_idname,
icon="ADD",
)
add_collider_group_op.armature_name = armature.name
class VRM_PT_vrm0_secondary_animation_armature_object_property(bpy.types.Panel): # type: ignore[misc] # noqa: N801
bl_idname = "VRM_PT_vrm0_secondary_animation_armature_object_property"
bl_label = "VRM 0.x Spring Bone"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "object"
bl_options = {"DEFAULT_CLOSED"}
bl_parent_id = VRM_PT_vrm_armature_object_property.bl_idname
@classmethod
def poll(cls, context: bpy.types.Context) -> bool:
return bool(
context.active_object
and context.active_object.type == "ARMATURE"
and hasattr(context.active_object.data, "vrm_addon_extension")
)
def draw_header(self, _context: bpy.types.Context) -> None:
self.layout.label(icon="PHYSICS")
def draw(self, context: bpy.types.Context) -> None:
ext = context.active_object.data.vrm_addon_extension
if isinstance(ext, VrmAddonArmatureExtensionPropertyGroup):
draw_vrm0_secondary_animation_layout(
context.active_object, self.layout, ext.vrm0.secondary_animation
)
class VRM_PT_vrm0_secondary_animation_ui(bpy.types.Panel): # type: ignore[misc] # noqa: N801
bl_idname = "VRM_PT_vrm0_secondary_animation_ui"
bl_label = "VRM 0.x Spring Bone"
bl_space_type = "VIEW_3D"
bl_region_type = "UI"
bl_category = "VRM"
bl_options = {"DEFAULT_CLOSED"}
@classmethod
def poll(cls, context: bpy.types.Context) -> bool:
return search.armature_exists(context)
def draw_header(self, _context: bpy.types.Context) -> None:
self.layout.label(icon="PHYSICS")
def draw(self, context: bpy.types.Context) -> None:
armature = search.current_armature(context)
if (
armature
and hasattr(armature.data, "vrm_addon_extension")
and isinstance(
armature.data.vrm_addon_extension,
VrmAddonArmatureExtensionPropertyGroup,
)
):
draw_vrm0_secondary_animation_layout(
armature,
self.layout,
armature.data.vrm_addon_extension.vrm0.secondary_animation,
)
def draw_vrm0_meta_layout(
armature: bpy.types.Object,
context: bpy.types.Context,
layout: bpy.types.UILayout,
meta_props: Vrm0MetaPropertyGroup,
) -> None:
migrate(armature.name, defer=True)
blend_data = context.blend_data
layout.prop_search(meta_props, "texture", blend_data, "images", text="Thumbnail")
layout.prop(meta_props, "title", icon="FILE_BLEND")
layout.prop(meta_props, "version", icon="LINENUMBERS_ON")
layout.prop(meta_props, "author", icon="USER")
layout.prop(meta_props, "contact_information", icon="URL")
layout.prop(meta_props, "reference", icon="URL")
layout.prop(meta_props, "allowed_user_name", icon="MATCLOTH")
layout.prop(
meta_props,
"violent_ussage_name",
icon="ORPHAN_DATA",
)
layout.prop(meta_props, "sexual_ussage_name", icon="HEART")
layout.prop(
meta_props,
"commercial_ussage_name",
icon="SOLO_OFF",
)
layout.prop(meta_props, "other_permission_url", icon="URL")
layout.prop(meta_props, "license_name", icon="COMMUNITY")
if meta_props.license_name == Vrm0MetaPropertyGroup.LICENSE_NAME_OTHER:
layout.prop(meta_props, "other_license_url", icon="URL")
class VRM_PT_vrm0_meta_armature_object_property(bpy.types.Panel): # type: ignore[misc] # noqa: N801
bl_idname = "VRM_PT_vrm0_meta_armature_object_property"
bl_label = "VRM 0.x Meta"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "object"
bl_options = {"DEFAULT_CLOSED"}
bl_parent_id = VRM_PT_vrm_armature_object_property.bl_idname
@classmethod
def poll(cls, context: bpy.types.Context) -> bool:
return bool(
context.active_object
and context.active_object.type == "ARMATURE"
and hasattr(context.active_object.data, "vrm_addon_extension")
)
def draw_header(self, _context: bpy.types.Context) -> None:
self.layout.label(icon="FILE_BLEND")
def draw(self, context: bpy.types.Context) -> None:
ext = context.active_object.data.vrm_addon_extension
if isinstance(ext, VrmAddonArmatureExtensionPropertyGroup):
draw_vrm0_meta_layout(
context.active_object, context, self.layout, ext.vrm0.meta
)
class VRM_PT_vrm0_meta_ui(bpy.types.Panel): # type: ignore[misc] # noqa: N801
bl_idname = "VRM_PT_vrm0_meta_ui"
bl_label = "VRM 0.x Meta"
bl_space_type = "VIEW_3D"
bl_region_type = "UI"
bl_category = "VRM"
bl_options = {"DEFAULT_CLOSED"}
@classmethod
def poll(cls, context: bpy.types.Context) -> bool:
return search.armature_exists(context)
def draw_header(self, _context: bpy.types.Context) -> None:
self.layout.label(icon="FILE_BLEND")
def draw(self, context: bpy.types.Context) -> None:
armature = search.current_armature(context)
if (
armature
and hasattr(armature.data, "vrm_addon_extension")
and isinstance(
armature.data.vrm_addon_extension,
VrmAddonArmatureExtensionPropertyGroup,
)
):
draw_vrm0_meta_layout(
armature,
context,
self.layout,
armature.data.vrm_addon_extension.vrm0.meta,
)
```
#### File: VRM_Addon_for_Blender/io_scene_vrm/registration.py
```python
from typing import Any
import bpy
from bpy.app.handlers import persistent
from .common import gltf2_addon_support, preferences, shader, version
from .editor import (
extension,
glsl_drawer,
make_armature,
operator,
panel,
property_group,
validation,
)
from .editor.vrm0 import operator as vrm0_operator
from .editor.vrm0 import panel as vrm0_panel
from .editor.vrm0 import property_group as vrm0_property_group
from .exporter import export_scene
from .importer import import_scene
from .locale.translation_dictionary import translation_dictionary
if persistent: # for fake-bpy-modules
@persistent # type: ignore[misc]
def add_shaders(_dummy: Any) -> None:
shader.add_shaders()
classes = [
gltf2_addon_support.WM_OT_vrm_gltf2_addon_disabled_warning,
property_group.ObjectPropertyGroup,
property_group.StringPropertyGroup,
property_group.FloatPropertyGroup,
property_group.BonePropertyGroup,
property_group.MeshPropertyGroup,
vrm0_property_group.Vrm0MaterialValueBindPropertyGroup,
vrm0_property_group.Vrm0BlendShapeBindPropertyGroup,
vrm0_property_group.Vrm0BlendShapeGroupPropertyGroup,
vrm0_property_group.Vrm0BlendShapeMasterPropertyGroup,
vrm0_property_group.Vrm0MeshAnnotationPropertyGroup,
vrm0_property_group.Vrm0DegreeMapPropertyGroup,
vrm0_property_group.Vrm0FirstPersonPropertyGroup,
vrm0_property_group.Vrm0HumanoidBonePropertyGroup,
vrm0_property_group.Vrm0HumanoidPropertyGroup,
vrm0_property_group.Vrm0MetaPropertyGroup,
vrm0_property_group.Vrm0SecondaryAnimationCollider,
vrm0_property_group.Vrm0SecondaryAnimationColliderGroupPropertyGroup,
vrm0_property_group.Vrm0SecondaryAnimationGroupPropertyGroup,
vrm0_property_group.Vrm0SecondaryAnimationPropertyGroup,
# vrm0_gizmo_group.Vrm0FirstPersonBoneOffsetGizmoGroup,
panel.VRM_PT_current_selected_armature,
panel.VRM_PT_controller,
panel.VRM_PT_vrm_armature_object_property,
vrm0_panel.VRM_PT_vrm0_meta_armature_object_property,
vrm0_panel.VRM_PT_vrm0_meta_ui,
vrm0_panel.VRM_PT_vrm0_humanoid_armature_object_property,
vrm0_panel.VRM_PT_vrm0_humanoid_ui,
vrm0_panel.VRM_PT_vrm0_blend_shape_master_armature_object_property,
vrm0_panel.VRM_PT_vrm0_blend_shape_master_ui,
vrm0_panel.VRM_PT_vrm0_first_person_armature_object_property,
vrm0_panel.VRM_PT_vrm0_first_person_ui,
vrm0_panel.VRM_PT_vrm0_secondary_animation_armature_object_property,
vrm0_panel.VRM_PT_vrm0_secondary_animation_ui,
vrm0_operator.VRM_OT_add_vrm0_first_person_mesh_annotation,
vrm0_operator.VRM_OT_remove_vrm0_first_person_mesh_annotation,
vrm0_operator.VRM_OT_add_vrm0_material_value_bind,
vrm0_operator.VRM_OT_remove_vrm0_material_value_bind,
vrm0_operator.VRM_OT_add_vrm0_material_value_bind_target_value,
vrm0_operator.VRM_OT_remove_vrm0_material_value_bind_target_value,
vrm0_operator.VRM_OT_add_vrm0_blend_shape_bind,
vrm0_operator.VRM_OT_remove_vrm0_blend_shape_bind,
vrm0_operator.VRM_OT_add_vrm0_secondary_animation_collider_group_collider,
vrm0_operator.VRM_OT_remove_vrm0_secondary_animation_collider_group_collider,
vrm0_operator.VRM_OT_add_vrm0_secondary_animation_group_bone,
vrm0_operator.VRM_OT_remove_vrm0_secondary_animation_group_bone,
vrm0_operator.VRM_OT_add_vrm0_secondary_animation_group_collider_group,
vrm0_operator.VRM_OT_remove_vrm0_secondary_animation_group_collider_group,
vrm0_operator.VRM_OT_add_vrm0_blend_shape_group,
vrm0_operator.VRM_OT_remove_vrm0_blend_shape_group,
vrm0_operator.VRM_OT_add_vrm0_secondary_animation_group,
vrm0_operator.VRM_OT_remove_vrm0_secondary_animation_group,
vrm0_operator.VRM_OT_add_vrm0_secondary_animation_collider_group,
vrm0_operator.VRM_OT_remove_vrm0_secondary_animation_collider_group,
# editor.detail_mesh_maker.ICYP_OT_detail_mesh_maker,
glsl_drawer.ICYP_OT_draw_model,
glsl_drawer.ICYP_OT_remove_draw_model,
make_armature.ICYP_OT_make_armature,
# editor.mesh_from_bone_envelopes.ICYP_OT_make_mesh_from_bone_envelopes,
operator.VRM_OT_add_human_bone_custom_property,
operator.VRM_OT_add_defined_human_bone_custom_property, # deprecated
operator.VRM_OT_add_extensions_to_armature,
operator.VRM_OT_add_required_human_bone_custom_property, # deprecated
operator.VRM_OT_simplify_vroid_bones,
operator.VRM_OT_vroid2vrc_lipsync_from_json_recipe,
operator.VRM_OT_save_human_bone_mappings,
operator.VRM_OT_load_human_bone_mappings,
validation.VrmValidationError,
export_scene.validation.WM_OT_vrm_validator,
export_scene.VRM_PT_export_error_messages,
export_scene.EXPORT_SCENE_OT_vrm,
import_scene.LicenseConfirmation,
import_scene.WM_OT_license_confirmation,
import_scene.IMPORT_SCENE_OT_vrm,
# importer.blend_model.ICYP_OT_select_helper,
preferences.VrmAddonPreferences,
vrm0_property_group.Vrm0PropertyGroup,
extension.VrmAddonArmatureExtensionPropertyGroup,
]
# アドオン有効化時の処理
def register(init_version: Any) -> None:
# Sanity check
if init_version != version.version():
raise Exception(
f"Sanity error: version mismatch: {init_version} != {version.version()}"
)
for cls in classes:
bpy.utils.register_class(cls)
bpy.types.TOPBAR_MT_file_import.append(import_scene.menu_import)
bpy.types.TOPBAR_MT_file_export.append(export_scene.menu_export)
bpy.types.VIEW3D_MT_armature_add.append(panel.add_armature)
# bpy.types.VIEW3D_MT_mesh_add.append(panel.make_mesh)
bpy.app.handlers.load_post.append(add_shaders)
bpy.app.translations.register(
preferences.addon_package_name,
translation_dictionary,
)
bpy.types.Armature.vrm_addon_extension = bpy.props.PointerProperty(
type=extension.VrmAddonArmatureExtensionPropertyGroup
)
# アドオン無効化時の処理
def unregister() -> None:
bpy.app.translations.unregister(preferences.addon_package_name)
bpy.app.handlers.load_post.remove(add_shaders)
bpy.types.VIEW3D_MT_armature_add.remove(panel.add_armature)
# bpy.types.VIEW3D_MT_mesh_add.remove(panel.make_mesh)
bpy.types.TOPBAR_MT_file_import.remove(import_scene.menu_import)
bpy.types.TOPBAR_MT_file_export.remove(export_scene.menu_export)
for cls in reversed(classes):
bpy.utils.unregister_class(cls)
if hasattr(bpy.types.Armature, "vrm_addon_extension"):
del bpy.types.Armature.vrm_addon_extension
if hasattr(bpy.types.Bone, "vrm_addon_extension"):
del bpy.types.Bone.vrm_addon_extension
if hasattr(bpy.types.ShapeKey, "vrm_addon_extension"):
del bpy.types.ShapeKey.vrm_addon_extension
``` |
{
"source": "98antlaz/flaskStore",
"score": 3
} |
#### File: flaskStore/store/store.py
```python
from flask import Flask, render_template, request, url_for
from dbhandler import dbhandler as db
app = Flask(__name__)
"""
TODO:
> Finish modal inputs
> Create a DB handler
> > Connect store.py to DB handler (send and receive data)
> Showcase products in configure
> Add edit/delete functionality
"""
@app.route("/")
def index():
return render_template("index.html")
@app.route("/store")
def store():
return render_template("store.html")
@app.route("/configure", methods=["GET", "POST"])
def configure():
products = db().getProducts()
if(request.method == "POST"):
if("create" in request.form):
print(request.form["name"]) #Prints name input value
return render_template("configure.html", products = products)
if(__name__ == "__main__"):
app.run()
``` |
{
"source": "98Glopes/complex_numbers",
"score": 4
} |
#### File: 98Glopes/complex_numbers/complex_number.py
```python
import math
class ComplexNumber():
"""
Class to implement complex number representation in python
mode argument must be "rec" to rectangulor mode or "pol" to polar mode
in rec mode: "a" is the real component and "b" is the imaginary component
in pol mode: "a" is the absolute value of vector and "b" is the vector angle
the pashe angle is printed in deegres
"""
def __init__(self, mode, a, b):
self.mode = mode
if self.mode == 'rec':
self.real = a
self.imag = b
self._to_polar()
elif self.mode == 'pol':
self.abs = a
self.phase = math.radians(b)
self._to_rec()
def _to_polar(self):
self.abs = math.sqrt(self.real**2 + self.imag**2)
self.phase = math.atan2(self.imag, self.real)
def _to_rec(self):
self.real = self.abs*math.cos(self.phase)
self.imag = self.abs*math.sin(self.phase)
def __str__(self):
if self.mode == 'rec':
return "%.2f + %.2fi" % (self.real, self.imag)
elif self.mode == 'pol':
return "%.2f < %.2f°" % (self.abs, math.degrees(self.phase))
def __add__(self, other):
a = self.real + other.real
b = self.imag + other.imag
return ComplexNumber('rec', a, b)
def __sub__(self, other):
a = self.real - other.real
b = self.imag - other.imag
return ComplexNumber('rec', a, b)
def __mul__(self, other):
a = self.abs * other.abs
b = self.phase + other.phase
return ComplexNumber('pol', a, b)
def __div__(self, other):
a = self.abs / other.abs
b = self.phase - other.phase
return ComplexNumber('pol', a, b)
``` |
{
"source": "98Glopes/smartiot",
"score": 2
} |
#### File: apps/api/models.py
```python
from django.contrib.auth.models import User
from django.db import models
from apps.api.utils import get_random_string
DATA_TYPE_CHOICES = (
('i', 'int'),
('f', 'float'),
('s', 'string')
)
DATA_TYPE_CAST = {
'i': int,
'f': float,
's': str,
}
class Device(models.Model):
id = models.CharField(max_length=4, primary_key=True, default=get_random_string)
user = models.ForeignKey(User, on_delete=models.CASCADE)
name = models.CharField(max_length=30)
area = models.CharField(max_length=30)
def __repr__(self):
return self.name
def __str__(self):
return self.name
class Sensor(models.Model):
id = models.CharField(max_length=4, primary_key=True, default=get_random_string)
name = models.CharField(max_length=30)
device = models.ForeignKey(Device, on_delete=models.CASCADE)
data_type = models.CharField(max_length=7, choices=DATA_TYPE_CHOICES, blank=False, null=False)
def __repr__(self):
return self.name
def __str__(self):
return self.name
class Read(models.Model):
sensor = models.ForeignKey(Sensor, on_delete=models.CASCADE)
timestamp = models.DateTimeField(editable=True, null=False, blank=False)
gateway_id = models.CharField(max_length=30)
rssi = models.FloatField()
snr = models.FloatField()
raw_value = models.CharField(max_length=30)
@property
def value(self):
cast = DATA_TYPE_CAST[self.sensor.data_type]
return cast(self.raw_value)
def __str__(self):
return F"{self.sensor.device.id}.{self.sensor.id}.{self.timestamp}"
``` |
{
"source": "98k-bot/model_differential_privacy",
"score": 3
} |
#### File: model_differential_privacy/train_DL_model/train_models.py
```python
import sys
sys.path.append("..")
from train_DL_model import model_params
from utils import util_functions as utils
import os, numpy as np
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.callbacks import ModelCheckpoint
import tensorflow as tf
#tf.compat.v1.disable_eager_execution()
########################################################################################
# Hard-coded rules. Please change this if you are changing the dataset format
########################################################################################
# 1. Provide the order in which the labels are provided in the label matrix
task_mapping = {"shape": 0, "color": 1, "size": 2, "quadrant": 3, "background": 4}
# 2. Provide the max number of classes in each task
label_num = { "shape": 5, "color": 7, "size": 3, "quadrant": 4, "background": 3}
########################################################################################
# Function that defines the DL model to be trained.
# Edit this function to use custom DL model.
# This function should written a valid keras or tf.keras Model object
########################################################################################
def build_model(num_lables):
"""Define the deep learning model to be trained"""
from keras.applications import DenseNet121
from keras.layers import (Dense, Dropout, Flatten)
from keras.models import Model, Sequential, load_model
base_model = DenseNet121(include_top=False, weights=None, input_shape=(256,256,3))
flat_1 = Flatten()(base_model.output)
cus_dense_1 = Dense(512, activation='relu', name='cus_dense_1')(flat_1)
cus_dense_do_1 = Dropout(0.5, name='cus_dense_do_1')(cus_dense_1)
cus_dense_2 = Dense(100, activation='relu', name='cus_dense_2')(cus_dense_do_1)
cus_dense_do_2 = Dropout(0.3, name='cus_dense_do_2')(cus_dense_2)
cus_dense_3 = Dense(num_lables, activation='softmax', name='cus_dense_3')(cus_dense_do_2)
model = Model(base_model.input, cus_dense_3)
return model
def train_models():
"""This is the main function that trains the model for one or many tasks"""
task = model_params.task
for task_key, task_value in task_mapping.items():
if(task == 'all' or task == task_key):
print("==================================================")
print("Building model for task ..... ", task_key)
num_task_labels = label_num[task_key]
model_name = model_params.output_name_prefix + "_" + task_key
# Edit this method to use custom DL models.
model = build_model(num_task_labels)
print("Printing model summary for task", task_key)
print(model.summary())
print("\nLoading training dataset ...... ")
data_type = "train"
X = np.load(model_params.train_data_path)
x_train = X["data"]
answer = X["lables"][:,task_value]
print("Train data shape", x_train.shape)
print("Train labels shapes ", answer.shape)
print("Train labels set", set(answer))
print("Pre-processing training dataset ...... ")
x_train = x_train.astype('float32')
x_train /= 255
total_data_point = x_train.shape[0]
data_indices = np.arange(total_data_point)
np.random.shuffle(data_indices)
x_train = x_train.take(data_indices, axis=0)
answer = answer.take(data_indices, axis=0)
y_train = to_categorical(answer, num_task_labels)
utils.create_directory(model_params.model_dir)
filepath = os.path.join(model_params.model_dir, model_name + "_e{epoch:02d}-acc{val_accuracy:.5f}.hdf5")
#checkpoint = ModelCheckpoint(filepath, monitor='val_accuracy', verbose=1, save_best_only=True, mode='max')
#callbacks_list = [checkpoint]
#checkpoint_filepath = '/tmp/checkpoint'
model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(
filepath=filepath,
save_weights_only=True,
monitor='val_accuracy',
mode='max',
save_best_only=True)
print("Submitting the model for training ...... ")
adam = Adam(lr=model_params.learning_rate, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)
model.compile(optimizer=adam, loss=model_params.loss_function, metrics=['accuracy'])
model.fit(x_train, y_train, batch_size=model_params.batch_size, epochs=model_params.epoch,
verbose=model_params.verbose, validation_split=model_params.validation_split, callbacks= [model_checkpoint_callback])
#model.fit(x_train, y_train, batch_size=model_params.batch_size, epochs=model_params.epoch, verbose=model_params.verbose, validation_split=model_params.validation_split, callbacks=callbacks_list)
print("\nTraining has finished ...... ")
#model.save(os.path.join(model_params.model_dir, model_name + "_final.hdf5"))
#print("Trained model store at: ", os.path.join(model_params.model_dir, model_name + "_final.hdf5"))
print("\nLoading test dataset ...... ")
data_type = "test"
test_data = np.load(model_params.test_data_path)
test_data_x = test_data["data"]
test_data_answer = test_data["lables"][:,task_value]
print("Test data shape", test_data_x.shape)
print("Test lables shapes ", test_data_answer.shape)
print("Test lables set", set(test_data_answer))
print("Pre-processing test dataset ...... ")
test_data_x = test_data_x.astype('float32')
test_data_x /= 255
test_data_answer_one_hot = to_categorical(test_data_answer, num_task_labels)
print("Evaluating the model using test data ...... ")
score = model.evaluate(x=test_data_x, y=test_data_answer_one_hot, verbose=model_params.verbose)
print("\nTest Score", score)
return model
if __name__ == "__main__":
train_models()
``` |
{
"source": "98k-bot/SMPyBandits",
"score": 2
} |
#### File: Experiment/Seznec19a_Fig2/plot.py
```python
from SMPyBandits.Policies import wSWA, FEWA, EFF_FEWA
import os
import numpy as np
from numpy import format_float_scientific
from matplotlib import pyplot as plt
plt.style.use('seaborn-colorblind')
plt.style.use('style.mplstyle')
def fig2A(data, name='fig2.pdf', ylim=2400, ylim2=500):
# -------------- PLOT --------------
legend_size = 0.45
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, gridspec_kw={'width_ratios': [1, 1, legend_size]})
N_arms = 9
ind = np.arange(N_arms) # the x locations for the groups
width = 0.7 # the width of the bars
L = np.array([0.001 * np.sqrt(10) ** (i) for i in range(9)])
for i, policy in enumerate(data):
X = range(data[policy]["mean"].shape[0])
ax1.plot(X, data[policy]["mean"], linewidth=3)
color = ax1.get_lines()[-1].get_c()
ax1.plot(X, data[policy]["uppq"], linestyle='--', color= color, linewidth=1)
ax1.plot(X, data[policy]["lowq"], linestyle='--', color= color, linewidth=1)
ax1.fill_between(X, data[policy]["uppq"], data[policy]["lowq"], alpha=.05, color= color)
height = data[policy]["pull"][1:] * L
x_pos = ind - width / 2 + (i + 2) * width / len(data)
width_bar = width / len(data)
ax2.bar(x_pos, height, width_bar, bottom=0, label=policy, color=color)
for j in np.argwhere(height > ylim2):
ax2.text(x_pos[j], ylim2 * 1.01, int(height[j]), ha='center', va='bottom', rotation='vertical',
fontsize=18, color=color)
ax1.set_ylim(0, ylim)
ax1.set_xlabel('Round ($t$)', fontsize=30)
ax1.set_ylabel('Average regret $R_t$', fontsize=30)
ax1.xaxis.set_label_coords(0.5, -0.08)
ax2.set_xticks(ind + width / len(data))
xticks = [format_float_scientific(mu, exp_digits=1, precision=0) for mu in L]
xticks = [float(xtick) if j % 2 == 0 else '' for j, xtick in enumerate(xticks)]
ax2.set_ylim(0, ylim2)
ax2.set_xticklabels(xticks)
ax2.set_ylabel('Average regret per arm $R_T^i$ at $T = 25000$', fontsize=30)
ax2.set_xlabel("Arm's $\Delta_i$", fontsize=30)
ax2.xaxis.set_label_coords(0.5, -0.08)
ax2.yaxis.set_label_coords(-0.08, 0.5)
handles, labels = ax2.get_legend_handles_labels()
pos = ax3.get_position()
fig.legend(handles, labels, loc=[0.9 * pos.x0 + 0.1 * pos.x1, (pos.y1 - pos.y0) / 2])
ax3.grid(False)
ax3.axis('off')
# Hide axes ticks
ax3.set_xticks([])
ax3.set_yticks([])
# -------------- SAVE --------------
fig.set_size_inches(30, 10)
fig.tight_layout()
fig.savefig(name)
if __name__ == "__main__":
policies = [
[FEWA, {'alpha': .03, 'delta': 1}],
[FEWA, {'alpha': .06, 'delta': 1}],
[FEWA, {'alpha': .1, 'delta': 1}],
[EFF_FEWA, {'alpha': .06, 'delta': 1, 'm': 2}],
[wSWA, {'alpha': 0.002}],
[wSWA, {'alpha': 0.02}],
[wSWA, {'alpha': 0.2}]
]
data = {}
for policy in policies:
policy_name = str(policy[0](nbArms=2, **policy[1]))
policy_name_nospace = policy_name.replace(' ', '_')
policy_data_regret = [
np.load(os.path.join('./data', file))
for file in os.listdir('./data') if
file.startswith("REGRET_" + policy_name_nospace)
]
policy_data_pull = [
np.load(os.path.join('./data', file))
for file in os.listdir('./data') if
file.startswith("DIFFPULL_" + policy_name_nospace)
]
if not policy_data_regret:
continue
regret_data_array = np.concatenate(policy_data_regret, axis=0)
pull_data_array = np.concatenate(policy_data_pull, axis=0)
data[policy_name] = {
"mean": regret_data_array.mean(axis=0),
"uppq": np.quantile(regret_data_array, 0.9, axis=0),
"lowq": np.quantile(regret_data_array, 0.1, axis=0),
"pull": pull_data_array.mean(axis=0)
}
fig2A(data)
``` |
{
"source": "98llm/tir-script-samples",
"score": 2
} |
#### File: Modules/SIGAACD/ACDA035TESTCASE.py
```python
from tir import Webapp
import unittest
import time
class ACDA035(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAEST','11/07/2019','T1','D MG 01')
inst.oHelper.Program('ACDA035')
inst.oHelper.AddParameter("MV_CBPE012", "", ".T.", ".T.", ".T.")
inst.oHelper.SetParameters()
#CT001 - Geração de uma ordem de separação por ordem de produção
#@author: <NAME>
#@date: 18/09/2019
def test_ACDA035_CT001(self):
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('Codigo Inv.', '000000005')
self.oHelper.SetValue('Usuario', '000010')
self.oHelper.SetValue('Quantidade', '1', grid=True)
self.oHelper.SetValue('Endereco', 'ENDSE01', grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Não')
self.oHelper.SetButton('Cancelar')
#Definição do operação
self.oHelper.AssertTrue()
def test_ACDA035_CT002(self):
self.oHelper.SearchBrowse("D MG 01 000000003")
self.oHelper.SetButton("Visão")
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
def test_ACDA035_CT003(self):
self.oHelper.SetButton("Outras Ações", "Legenda")
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_ACDA035_CT004(self):
self.oHelper.SearchBrowse("D MG 01 000000030")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue('Quantidade', '3', grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Não')
self.oHelper.AssertTrue()
def test_ACDA035_CT005(self):
self.oHelper.SearchBrowse("D MG 01 000000005")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Sim')
self.oHelper.AssertTrue()
def test_ACDA035_CT006(self):
self.oHelper.AddParameter("MV_WMSNEW ", "", ".F.", ".T.", ".T.")
self.oHelper.SetParameters()
self.oHelper.SearchBrowse("D MG 01 000000029")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue('Qtd.Original', '3', grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Sim')
self.oHelper.AssertTrue()
def test_ACDA035_CT007(self):
self.oHelper.SearchBrowse("D MG 01 000000032")
self.oHelper.SetButton("Alterar")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Deseja finalizar a contagem?")
self.oHelper.SetButton("Não")
self.oHelper.WaitHide("Deseja finalizar a contagem?")
time.sleep(3)
self.oHelper.SetButton("Visão")
self.oHelper.CheckResult("Produto","ACDACDA03500000000000000000001",grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAACD/ACDA080TESTCASE.py
```python
from tir import Webapp
from datetime import date
import unittest
import time
class ACDA080(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
data_Sistema = date.today()
data = data_Sistema.strftime('%d/%m/%Y')
inst.oHelper.Setup('SIGAPCP',data,'T1','D MG 01')
inst.oHelper.Program('ACDA080')
#CT001 - Inclusão de Monitoramento de Produção de Transação tipo Início
#@author: <NAME>
#@date: 25/09/2019
def test_ACDA080_CT001(self):
self.oHelper.WaitShow("Monitoramento da Producao")
self.oHelper.SetKey("F12")
self.oHelper.SetValue("Tipo de Producao ?", "PCP MOD2")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Monitoramento da Producao - INCLUIR")
self.oHelper.SetKey("F3")
self.oHelper.SearchBrowse("pcpA1T")
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("Operacao", "01")
self.oHelper.SetValue("Transacao", "01")
self.oHelper.SetValue("Parc./Total", "T - Total")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#CT002 - Inclusão de Monitoramento de Produção de Transação tipo Pausa sem apontamento
#@author: <NAME>
#@date: 25/09/2019
def test_ACDA080_CT002(self):
self.oHelper.WaitShow("Monitoramento da Producao")
self.oHelper.SetKey("F12")
self.oHelper.SetValue("Tipo de Producao ?", "PCP MOD2")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Monitoramento da Producao - INCLUIR")
self.oHelper.SetKey("F3")
self.oHelper.SearchBrowse("pcpA1U")
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("Operacao", "01")
self.oHelper.SetValue("Transacao", "02")
self.oHelper.SetValue("Parc./Total", "T - Total")
self.oHelper.SetValue("Recurso", "EST001")
self.oHelper.SetValue("Dt. Apont.", "26/09/2019")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#CT003 - Inclusão de Monitoramento de Produção de Transação tipo Produção
#@author: <NAME>
#@date: 25/09/2019
def test_ACDA080_CT003(self):
self.oHelper.WaitShow("Monitoramento da Producao")
self.oHelper.SetKey("F12")
self.oHelper.SetValue("Tipo de Producao ?", "PCP MOD2")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Monitoramento da Producao - INCLUIR")
self.oHelper.SetKey("F3")
self.oHelper.SearchBrowse("pcpA1V")
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("Operacao", "01")
self.oHelper.SetValue("Transacao", "03")
self.oHelper.SetValue("Parc./Total", "T - Total")
self.oHelper.SetValue("Recurso", "EST001")
self.oHelper.SetValue("Dt. Apont.", "26/09/2019")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#CT004 - Alteração de Monitoramento de Produção de Transação tipo Pausa sem apontamento
#@author: <NAME>
#@date: 25/09/2019
def test_ACDA080_CT004(self):
self.oHelper.WaitShow("Monitoramento da Producao")
self.oHelper.SearchBrowse("D MG 01 pcpA1W01001 02 ")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue("Parc./Total", "P - Parcial")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#CT005 - Exclusão de Monitoramento de Produção - Início
#@author: <NAME>
#@date: 25/09/2019
def test_ACDA080_CT005(self):
self.oHelper.WaitShow("Monitoramento da Producao")
self.oHelper.SearchBrowse("D MG 01 pcpA1X01001 01")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
#CT006 - Exclusão de Monitoramento de Produção - Pausa sem apontamento
#@author: <NAME>
#@date: 25/09/2019
def test_ACDA080_CT006(self):
self.oHelper.WaitShow("Monitoramento da Producao")
self.oHelper.SearchBrowse("D MG 01 pcpA1Y01001 02")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
#CT007 - Exclusão de Monitoramento de Produção - Produção
#@author: <NAME>
#@date: 25/09/2019
def test_ACDA080_CT007(self):
self.oHelper.WaitShow("Monitoramento da Producao")
self.oHelper.SearchBrowse("D MG 01 pcpA1Z01001 03")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
def test_ACDA080_CT008(self):
self.oHelper.WaitShow("Monitoramento da Producao")
self.oHelper.SetButton("Outras Ações", "Relatorio")
self.oHelper.SetButton("Param.")
self.oHelper.SetValue("Da Data ?", "24/09/2019")
self.oHelper.SetValue("Ate Data ?", "25/09/2019")
self.oHelper.SetValue("Ate OP ?", "zzzzzzzzzzzzzz")
self.oHelper.SetValue("Ate Transacao ?", "zz")
self.oHelper.SetValue("Ate Operador ?", "zzzzzz")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Sair")
self.oHelper.AssertTrue()
def test_ACDA080_CT009(self):
self.oHelper.WaitShow("Monitoramento da Producao")
self.oHelper.SetButton("Outras Ações", "Legenda")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_ACDA080_CT010(self):
self.oHelper.WaitShow("Monitoramento da Producao")
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
#CT011 - Inclusão de Monitoramento de Produção Parcialmente Apontada
#@author: <NAME>
#@date: 01/10/2019
def test_ACDA080_CT011(self):
self.oHelper.WaitShow("Monitoramento da Producao")
time.sleep(3)
self.oHelper.SetKey("F12")
self.oHelper.SetValue("Tipo de Producao ?", "PCP MOD2")
self.oHelper.SetButton("Ok")
time.sleep(1)
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Monitoramento da Producao - INCLUIR")
self.oHelper.SetKey("F3")
time.sleep(1)
self.oHelper.SearchBrowse("PCPA20")
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("Operacao", "01")
self.oHelper.SetValue("Transacao", "01")
self.oHelper.SetValue("Parc./Total", "T - Total")
self.oHelper.SetValue("Dt. Apont.", "01/10/2019")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#CT012 - Apontamento parcial com apontamentos parciais em operações anteriores
#@author: <NAME>
#@date: 01/10/2019
def test_ACDA080_CT012(self):
self.oHelper.WaitShow("Monitoramento da Producao")
time.sleep(3)
self.oHelper.SetKey("F12")
self.oHelper.SetValue("Tipo de Producao ?", "PCP MOD2")
self.oHelper.SetButton("Ok")
time.sleep(1)
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Monitoramento da Producao - INCLUIR")
self.oHelper.SetValue("CBH_OP", "PCPA2101001")
self.oHelper.SetValue("Operacao", "01")
self.oHelper.SetValue("Transacao", "01")
self.oHelper.SetValue("CBH_PARTOT", "T - Total")
self.oHelper.SetButton("Salvar")
time.sleep(3)
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#CT013 - Apontamento parcial com apontamentos parciais em operações anteriores
#@author: <NAME>
#@date: 01/10/2019
def test_ACDA080_CT013(self):
self.oHelper.WaitShow("Monitoramento da Producao")
time.sleep(3)
self.oHelper.SetKey("F12")
self.oHelper.SetValue("Tipo de Producao ?", "PCP MOD2")
self.oHelper.SetButton("Ok")
time.sleep(1)
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Monitoramento da Producao - INCLUIR")
self.oHelper.SetValue("CBH_OP", "PCPA2101001")
self.oHelper.SetValue("Operacao", "01")
self.oHelper.SetValue("Transacao", "03")
self.oHelper.SetValue("Recurso", "EST001")
self.oHelper.SetValue("Quantidade", "30,00")
self.oHelper.CheckResult("CBH_PARTOT", "P - Parci")
self.oHelper.SetButton("Salvar")
time.sleep(3)
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAAGR/OGA250TestCase.py
```python
from tir import Webapp
import unittest
class OGA250(unittest.TestCase):
@classmethod
def setUpClass(inst):
from datetime import datetime
DateSystem = datetime.today().strftime('%d/%m/%Y')
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAAGR',DateSystem,'T1','D MG 01 ')
def test_OGA250_CT001(self):
#Cenário 001: Entrada por produção - nova comercialização
self.oHelper.Program('OGA250')
self.oHelper.AddParameter("MV_AGRA001", "", ".T.", ".T.", ".T.")
self.oHelper.AddParameter("MV_AGRO002", "", ".T.", ".T.", ".T.")
self.oHelper.AddParameter("MV_SIGAAGR","",".T.",".T.",".T.")
self.oHelper.AddParameter("MV_ARM251A", "", "001", "001", "001")
self.oHelper.AddParameter("MV_AGRTMPR", "", "010", "010", "010")
self.oHelper.AddParameter("MV_AGRTMPS", "", "001", "001", "001")
self.oHelper.AddParameter("MV_AGRTMRQ", "", "501", "501", "501")
self.oHelper.SetParameters()
self.oHelper.WaitShow("Romaneios com Pesagem")
self.oHelper.SetKey("F12")
self.oHelper.SetValue("MV_PAR01", "000001", name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("Tipo", "1")
self.oHelper.SetValue("Cod.Entidade", "000001")
self.oHelper.SetValue("Loj.Entidade", "01")
self.oHelper.ClickFolder("Analise")
self.oHelper.SetValue("Cod. Safra", "1920")
self.oHelper.SetValue("Cod. Produto", "AGR-FARDAO-ALGODAO")
self.oHelper.SetValue("Local", "01")
self.oHelper.SetValue("Fazenda", "01")
self.oHelper.SetValue("Un. Benef.", "01")
self.oHelper.SetButton("Outras Ações", "Vincular Fardões")
self.oHelper.ClickBox("Código","000033", grid_number=1)
self.oHelper.SetButton(">>")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações", "Pesagem")
self.oHelper.SetValue("nPeso", "1000", name_attr=True)
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Outras Ações", "Pesagem")
self.oHelper.SetValue("nPeso", "101000", name_attr=True)
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Outras Ações", "Atualizar")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Outras Ações", "Confirmar")
self.oHelper.WaitHide("Aguarde")
self.oHelper.SetButton("Visualizar")
self.oHelper.ClickFolder("Pesagem")
self.oHelper.CheckResult("NJJ_PSSUBT", "100.000,00")
self.oHelper.ClickFolder("Controle")
self.oHelper.CheckResult("NJJ_STATUS", "3 - Confirmado")
self.oHelper.AssertTrue()
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("x")
def test_OGA250_CT002(self):
#Cenário 002: Exclusão documento de saída e reabertura do romaneio (atualizado)
self.oHelper.SetLateralMenu("Atualizações > Gestão Agrícola > Faturamento > Exclus. Doc. Saída")
###self.oHelper.Program("MATA521A")
self.oHelper.AddParameter("MV_SIGAAGR","",".T.",".T.",".T.")
self.oHelper.SetParameters()
self.oHelper.SetValue("Modelo de Interface ?" ,"Marcacao")
self.oHelper.SetValue("Selecionar itens ?" ,"Nao")
self.oHelper.SetValue("Dt.Emissao de ?" ,"01/01/2000")
self.oHelper.SetValue("Dt.Emissao ate ?" ,"31/12/2045")
self.oHelper.SetValue("Serie de ?" ,"001")
self.oHelper.SetValue("Serie ate ?" ,"001")
self.oHelper.SetValue("Documento de ?" ,"T2501K")
self.oHelper.SetValue("Documento ate ?" ,"T2501K")
self.oHelper.SetButton("OK")
self.oHelper.ClickBox("Numero","T2501K")
self.oHelper.SetButton("Outras Ações","Excluir")
self.oHelper.SetButton("Sim")
self.oHelper.WaitProcessing("Estorno dos documentos de saida")
self.oHelper.SetButton("x")
self.oHelper.Program('OGA250')
self.oHelper.SearchBrowse("D MG 01 0000000135", "Filial+cod.romaneio")
self.oHelper.SetButton("Visualizar")
self.oHelper.ClickFolder("Controle")
self.oHelper.CheckResult("NJJ_STATUS", "2 - Atualizado")
self.oHelper.AssertTrue()
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("x")
def test_OGA250_CT003(self):
#Cenário 003: Exclusão documento de saída e reabertura do romaneio (atualizado)
self.oHelper.SetLateralMenu("Atualizações > Gestão Agrícola > Faturamento > Exclus. Doc. Saída")
#self.oHelper.Program("MATA521A")
self.oHelper.AddParameter("MV_SIGAAGR","",".T.",".T.",".T.")
self.oHelper.SetParameters()
self.oHelper.SetValue("Modelo de Interface ?" ,"Marcacao")
self.oHelper.SetValue("Selecionar itens ?" ,"Nao")
self.oHelper.SetValue("Dt.Emissao de ?" ,"01/01/2000")
self.oHelper.SetValue("Dt.Emissao ate ?" ,"31/12/2045")
self.oHelper.SetValue("Serie de ?" ,"001")
self.oHelper.SetValue("Serie ate ?" ,"001")
self.oHelper.SetValue("Documento de ?" ,"T2501L")
self.oHelper.SetValue("Documento ate ?" ,"T2501L")
self.oHelper.SetButton("OK")
self.oHelper.ClickBox("Numero","T2501L")
self.oHelper.SetButton("Outras Ações","Excluir")
self.oHelper.SetButton("Sim")
self.oHelper.WaitProcessing("Estorno dos documentos de saida")
self.oHelper.SetButton("x")
self.oHelper.Program('OGA250')
self.oHelper.SearchBrowse("D MG 01 0000000136", "Filial+cod.romaneio")
self.oHelper.SetButton("Visualizar")
self.oHelper.ClickFolder("Controle")
self.oHelper.CheckResult("NJJ_STATUS", "2 - Atualizado")
self.oHelper.AssertTrue()
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("x")
def test_OGA250_CT004(self): #cenario exclusão doc entrada
#Cenário 004: Exclusão documento de entrada e reabertura do romaneio (atualizado)
self.oHelper.Program('MATA103')
self.oHelper.AddParameter("MV_SIGAAGR","",".T.",".T.",".T.")
self.oHelper.SetParameters()
self.oHelper.SearchBrowse("D MG 01 T25023", "Filial+numero")
self.oHelper.SetButton('Outras Ações', "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("x")
self.oHelper.Program('OGA250')
self.oHelper.SearchBrowse("D MG 01 0000000147", "Filial+cod.romaneio")
self.oHelper.SetButton("Visualizar")
self.oHelper.ClickFolder("Controle")
self.oHelper.CheckResult("NJJ_STATUS", "2 - Atualizado")
self.oHelper.AssertTrue()
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("x")
def test_OGA250_CT005(self):
#Cenário 005: Expedição Algodão sem IE - Novo Negócio
if self.oHelper.GetRelease() >= "12.1.028":
self.oHelper.Program('OGA250')
self.oHelper.AddParameter("MV_AGRA001", "", ".T.", ".T.", ".T.")
self.oHelper.AddParameter("MV_AGRO002", "", ".T.", ".T.", ".T.")
self.oHelper.AddParameter("MV_SIGAAGR", "", ".T.", ".T.", ".T.")
self.oHelper.AddParameter("MV_OGDECPS", "", "2", "2", "2")
self.oHelper.AddParameter("MV_AGRTMPP", "", "501", "501", "501")
self.oHelper.SetParameters()
self.oHelper.WaitShow("Romaneios com Pesagem")
self.oHelper.SearchBrowse("D MG 01 0000000154", "Filial+cod.romaneio")
self.oHelper.SetButton("Alterar")
self.oHelper.ClickFolder("Comercialização")
self.oHelper.SetValue("Intervalo", "001", grid=True)
self.oHelper.SetValue("Id Regra", "002", grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Outras Ações","Vincular Fardos")
self.oHelper.ClickBox("Filial",select_all=True, grid_number=1)
self.oHelper.SetButton(">>")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Atualizar")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Outras Ações","Confirmar")
self.oHelper.WaitShow("Serie / Notas")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Visualizar")
self.oHelper.ClickFolder("Controle")
self.oHelper.CheckResult("NJJ_STATUS", "3 - Confirmado")
self.oHelper.AssertTrue()
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("x")
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAAGR/OGA280TESTCASE.py
```python
from tir import Webapp
import unittest
class OGA280(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAAGR','04/11/2019','T1','D MG 01 ','67')
inst.oHelper.Program('OGA280')
def test_OGA280_CT001(self):
#Cenário 001: Vínculo contrato de compra x contrato de venda
self.oHelper.AddParameter("MV_AGRA001","",".F.",".F.",".F.")#Novo UBA
self.oHelper.AddParameter("MV_AGRO002","",".F.",".F.",".F.")#Nova comercialização
self.oHelper.SetParameters()
self.oHelper.SearchBrowse("D MG 01 000071", key="Filial+contrato")
self.oHelper.SetButton('Outras Ações',"Mais Ações..., Vínculo Contratos")
self.oHelper.SetButton('Alocar')
self.oHelper.SetButton('OK')
self.oHelper.SetValue("Alocar", "40.000,00", grid=True, grid_number=1, name_attr=True, row=3)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Alocar')
self.oHelper.SetButton('OK')
self.oHelper.SetValue("Alocar", "60.000,00", grid=True, grid_number=1, name_attr=True, row=3)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.CheckResult("Qtd. Vinculada", "100.000,00", grid=True, line=1, grid_number=1)
self.oHelper.LoadGrid()
self.oHelper.CheckResult("Qtd. Vinculada", "100.000,00", grid=True, line=1, grid_number=2)
self.oHelper.LoadGrid()
#teste delete do vínculo
self.oHelper.ClickGridCell("Contrato", row=1, grid_number=2)
self.oHelper.ClickBox("Contrato", select_all=True, grid_number=2)
self.oHelper.SetButton('Deletar Vínculo')
self.oHelper.CheckResult("Qtd. Vinculada", "0,00", grid=True, line=1, grid_number=1)
self.oHelper.LoadGrid()
self.oHelper.AssertTrue()
self.oHelper.SetButton('Sair')
self.oHelper.RestoreParameters()
def test_OGA280_CT002(self):
#Cenário 002: Nota fiscal global futura
self.oHelper.AddParameter("MV_AGRA001","",".T.",".T.",".T.")#Novo UBA
self.oHelper.AddParameter("MV_AGRO002","",".T.",".T.",".T.")#Nova comercialização
self.oHelper.SetParameters()
self.oHelper.SearchBrowse("D MG 01 000129", key="Filial+contrato")
self.oHelper.SetButton('Alterar')
self.oHelper.ClickFolder("Cadência")
self.oHelper.SetValue("TES", "010", grid=True, grid_number=2)
self.oHelper.SetValue("TES Rem", "009", grid=True, grid_number=2)
self.oHelper.SetValue("Op.Futura", "1", grid=True, grid_number=2)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Outras Ações', 'Confirmar')
self.oHelper.SetValue("Descrição/Observação","Ok")
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Outras Ações','Mais ações...,Emitir NF Operação Futura')
self.oHelper.SetButton('Não')
self.oHelper.ClickBox("Id Regra", "001", grid_number = 1)
self.oHelper.SetValue("Numero NF", "1010", grid=True, grid_number=1)
self.oHelper.SetValue("Serie NF", "01", grid=True, grid_number=1)
self.oHelper.SetValue("Emissao NF", "20/08/2020", grid=True, grid_number=1)
self.oHelper.SetValue("Especie NF", "NF", grid=True, grid_number=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Romaneio(s) gerado(s) com sucesso.")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton('Outras Ações', 'Mais Ações...,Romaneios')
self.oHelper.CheckResult("TOTAIS", "(E) VENDA ENTREGA FUTURA", grid=True, grid_number=2, line=1)
self.oHelper.CheckResult("Qtd. Fisica", "100.000,00", grid=True, grid_number=2, line=1)
self.oHelper.CheckResult("Qtd. Fiscal", "100.000,00", grid=True, grid_number=2, line=1)
self.oHelper.CheckResult("Valor Total", "180.556,70", grid=True, grid_number=2, line=1)
self.oHelper.LoadGrid()
self.oHelper.AssertTrue()
self.oHelper.SetButton('Close')
self.oHelper.RestoreParameters()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAAGR/OGA290TESTCASE.py
```python
from tir import Webapp
import unittest
class OGA290(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAAGR','20/09/2019','T1','D MG 01 ','67')
inst.oHelper.Program('OGA290')
inst.oHelper.AddParameter("MV_INTGFE","",".T.",".T.",".T.")
inst.oHelper.AddParameter("MV_AGRA001","",".T.",".T.",".T.")#Novo UBA
inst.oHelper.AddParameter("MV_AGRO002","",".T.",".T.",".T.")#Nova comercialização
inst.oHelper.SetParameters()
def test_OGA290_CT001(self):
self.oHelper.SearchBrowse("D MG 01 000069", key="Filial+contrato")
self.oHelper.SetButton('Outras Ações', 'Gerar Previsão Financeira')
self.oHelper.WaitProcessing("Processando...")
self.oHelper.SetButton('Visualizar')
self.oHelper.WaitShow("Contratos - VISUALIZAR")
self.oHelper.ClickFolder("Financeiro")
self.oHelper.CheckResult("NN7_VALOR", "139.624,70", grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Outras Ações', 'Demonstrativo de Preços')
self.oHelper.SetButton('Close')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_OGA290_CT002(self):
if self.oHelper.GetRelease() > '12.1.027':
self.oHelper.SearchBrowse("D MG 01 000329", key="Filial+contrato")
self.oHelper.SetButton("Alterar")
self.oHelper.ClickFolder("Previsão de Entrega")
self.oHelper.SetValue("TES Rem", "517", grid=True, grid_number=2, row=1)
self.oHelper.SetValue("Op.Futura", "1", grid=True, grid_number=2, row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Outras Ações', 'Confirmar')
self.oHelper.SetValue("Descrição/Observação","Ok")
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Outras Ações','Mais ações...,Emitir NF Operação Futura')
self.oHelper.ClickBox("Id Regra", "001", grid_number = 1)
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Romaneio(s) gerado(s) com sucesso.")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton('Outras Ações', 'Mais Ações...,Romaneios')
self.oHelper.CheckResult("TOTAIS", "(S) VENDA ENTREGA FUTURA", grid=True, grid_number=2, line=1)
self.oHelper.CheckResult("Qtd. Fisica", "100.000,00", grid=True, grid_number=2, line=1)
self.oHelper.CheckResult("Qtd. Fiscal", "100.000,00", grid=True, grid_number=2, line=1)
self.oHelper.CheckResult("Valor Total", "177.580,50", grid=True, grid_number=2, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Close')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAAGR/OGA450TestCase.py
```python
from tir import Webapp
import unittest
class OGA450(unittest.TestCase):
@classmethod
def setUpClass(inst):
from datetime import datetime
DateSystem = datetime.today().strftime('%d/%m/%Y')
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAADV',DateSystem,'T1','D MG 01 ','67')
inst.oHelper.Program('OGA450')
#Cenário 001: Ajustar pendência de fixação, gerando complemento de preço - modelo clássico
def test_OGA450_CT001(self):
self.oHelper.SetValue("Entidade", "000003")
self.oHelper.SetValue("cLojEnt", "01",name_attr=True)
self.oHelper.SetButton("Atualizar")
self.oHelper.SearchBrowse("D MG 01 2011920 AGR-SOJA GRANEL")
self.oHelper.ClickGridCell('Contrato',2,grid_number = 2)
self.oHelper.SetButton("Outras Ações","Financeiro",position=2, check_error=True)
self.oHelper.SetButton("Pendências")
self.oHelper.ClickBox("Romaneio","0000000079",grid_number = 2)
self.oHelper.SetButton("Ajustar Pendencia")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("x")
self.oHelper.ClickGridCell('Romaneio',1,grid_number = 2)
self.oHelper.CheckResult("Vr.Complem.", user_value = "0,00", grid=True,line=2 ,grid_number = 2, name_attr=False)
self.oHelper.LoadGrid()
self.oHelper.SetButton("x")
self.oHelper.AssertTrue()
def test_OGA450_CT002(self):
##Cenário 002: Automatizar o processo de alterar/incluir fixacao
self.oHelper.SetValue("Entidade", "000003")
self.oHelper.SetValue("cLojEnt", "01",name_attr=True)
self.oHelper.SetButton("Atualizar")
self.oHelper.SearchBrowse("D MG 01 2011920 <NAME>")
self.oHelper.ScrollGrid(column="Contrato", match_value="000125", grid_number=2)
self.oHelper.SetButton("Outras Ações","Financeiro",position=2, check_error=True)
self.oHelper.ClickGridCell("Filial", row=2, grid_number=1)
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue("Dt.Ini.Ent.", "01/08/2020" )
self.oHelper.SetValue("Dt.Fin.Ent.", "31/08/2020" )
self.oHelper.SetButton("Confirmar")
self.oHelper.SetValue("Descrição/Observação", "Teste Automatizado - TIR")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("NN8_VALTOT", user_value = "100.000,00")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_OGA450_CT003(self):
#Cenário 003: Ajustar pendência de fixação, gerando complemento de preço - modelo novo
self.oHelper.AddParameter("MV_SIGAAGR","",".T.",".T.",".T.")
self.oHelper.AddParameter("MV_AGRA001","",".T.",".T.",".T.")#Novo UBA
self.oHelper.AddParameter("MV_AGRO002","",".T.",".T.",".T.")#Nova comercialização
self.oHelper.SetParameters()
self.oHelper.SetValue("Entidade", "000001")
self.oHelper.SetValue("cLojEnt", "01",name_attr=True)
self.oHelper.SetButton("Atualizar")
self.oHelper.SearchBrowse("D MG 01 2011920 <NAME>")
self.oHelper.ScrollGrid(column="Contrato", match_value="000128", grid_number=2)
self.oHelper.SetButton("Outras Ações","Pendências",position=2, check_error=True)
self.oHelper.ClickBox("Filial", "D MG 01", grid_number=1)
self.oHelper.SetButton("Solucionar Pendências")
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Gerar Complemento")
self.oHelper.WaitProcessing("Gerando Nf de Complemento.")
self.oHelper.CheckResult("Valor", user_value = "49.713,72", grid_number=2, grid=True)
self.oHelper.LoadGrid()
self.oHelper.AssertTrue()
def test_OGA450_CT004(self):
#Cenário 004: Transferência simples de saldo entre contratos
self.oHelper.AddParameter("MV_SIGAAGR","",".T.",".T.",".T.")
self.oHelper.AddParameter("MV_AGRA001","",".F.",".F.",".F.")#Novo UBA
self.oHelper.AddParameter("MV_AGRO002","",".F.",".F.",".F.")#Nova comercialização
self.oHelper.SetParameters()
self.oHelper.SetValue("Entidade", "000003")
self.oHelper.SetValue("cLojEnt", "01",name_attr=True)
self.oHelper.SetButton("Atualizar")
self.oHelper.SearchBrowse("D MG 01 1011920 <NAME>")
self.oHelper.ScrollGrid(column="Contrato", match_value="000015", grid_number=2)
self.oHelper.SetButton("Outras Ações","Transferência",position=2, check_error=True)
self.oHelper.SetValue("cTesDev", "501", name_attr=True)
self.oHelper.SetValue("cLocalO", "01", name_attr=True)
self.oHelper.SetValue("cDCodEnt", "000002", name_attr=True)
self.oHelper.SetValue("cDLojEnt", "01", name_attr=True)
self.oHelper.SetValue("cTipoDest", "Compra", name_attr=True)
self.oHelper.SetValue("cTESDest", "001",name_attr=True)
self.oHelper.SetValue("nQtd","200",name_attr=True, check_value=False)
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Sim")
self.oHelper.ScrollGrid(column="Contrato", match_value="000050", grid_number=1)
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Romaneios")
self.oHelper.CheckResult("Qtd. Fiscal", user_value = "200,00", grid_number=2, grid=True, line=2)
self.oHelper.LoadGrid()
self.oHelper.AssertTrue()
def test_OGA450_CT005(self):
#Cenário 004: Transferência múltipla de saldo entre contratos
self.oHelper.AddParameter("MV_SIGAAGR","",".T.",".T.",".T.")
self.oHelper.AddParameter("MV_AGRA001","",".F.",".F.",".F.")#Novo UBA
self.oHelper.AddParameter("MV_AGRO002","",".F.",".F.",".F.")#Nova comercialização
self.oHelper.SetParameters()
self.oHelper.SetValue("Entidade", "000001")
self.oHelper.SetValue("cLojEnt", "01",name_attr=True)
self.oHelper.SetButton("Atualizar")
self.oHelper.SetButton("Trf. Mul. Origens")
self.oHelper.SetButton("Outras Ações", "Filtro")
self.oHelper.SetValue("MV_PAR01", "000001", name_attr=True)
self.oHelper.SetValue("MV_PAR02", "01", name_attr=True)
self.oHelper.SetValue("MV_PAR03", "000002", name_attr=True)
self.oHelper.SetValue("MV_PAR04", "01", name_attr=True)
self.oHelper.SetValue("MV_PAR05", "000024", name_attr=True, check_value=False)
self.oHelper.SetValue("MV_PAR06", "000029", name_attr=True, check_value=False)
self.oHelper.SetButton("OK")
self.oHelper.ClickBox("Contrato", "000024", grid_number=1)
self.oHelper.ClickBox("Contrato", "000029", grid_number=1)
self.oHelper.SetButton("Transferir")
self.oHelper.SetValue("cTipoDest", "Compra", name_attr=True)
self.oHelper.SetValue("cTESDest", "004",name_attr=True)
self.oHelper.SetValue("nQtd","20200",name_attr=True, check_value=False)
self.oHelper.SetValue("cLocalD", "01", name_attr=True)
self.oHelper.SetValue("cNFPSer","01",name_attr=True)
self.oHelper.SetValue("cNFPNum","151520",name_attr=True)
self.oHelper.SetValue("TES","504",grid=True, row=1)
self.oHelper.SetValue("Local","01",grid=True, row=1)
self.oHelper.SetValue("Qt.Transf","200",grid=True, row=1, check_value=False)
self.oHelper.SetValue("TES","504",grid=True, row=2)
self.oHelper.SetValue("Local","01",grid=True, row=2)
self.oHelper.SetValue("Qt.Transf","20000",grid=True, row=2, check_value=False)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Sim")
self.oHelper.ScrollGrid(column="Contrato", match_value="000074")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("x")
self.oHelper.SearchBrowse("D MG 01 1011920 AGR-SOJA GRANEL")
self.oHelper.ScrollGrid(column="Contrato", match_value="000074", grid_number=2)
self.oHelper.SetButton("Romaneios")
self.oHelper.CheckResult("Qtd. Fiscal", user_value = "20.200,00", grid_number=2, grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAAGR/OGC040TestCase.py
```python
from tir import Webapp
import unittest
class OGC040(unittest.TestCase):
@classmethod
def setUpClass(inst):
from datetime import datetime
DateSystem = datetime.today().strftime('%d/%m/%Y')
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAADV',DateSystem,'T1','D MG 01 ','67')
inst.oHelper.Program('OGA290')
inst.oHelper.AddParameter("MV_AGRA001","",".T.",".T.",".T.")#Novo UBA
inst.oHelper.AddParameter("MV_AGRO002","",".T.",".T.",".T.")#Nova comercialização
inst.oHelper.SetParameters()
def test_OGC040_CT001(self):
self.oHelper.SearchBrowse("D MG 01 "+"000043")
self.oHelper.SetButton("Outras Ações","Blocos e Fardos Vinculados")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse("D MG 01 "+"000043")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("NJR_CODCTR", user_value = "000043")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAATF/ATFA006TESTCASE.py
```python
from tir import Webapp
import unittest
class ATFA006(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAATF', '01042019', 'T1', 'D MG 01 ')
inst.oHelper.Program('ATFA006')
@classmethod
def test_ATFA006_CT001(self): #Inclusão
self.oHelper.SetButton("Incluir")
self.oHelper.SetValue('FNT_CODIND', '06')
self.oHelper.SetValue('FNT_DATA', '01/04/2019')
self.oHelper.SetValue('FNT_TAXA', "5,00000000") # 0,00000000
self.oHelper.CheckResult('FNT_CODIND', '06')
self.oHelper.CheckResult('FNT_DATA', '01/04/2019')
self.oHelper.CheckResult('FNT_TAXA', "5,00000000") # 0,00000000
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def test_ATFA006_CT002(self): #Revisar
self.oHelper.SearchBrowse('07000120180901 ') #posiciona no registro
self.oHelper.SetButton("Outras Ações", "Revisar")
self.oHelper.SetValue('FNT_TAXA', "10,00000000") # 6,00000000
self.oHelper.CheckResult('FNT_TAXA', "10,00000000") # 6,00000000
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def test_ATFA006_CT003(self): #Bloquear
self.oHelper.SearchBrowse('08000120170801 ') #posiciona no registro
self.oHelper.SetButton("Bloq. / Desbloq.")
self.oHelper.SetValue('FNT_MSBLQL', "1 - Sim") # 0,00000000
self.oHelper.CheckResult('FNT_MSBLQL', "1 - Sim") # 0,00000000
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def test_ATFA006_CT004(self): #Exclusão
self.oHelper.SearchBrowse('09000120170501 ') #posiciona no registro
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def test_ATFA006_CT005(self): #Visualizacao
self.oHelper.SearchBrowse('10000120170401 ') #posiciona no registro
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult('FNT_CODIND', '10')
self.oHelper.CheckResult('FNT_DATA', '01/04/2017')
self.oHelper.CheckResult('FNT_TAXA', "15,00000000") # 0,00000000
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def test_ATFA006_CT006(self): #Desbloqueio
self.oHelper.SearchBrowse('11000120171201 ') #posiciona no registro
self.oHelper.SetButton("Bloq. / Desbloq.")
self.oHelper.SetValue('FNT_MSBLQL', "2 - Nao")
self.oHelper.CheckResult('FNT_MSBLQL', "2 - Nao")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def test_ATFA006_CT007(self): #Inclusão com curva
self.oHelper.SetButton("Incluir")
self.oHelper.SetValue('FNT_CODIND', '12')
self.oHelper.SetValue('FNT_DATA', '01/06/2019')
self.oHelper.SetValue('FNT_CURVA', "10,00") # 0,00000000
self.oHelper.CheckResult('FNT_CODIND', '12')
self.oHelper.CheckResult('FNT_DATA', '01/06/2019')
self.oHelper.CheckResult('FNT_CURVA', "10,00") # 0,00000000
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def test_ATFA006_CT008(self): #Revisão com curva
self.oHelper.SearchBrowse('13000120170901 ') #posiciona no registro
self.oHelper.SetButton("Outras Ações", "Revisar")
self.oHelper.SetValue('FNT_CURVA', "5,00") # 6,00000000
self.oHelper.CheckResult('FNT_CURVA', "5,00") # 6,00000000
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def test_ATFA006_CT009(self): #Exportar
self.oHelper.SearchBrowse('10000120170401 ')
self.oHelper.SetButton("Outras Ações", "Exportar")
self.oHelper.SetValue('MV_PAR01', "\\baseline\\atfa006_tir09.csv")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Ok")
self.oHelper.AssertTrue()
@classmethod
def test_ATFA006_CT010(self): #Importar
self.oHelper.SetButton("Outras Ações", "Importar")
self.oHelper.SetValue('MV_PAR01', "\\baseline\\atfa006_tir10.csv")
self.oHelper.SetValue("Gerar rev. para taxa existente ?","Sim")
self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse('07000220180901 ')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAATF/ATFA240TESTCASE.py
```python
from tir import Webapp
import unittest
class ATFA240(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAATF', '10/04/2016', 'T1', 'M PR 01 ')
inst.oHelper.Program('ATFA240')
@classmethod
def test_ATFA240_CT001(self):
self.oHelper.SearchBrowse('M PR 01 NFE00000250001')
#N3_FILIAL+N3_CBASE+N3_ITEM+N3_TIPO+N3_BAIXA+N3_SEQ
self.oHelper.SetButton("Classificar")
self.oHelper.SetBranch("M PR 01 ")
self.oHelper.WaitShow('Ativo Imobilizado - Classificacao de Ativos Imobilizados')
self.oHelper.SetValue("M->N1_GRUPO","0001",name_attr=True)
self.oHelper.SetButton("Sim")
self.oHelper.SetValue("Num.Plaqueta","NFE0000025")
self.oHelper.SetButton("Confirmar")
self.oHelper.WaitShow("Registro alterado com sucesso.")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse('M PR 01 NFE00000250001')
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult('N1_CBASE' , 'NFE0000025')
self.oHelper.CheckResult('N1_ITEM' , '0001')
self.oHelper.CheckResult('N1_AQUISIC' , '10/03/2016')
self.oHelper.CheckResult('N3_TIPO' , '01')
self.oHelper.CheckResult('N3_CCONTAB' , '101010105')
self.oHelper.CheckResult('N3_CDEPREC' , '101010105')
self.oHelper.CheckResult('N3_TXDEPR1' , '10,0000')
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def test_ATFA240_CT002(self):
self.oHelper.SearchBrowse('M PR 01 NFE00000270001')
#N3_FILIAL+N3_CBASE+N3_ITEM+N3_TIPO+N3_BAIXA+N3_SEQ
self.oHelper.SetButton("Classificar")
self.oHelper.SetBranch("M PR 01 ")
self.oHelper.SetValue("Grupo","0002")
self.oHelper.SetButton("Sim")
self.oHelper.SetValue("Num.Plaqueta","NFE0000027")
self.oHelper.SetButton("Confirmar")
self.oHelper.WaitShow("Registro alterado com sucesso.")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse('M PR 01 NFE00000270001')
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult('N1_CBASE' , 'NFE0000027')
self.oHelper.CheckResult('N1_ITEM' , '0001')
self.oHelper.CheckResult('N1_AQUISIC' , '31/03/2016')
self.oHelper.CheckResult('N3_TIPO' , '01')
self.oHelper.CheckResult('N3_CCONTAB' , '101010105')
self.oHelper.CheckResult('N3_TXDEPR1' , '12,0000')
self.oHelper.CheckResult('N3_EC05DB' , '000001')
self.oHelper.CheckResult('N3_EC05CR' , '000002')
self.oHelper.CheckResult('N3_EC06DB' , '000001')
self.oHelper.CheckResult('N3_EC06CR' , '000002')
self.oHelper.CheckResult('N3_EC07DB' , '000001')
self.oHelper.CheckResult('N3_EC07CR' , '000002')
self.oHelper.CheckResult('N3_EC08DB' , '000001')
self.oHelper.CheckResult('N3_EC08CR' , '000002')
self.oHelper.CheckResult('N3_EC09DB' , '000001')
self.oHelper.CheckResult('N3_EC09CR' , '000002')
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
##############################################################################################
##### Classificar mudando codigo do bem
# ############################################################################################
@classmethod
def test_ATFA240_CT003(self):
#self.oHelper.AddParameter("MV_ULTDEPR","M PR 01 ", "20161004")
#self.oHelper.SetParameters() ##Caso queira rodar a configuração do ultdepr pelo robo
self.oHelper.SearchBrowse('M PR 01 NFE000002B0001')
self.oHelper.SetButton("Classificar")
self.oHelper.SetBranch("M PR 01 ")
self.oHelper.SetValue("Grupo","0001")
self.oHelper.SetButton("Sim")
self.oHelper.CheckResult('N1_CBASE' , 'NFE000002B') ##Verificando codigo anterior
self.oHelper.SetValue('N1_CBASE' , 'NFE0000MOD')
self.oHelper.SetValue("N1_CHAPA","NFE000002T")#Num.Plaqueta #N1_CHAPA
self.oHelper.SetButton("Confirmar")
self.oHelper.WaitShow("Registro alterado com sucesso.")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse('M PR 01 NFE0000MOD0001')
self.oHelper.SetButton("Visualizar")
##Cabeçalho SN1
self.oHelper.CheckResult('N1_CBASE' , 'NFE0000MOD')
self.oHelper.CheckResult('N1_ITEM' , '0001')
self.oHelper.CheckResult("N1_CHAPA","NFE000002T")#Num.Plaqueta #NFE0000MOD
self.oHelper.CheckResult('N1_AQUISIC' , '10/04/2016')
##Cabeçalho SN3
self.oHelper.CheckResult("N3_TIPO","01")
self.oHelper.CheckResult('N3_VORIG1' , '2500,00')
self.oHelper.CheckResult('N3_TIPO' , '01')
self.oHelper.CheckResult('N3_CCONTAB' , '101010105')
self.oHelper.CheckResult('N3_CDEPREC' , '101010105')
self.oHelper.CheckResult('N3_TXDEPR1' , '10,0000')
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAATF/ATFA490TESTCASE.py
```python
from tir import Webapp
import unittest
class ATFA490(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAATF", "01/03/2016", "T1", "D MG 01 ", "01")
inst.oHelper.Program("ATFA490")
# Para que o Tipo de Saldo seja considerado nas pesquisas e validações relacionados
#inst.oHelper.AddParameter("MV_CTBCTG ","", ".T.")
# inst.oHelper.SetParameters()
# ==================================================================================
# Copiar Provisão
# Kanoah "https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T532"
# ==================================================================================
def test_ATFA490_001(self):
##COPIA
self.oHelper.SearchBrowse("D MG 01 00000000060001")
self.oHelper.SetButton("Outras Ações", "Copiar")
self.oHelper.SetValue("FNU_COD","TIR01")
self.oHelper.SetValue("FNU_DESCR","Copia TIR")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
# ==================================================================================
# Revisar Provisão
# Kanoah "https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T551"
# ==================================================================================
def test_ATFA490_002(self):
self.oHelper.SearchBrowse("D MG 01 00000000070001")
self.oHelper.SetButton("Outras Ações", "Revisar")
self.oHelper.SetValue("Mostra Lanc. Contabeis ?","Não")
self.oHelper.SetValue("Aglut Lançamentos ?","Não")
self.oHelper.SetValue("Contabiliza Online ?","Não")
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Confirmar")
self.oHelper.CheckHelp("Deseja gravar a operação, bloqueando a revisão anterior ?","Sim")
self.oHelper.AssertTrue()
# ==================================================================================
# Desbloqueio de Provisão
# Kanoah "https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T537"
# ==================================================================================
def test_ATFA490_003(self):
self.oHelper.SearchBrowse("D MG 01 00000000080001")
self.oHelper.SetButton("Outras Ações", "Bloqueio/Desbloq")
self.oHelper.SetValue("FNU_MSBLQL","2 - Não")
self.oHelper.SetButton("Confirmar")
self.oHelper.CheckHelp("Deseja Realizar o bloqueio/desbloqueio do controle de provisão ?","Sim")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("FNU_MSBLQL","2 - Não")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGABI/BIXLogTestCase.py
```python
import time
import unittest
from tir import Webapp
class BIXLOG(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGACFG','11/12/2018','T1','D MG 01 ')
inst.oHelper.SetLateralMenu('Ambiente > Extrator Bi > Log de Extração')
def test_BIXLOG_CT001(self):
# Outras Ações
# Log de Extração
self.oHelper.SetButton("Outras Ações", sub_item="Log de Extração")
self.oHelper.SetButton('Fechar')
time.sleep(2)
# Analise de Performance
self.oHelper.SetButton("Outras Ações", sub_item="Análise de Performance")
self.oHelper.SetButton('Fechar')
time.sleep(2)
# Configuração
self.oHelper.SetButton("Outras Ações", sub_item="Configuração")
self.oHelper.ClickLabel("Habilitar modo de debug ?")
self.oHelper.ClickLabel("Alertar sobre ocorrência de erro na extração de fatos e dimensões ?")
self.oHelper.ClickLabel("Alertar no momento em que uma extração for finalizada ?")
self.oHelper.ClickLabel("Alertar no momento em que uma extração for cancelada ?")
self.oHelper.SetButton('Confirmar')
time.sleep(2)
#Gerar Relatório
self.oHelper.SetButton("Outras Ações", sub_item="Gerar Relatório")
self.oHelper.ClickLabel("Enviar arquivo HTML gerado por e-mail ? ")
self.oHelper.SetValue("Quem deve receber e-mail com o relatório gerado anexo ?", "<EMAIL>")
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton("Outras Ações", sub_item="Gerar Relatório")
self.oHelper.ClickLabel("Abrir arquivo HTML gerado no browser após confirmação? ")
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
# Configurar
self.oHelper.SetButton("Outras Ações", sub_item="Configurar")
self.oHelper.SetButton('OK')
time.sleep(2)
# Log de Extração tela principal
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGABI/BIXProfileTestCase.py
```python
import unittest
from tir import Webapp
class BIXPROFILE(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGACFG','11/12/2018','T1','D MG 01 ')
inst.oHelper.SetLateralMenu('Ambiente > Extrator Bi > Perfil de Extração')
def test_BIXPROFILE_CT001(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetValue("Código", "000001")
self.oHelper.SetValue("Descrição", "Extracao 000001")
self.oHelper.ClickLabel("Marcar / Desmarcar" ) # desmarcar
self.oHelper.ScrollGrid(column="Tabela", match_value="HL2", grid_number=2)
self.oHelper.ClickBox("Tabela", contents_list="HL2", grid_number=2)
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_BIXPROFILE_CT002(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetValue("Código", "000000")
self.oHelper.SetValue("Descrição", "Extracao 00000")
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_BIXPROFILE_CT003(self):
self.oHelper.SetButton("Visualizar") # Perfil de extração - VISUALIZAR
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_BIXPROFILE_CT004(self):
self.oHelper.SetButton("Alterar") # Perfil de Extração - ALTERAR
self.oHelper.SetValue("Descrição", "BIXPROFILE")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_BIXPROFILE_CT005(self):
self.oHelper.SetButton("Outras Ações", sub_item="Executar Perfil") # Executar Perfil
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton('Não')
self.oHelper.AssertTrue()
def test_BIXPROFILE_CT006(self):
self.oHelper.SetButton("Outras Ações", sub_item="Excluir") # Excluir
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGACRM/CRMA070TESTCASE.py
```python
from tir import Webapp
import unittest
import time
from datetime import datetime
DateSystem = datetime.today().strftime("%d/%m/%Y")
class CRMA070(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.SetTIRConfig(config_name="user", value="aline.toyoda")
inst.oHelper.SetTIRConfig(config_name="password", value="1")
inst.oHelper.Setup('SIGAADV',DateSystem,'T1','D MG 01 ','73')
inst.oHelper.Program('CRMA070')
def test_CRMA070_001(self):
'''
Caso de Teste 001
'''
clienteCodigo = "CLI029"
clienteNome = "<NAME>"
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Clientes - INCLUIR")
self.oHelper.SetValue("Codigo",clienteCodigo)
self.oHelper.SetValue("Loja","01")
self.oHelper.SetValue("Nome",clienteNome)
self.oHelper.SetValue("N Fantasia","FANTASIA CLIENTE")
self.oHelper.SetValue("Endereco","ENDERECO CLIENTE")
self.oHelper.SetValue("Tipo","F")
self.oHelper.SetValue("Estado","SP")
self.oHelper.SetValue("Cd.Municipio","50308")
self.oHelper.SetValue("Municipio","SAO PAULO")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Não")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#CT021 - TIR - Incluir uma Atividade do tipo E-mail vinculada à uma Entidade (Clientes)
def test_CRMA070_CT021(self):
self.oHelper.SearchBrowse("D MG CRM180")
self.oHelper.SetButton("Outras Ações", "Relacionadas, Atividades, Nova Atividade")
time.sleep(5)
self.oHelper.SetBranch("D MG 01 ")
self.oHelper.ClickLabel('E-mail')
self.oHelper.SetButton('Sim')
self.oHelper.SetValue("AOF_PARTIC", "<EMAIL>")
#Se o campo de destinatário estiver vazio, sem carregar o A1_EMAIL, não passa
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGACRM/CRMA290TESTCASE.py
```python
from tir import Webapp
from datetime import datetime
DataSystem = datetime.today().strftime('%d/%m/%Y')
import unittest
import time
class CRMA290(unittest.TestCase):
Contr = ""
@classmethod
def setUpClass(inst):
'''
SETUP
Test Case Initial Setup
'''
#Endereço do webapp e o nome do Browser
inst.oHelper = Webapp()
inst.oHelper.SetTIRConfig(config_name="User", value="APICRM")
inst.oHelper.SetTIRConfig(config_name="Password", value="1")
#Parametros de inicializaçao
inst.oHelper.Setup("SIGACRM", DataSystem,"T1","D MG 01 ","73")
#Nome da rotina do Caso de Teste
inst.oHelper.Program("CRMA290")
def test_CRMA290_CT001(self):
'''
Test Case 001
'''
#self.oHelper.SetButton("Não")
time.sleep(15)
self.oHelper.ClickLabel("+ Criar Oportunidade")
NumOpt = self.oHelper.GetValue("AD1_NROPOR")
self.oHelper.SetValue("AD1_DESCRI", "INCLUSAO TIR AT")
self.oHelper.SetValue("AD1_DTINI",DataSystem)
self.oHelper.SetValue("AD1_CODCLI","FATT01")
self.oHelper.SetValue("AD1_LOJCLI","01")
self.oHelper.SetValue("AD1_PROVEN","FAT001")
self.oHelper.SetValue("AD1_STAGE","000002")
self.oHelper.SetButton("Confirmar")
self.oHelper.WaitShow("Minhas Oportunidades")
self.oHelper.ClickLabel("Minhas Oportunidades")
self.oHelper.WaitHide("Minhas Oportunidades")
self.oHelper.SearchBrowse(f"D MG 01 {NumOpt}")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("AD1_NROPOR", NumOpt)
self.oHelper.CheckResult("AD1_DESCRI", "INCLUSAO TIR AT")
self.oHelper.CheckResult("AD1_CODCLI","FATT01")
self.oHelper.CheckResult("AD1_LOJCLI","01")
self.oHelper.CheckResult("AD1_PROVEN","FAT001")
self.oHelper.CheckResult("AD1_STAGE","000002")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("X")
self.oHelper.AssertTrue()
def test_CRMA290_CT002(self):
'''
Test Case 002
'''
self.oHelper.WaitShow("Minhas Oportunidades")
self.oHelper.ClickLabel("Minhas Oportunidades")
NumOpt = '000273'
self.oHelper.SearchBrowse(f"D MG 01 {NumOpt}")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue("AD1_DESCRI", "ALTERACAO TIR AT")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Sim")
self.oHelper.SearchBrowse(f"D MG 01 {NumOpt}")
self.oHelper.SetButton("Alterar")
self.oHelper.ClickFolder('Produtos')
self.oHelper.SetValue("ADJ_PROD", "FAT004", grid=True, row=1)
self.oHelper.SetValue("ADJ_PRUNIT", "1,00", grid=True, row=1)
self.oHelper.LoadGrid()
self.oHelper.SetValue("AD1_DESCRI", "ALTERACAO 2 TIR AT")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Não")
self.oHelper.SearchBrowse(f"D MG 01 {NumOpt}")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("AD1_NROPOR",NumOpt)
self.oHelper.CheckResult("AD1_REVISA","02")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("X")
self.oHelper.AssertTrue()
def test_CRMA290_CT003(self):
'''
Test Case 003
'''
self.oHelper.WaitShow("Oportunidade Rápida")
self.oHelper.ClickLabel("Oportunidade Rápida")
NumOpt = self.oHelper.GetValue("AD1_NROPOR")
self.oHelper.SetValue("AD1_DESCRI", "INCLUSAO TIR AT")
self.oHelper.SetValue("AD1_DTINI",DataSystem)
self.oHelper.SetValue("AD1_CODCLI","FATT01")
self.oHelper.SetValue("AD1_LOJCLI","01")
self.oHelper.SetValue("AD1_PROVEN","FAT001")
self.oHelper.SetValue("AD1_STAGE","000002")
self.oHelper.SetButton("Confirmar")
self.oHelper.WaitShow("Minhas Oportunidades")
self.oHelper.ClickLabel("Minhas Oportunidades")
self.oHelper.WaitHide("Minhas Oportunidades")
self.oHelper.SearchBrowse(f"D MG 01 {NumOpt}")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("AD1_NROPOR", NumOpt)
self.oHelper.CheckResult("AD1_DESCRI", "INCLUSAO TIR AT")
self.oHelper.CheckResult("AD1_CODCLI","FATT01")
self.oHelper.CheckResult("AD1_LOJCLI","01")
self.oHelper.CheckResult("AD1_PROVEN","FAT001")
self.oHelper.CheckResult("AD1_STAGE","000002")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("X")
self.oHelper.AssertTrue()
def test_CRMA290_CT004(self):
'''
Test Case 004
'''
time.sleep(15)
self.oHelper.WaitShow("Minhas Oportunidades")
self.oHelper.ClickLabel("Minhas Oportunidades")
NumOpt = '000277'
self.oHelper.SearchBrowse(f"D MG 01 {NumOpt}")
self.oHelper.SetButton("Alterar")
self.oHelper.SetButton("Outras Ações","Proposta Comercial")
self.oHelper.SetButton("Incluir")
self.oHelper.SetValue("ADY_TABELA","API")
self.oHelper.SetValue("ADY_CONDPG","000")
self.oHelper.SetValue("ADY_TES","501")
self.oHelper.SetValue("ADZ_PRODUT", "FAT001", grid=True)
self.oHelper.SetValue("ADZ_PRCVEN", "100,00", grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("X")
self.oHelper.SetValue("AD1_FCS", "000003")
self.oHelper.SetValue("AD1_STATUS", "9 - Ganha")
self.oHelper.ClickFolder("Aceite da proposta")
self.oHelper.SetValue("AD1_DTASSI", DataSystem)
self.oHelper.SetFocus("AD1_CNTPRO")
self.oHelper.SetKey("F3")
self.oHelper.SetButton("Incluir")
self.oHelper.SetValue("U5_CODCONT", "TIR001")
self.oHelper.SetValue("U5_CONTAT", "Contato OP TIR")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("X")
time.sleep(15)
self.oHelper.AssertTrue()
def test_CRMA290_CT005(self):
'''
Test Case 005 - Teste
'''
time.sleep(15)
self.oHelper.WaitShow("Minhas Oportunidades")
self.oHelper.ClickLabel("Minhas Oportunidades")
NumOpt = '000275'
#Alterar a tela de legenda para acrescentar o botão fechar.
#self.oHelper.SetButton("Outras Ações","Legenda")
#self.oHelper.SetButton("x")
self.oHelper.SearchBrowse(f"D MG 01 {NumOpt}")
self.oHelper.SetButton("Alterar")
self.oHelper.SetButton("Outras Ações","Legenda Evolução da Venda")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Outras Ações","Histórico da Oportunidade")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("ADC_NROPOR", '000275')
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("X")
self.oHelper.SetButton("Outras Ações","Pendência Financeira")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Outras Ações","Avaliação Financeira")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Outras Ações","Análise do Custo")
self.oHelper.SetButton("Parâmetro")
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Sair da página")
self.oHelper.SetButton("X")
time.sleep(15)
self.oHelper.AssertTrue()
def test_CRMA290_CT006(self):
'''
Test Case 006 - Teste
'''
time.sleep(15)
self.oHelper.WaitShow("Minhas Oportunidades")
self.oHelper.ClickLabel("Minhas Oportunidades")
time.sleep(15)
self.oHelper.WaitShow("Oportunidade de Venda:")
NumOpt = '000275'
#Alterar a tela de legenda para acrescentar o botão fechar.
#self.oHelper.SetButton("Outras Ações","Legenda")
#self.oHelper.SetButton("x")
self.oHelper.SearchBrowse(f"D MG 01 {NumOpt}")
self.oHelper.SetButton("Outras Ações","Comparar")
self.oHelper.ClickGridCell("Revisao",row=1)
self.oHelper.ClickBox("Revisao", "01")
self.oHelper.ClickGridCell("Revisao",row=2)
self.oHelper.ClickBox("Revisao", "02")
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("COMPARAR")
self.oHelper.SetButton("Outras Ações","Legenda")
time.sleep(15)
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Outras Ações","Próx.Dif")
self.oHelper.SetButton("Outras Ações","Dif.Ant.")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("X")
time.sleep(15)
self.oHelper.AssertTrue()
def test_CRMA290_CT007(self):
'''
Test Case 007 - Teste
'''
time.sleep(15)
self.oHelper.WaitShow("Criar Painel")
self.oHelper.ClickLabel("Criar Painel")
self.oHelper.SetButton("Sim")
self.oHelper.WaitShow("Configuração")
self.oHelper.SetButton("Avançar >>")
self.oHelper.SetValue("Digite o nome do Painel:","TIR001")
self.oHelper.SetButton("Avançar >>")
self.oHelper.SetValue("cCbxOpcs1","Tabela",name_attr = True)
self.oHelper.SetValue("cCbxAlias1","SA1 - Clientes", name_attr = True)
self.oHelper.SetValue("cCbxOpcs2","Gráfico", name_attr = True)
self.oHelper.SetValue("cCbxAlias2","SA1 - Clientes", name_attr = True)
self.oHelper.SetButton("Avançar >>")
self.oHelper.SetButton("Avançar >>")
self.oHelper.SetButton("Finalizar")
self.oHelper.SetButton("Sim")
time.sleep(15)
self.oHelper.AssertTrue()
def test_CRMA290_CT008(self):
'''
Test Case 008 - Meus Pedidos
'''
self.oHelper.WaitShow("Minhas Oportunidades")
self.oHelper.ClickLabel("Meus Pedidos")
self.oHelper.SetButton("X")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
'''
Method that finishes the test case.
'''
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGACTB/CTBA010TESTCASE.py
```python
from tir import Webapp
import unittest
class CTBA010(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGACTB", "01/04/2016", "T1", "D MG 01 ", "34")
inst.oHelper.Program("CTBA010")
def test_CTBA010_001(self):
self.oHelper.WaitShow("Cadastro Calendário Contábil")
self.oHelper.SetKey("F12") #abri o wizard de parâmetro
self.oHelper.SetValue("Tipo da Interface ?","Assistente") #Seleciona o modo assistente para inclusão
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Avançar")
self.oHelper.SetValue("Data Inicial ?","01/01/2098")
self.oHelper.SetValue("Data Final ?","31/12/2098")
self.oHelper.SetButton("Avançar")
self.oHelper.SetButton("Avançar")
self.oHelper.SetButton("Avançar")
self.oHelper.SetValue("Calendario ?","298")
self.oHelper.SetValue("Exercicio Contabil ?","2098")
self.oHelper.ClickCheckBox("Amarrar Calendario com Moedas",1)
self.oHelper.SetButton("Avançar")
self.oHelper.SetButton("Finalizar")
self.oHelper.SetButton("Avançar") #wizard de amarração da moeda
self.oHelper.SetButton("Finalizar")
self.oHelper.SetButton("Sim")
self.oHelper.SearchBrowse("D MG 01 298") #filtra o calendário criado na tela
self.oHelper.SetButton("Visualizar")
#na opcao de visualizar clica nos itens da arvore para expandir o conteudo
self.oHelper.ClickTree("298 - Exercicio : 2098 > Periodo 01 de : 01/01/2098 ate : 31/01/2098", right_click=True)
#checando os valores do resultado esperado
self.oHelper.CheckResult('CTG_CALEND','298',name_attr=True)
self.oHelper.CheckResult('CTG_EXERC','2098',name_attr=True)
self.oHelper.CheckResult('CTG_PERIOD','01',name_attr=True)
self.oHelper.CheckResult('CTG_DTINI','01/01/2098',name_attr=True)
self.oHelper.CheckResult('CTG_DTFIM','31/01/2098',name_attr=True)
self.oHelper.CheckResult('CTG_STATUS','1 - Aberto',name_attr=True)
self.oHelper.SetButton("x")
self.oHelper.SetButton("x") #volta para a tela principal para inicio automatico de novo caso de teste
self.oHelper.AssertTrue()
def test_CTBA010_002(self):
self.oHelper.SearchBrowse("D MG 01 297") #seleciona registro criado na base congelada
self.oHelper.SetButton("Outras Ações","Excluir") #clica no botao excluir
self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse("D MG 01 297") #faz a pesquisa pelo registro que foi excluido
self.oHelper.SetButton("Alterar") #com o registro filtrado seleciona a opcao alterar para validacao dos valores
#verificando se o registro encontrado é igual ao excluido
self.oHelper.CheckResult('cCalendCTB','297',name_attr=True)
self.oHelper.CheckResult('cExerc','2097',name_attr=True)
self.oHelper.SetButton("x") # voltando para a tela principal para inicio de novos casos de teste
self.oHelper.AssertFalse() #como os dados encontrados não devem ser iguais ao do registro excluido usado assertfalse
def test_CTBA010_003(self):
self.oHelper.SearchBrowse("D MG 01 296") #seleciona registro criado na base congelada
self.oHelper.SetButton("Outras Ações","Bloqueio de Processo")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse("D MG 01 296")
self.oHelper.SetButton("Outras Ações","Bloqueio Automático")
self.oHelper.SetValue("Data Inicial ?","01/01/2096") #setando os valores para o bloqueio automatico
self.oHelper.SetValue("Data Final ?","28/02/2096")
self.oHelper.SetValue("Processo Inicial ?","ATF001")
self.oHelper.SetValue("Processo Final ?","ATF001")
self.oHelper.SetValue("Status ?","Bloqueado")
self.oHelper.SetValue("Seleciona Filial ?","Não")
self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse("D MG 01 296")
self.oHelper.SetButton("Outras Ações","Visualizar Bloqueio") #entra na tela de visualização de bloqueio para validar os valores
self.oHelper.WaitShow("Bloqueio de Processo - Visualização - Bloqueio de Processo") #força o robo esperar o conteudo da tela carregar
#checando valor esperado
self.oHelper.CheckResult('Status bloq.','Bloqueado',grid=True,line=1,grid_number=2,name_attr=False)
self.oHelper.LoadGrid() #para verificação de valor de grid se faz necessario usar função LoadGrid
self.oHelper.SetButton("Fechar") #Volta para a tela inicial
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGACTB/CTBA102TESTCASE.py
```python
from tir import Webapp
import unittest
class CTBA102(unittest.TestCase):
@classmethod
def setUpClass(inst):
# Endereço do webapp e o nome do Browser
inst.oHelper = Webapp()
# Parametros de inicializaçao
inst.oHelper.Setup("SIGACTB", "15/04/2015", "T1", "M SP 01 ", "34")
# Nome da rotina do Caso de Teste
inst.oHelper.Program("CTBA102")
def test_CTBA102_001(self):
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("M SP 01 ")
self.oHelper.SetValue("Lote", "000001")
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("Tipo Lcto" ,"3 - Partida Dobrada",grid=True)
self.oHelper.SetValue("CT2_DEBITO","101030105" ,grid=True)
self.oHelper.SetValue("CT2_CREDIT","2130205" ,grid=True)
self.oHelper.SetValue("CT2_VALOR" ,"1000,00" ,grid=True)
self.oHelper.SetValue("Hist Lanc" ,"TESTE INC.",grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("CT2_VALOR", "1.000,00", grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_CTBA102_002(self):
# INCLUSAO COLOCANDO O LOTE PROPRIO
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("M SP 01 ")
self.oHelper.SetValue("Lote", "998877")
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("Tipo Lcto", "3 - Partida Dobrada", grid=True)
self.oHelper.SetValue("CT2_DEBITO", "101030105", grid=True)
self.oHelper.SetValue("CT2_CREDIT", "2130205", grid=True)
self.oHelper.SetValue("CT2_VALOR", "5000000000,00", grid=True)
self.oHelper.SetValue("CT2_HP", "456", grid=True)
self.oHelper.SetValue("CT2_CCD", "124", grid=True)
self.oHelper.SetValue("CT2_CCC", "223", grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SearchBrowse(f"M SP 01 15/04/2015998877001000001", "Filial+data Lcto + Numero Lote + Sub Lote + Numero Doc + Seq Auxiliar + Empre")
self.oHelper.SetButton("Visualizar")
self.oHelper.LoadGrid()
self.oHelper.SetFocus("Valor",grid_cell=True,row_number=1)
self.oHelper.SetKey("F4", grid=True)
self.oHelper.SetButton("x")
self.oHelper.LoadGrid()
self.oHelper.SetFocus("Valor",grid_cell=True,row_number=1)
self.oHelper.SetKey("F5", grid=True)
self.oHelper.SetButton("Fechar")
self.oHelper.SetFocus("Valor",grid_cell=True,row_number=1)
self.oHelper.SetKey("F6", grid=True)
self.oHelper.SetButton("Fechar")
self.oHelper.SetFocus("Valor",grid_cell=True,row_number=1)
self.oHelper.SetKey("F7", grid=True)
self.oHelper.SetButton("x")
self.oHelper.CheckResult("CT2_VALOR", "5.000.000.000,00", grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_CTBA102_003(self):
# Copiar para filial atual.
codigo = "101010100 13/07/2015"
self.oHelper.SearchBrowse(f"M SP 01 {codigo}", "Filial+cta Debito + Data Lcto")
self.oHelper.SetButton("Outras Ações", "Copiar")
self.oHelper.SetBranch("M SP 01 ")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_CTBA102_004(self):
self.oHelper.SearchBrowse(f"M SP 01 15/04/2015998877001000001", "Filial+data Lcto + Numero Lote + Sub Lote + Numero Doc + Seq Auxiliar + Empre")
# Excluir em lote
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Sim")
# PARAMETROS
self.oHelper.SetValue("mv_par01", "15042015") # Da data ?
self.oHelper.SetValue("mv_par02", "15042015") # Ate a Data ?
self.oHelper.SetValue("mv_par03", "998877") # Do Lote?
self.oHelper.SetValue("mv_par04", "998877") # Ate o Lote?
self.oHelper.SetValue("mv_par05", "000") # Do SubLote ?
self.oHelper.SetValue("mv_par06", "999") # Ate o SubLote?
self.oHelper.SetValue("mv_par07", "000000") # Do Documento ?
self.oHelper.SetValue("mv_par08", "999999") # Ate o Documento ?
self.oHelper.SetValue("Gerar na data lanc.orig. ?", "Não") # Ate o Documento ?
self.oHelper.SetValue("Imp.relat. inconsist. ?", "Não") # Ate o Documento ?
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"M SP 01 15/04/2015998877001000001", "Filial+data Lcto + Numero Lote + Sub Lote + Numero Doc + Seq Auxiliar + Empre")
self.oHelper.SetButton('Visualizar')
self.oHelper.CheckResult("CT2_DEBITO", "101030105", grid=True, line=1)
self.oHelper.CheckResult("CT2_CREDIT", "2130205", grid=True, line=1)
self.oHelper.CheckResult("CT2_VALOR", "5.000.000.000,00", grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertFalse()
def test_CTBA102_005(self):
codigo = "101010100 13/07/2015"
self.oHelper.SearchBrowse(f"M SP 01 {codigo}", "Filial+cta Debito + Data Lcto")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Não")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Sim")
self.oHelper.SearchBrowse(f"M SP 01 {codigo}", "Filial+cta Debito + Data Lcto")
self.oHelper.AssertTrue()
def test_CTBA102_006(self):
# Alteração moeda e historico
codigo = "101030105 15/04/2015"
self.oHelper.SearchBrowse(f"M SP 01 {codigo}", "Filial+cta Debito + Data Lcto")
self.oHelper.SetButton("Alterar")
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("CT2_HIST", "TESTANDOO",grid=True)
self.oHelper.SetValue("CT2_VALOR", "5.000,00",grid=True)
self.oHelper.LoadGrid()
self.oHelper.CheckResult("CT2_HIST", "TESTANDOO", grid=True)
self.oHelper.CheckResult("CT2_VALOR", "5.000,00", grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetKey("DOWN",grid=True) #adicionar continuacao de histórico
self.oHelper.SetValue("Tipo Lcto" ,"4 - Cont.Hist",grid=True)
self.oHelper.SetValue("Hist Lanc" ,"TESTE ADICIONADO CONTINUACAO",grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
def test_CTBA102_007(self):
# Copiar para filial destino com inserção automatica - Data somente preenchda na capa do lote
codigo = "101010100 13/07/2015"
self.oHelper.SearchBrowse(f"M SP 01 {codigo}", "Filial+cta Debito + Data Lcto")
self.oHelper.SetButton("Outras Ações", "Cópia Filial")
self.oHelper.SetValue("MV_PAR01", "D MG 01",name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("Data", "18042018")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Salvar")
self.oHelper.SearchBrowse(f"D MG 01 {codigo}", "Filial+cta Debito + Data Lcto")
self.oHelper.AssertTrue()
def test_CTBA102_008(self):
#Inclui lançamento com LP pelo CTBA102
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("M SP 01 ")
self.oHelper.SetValue("Lote","TIR008")
self.oHelper.SetValue("Lçto.Padrão","TIR")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("CT2_VALOR", "1.000,00", grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_CTBA102_009(self):
#Inclui lançamento com Rateio online
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("M SP 01 ")
self.oHelper.SetValue("Lote","TIR009")
self.oHelper.SetValue("Lçto.Padrão","TIR")
self.oHelper.SetButton("Ok")
self.oHelper.SetFocus("Cta Debito",grid_cell=True,row_number=1)
self.oHelper.SetKey("F3", grid=True)
self.oHelper.SearchBrowse("012340000")
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("nValRat","1.000,00",name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("CT2_VALOR", "500,00",grid=True,line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_CTBA102_010(self):
#Inclui lançamento com Rateio online
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("M SP 01 ")
self.oHelper.SetValue("Lote","TIR010")
self.oHelper.SetValue("Lçto.Padrão","TIR")
self.oHelper.SetButton("Ok")
self.oHelper.SetFocus("Hist Pad",grid_cell=True,row_number=1)
self.oHelper.SetKey("F3", grid=True)
self.oHelper.SearchBrowse("TIR")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("CT2_VALOR", "1.000,00",grid=True,line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_CTBA102_011(self):
codigo = "11/10/2015008810001000001"
self.oHelper.SearchBrowse(f"M SP 01 {codigo}",key=1,index=True)
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Não")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Sim")
self.oHelper.WaitProcessing("Aguarde")
self.oHelper.SearchBrowse(f"M SP 01 {codigo}",key=1,index=True)
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("CT2_DEBITO", "012340002", grid=True, line=1)
self.oHelper.CheckResult("CT2_VALOR", "10.000,00", grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertFalse()
def test_CTBA102_012(self):
codigo = "11/10/2015008850001000001"
self.oHelper.SearchBrowse(f"M SP 01 {codigo}",key=1,index=True)
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Não")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Sim")
self.oHelper.WaitProcessing("Aguarde")
self.oHelper.SearchBrowse(f"M SP 01 {codigo}",key=1,index=True)
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("CT2_DEBITO", "012340003", grid=True, line=1)
self.oHelper.CheckResult("CT2_VALOR", "10.000,00", grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertFalse()
def test_CTBA102_013(self):
codigo = "11/10/2015008850001000002"
self.oHelper.SearchBrowse(f"M SP 01 {codigo}",key=1,index=True)
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Não")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Sim")
self.oHelper.WaitProcessing("Aguarde")
self.oHelper.SearchBrowse(f"M SP 01 {codigo}",key=1,index=True)
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("CT2_DEBITO", "012340002", grid=True, line=1)
self.oHelper.CheckResult("CT2_VALOR", "1.000,00", grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertFalse()
def test_CTBA102_014(self):
self.oHelper.AddParameter("MV_CTBAPLA","","4")
self.oHelper.AddParameter("MV_ATUSAL" ,"","N")
self.oHelper.AddParameter("MV_CONTBAT","","S")
self.oHelper.AddParameter("MV_CONTSB" ,"","N")
self.oHelper.AddParameter("MV_CTBLIMC","","0.20;0.20;0.20;0.20;0.20")
self.oHelper.AddParameter("MV_CTBCENC","","10101010003")
self.oHelper.SetParameters()
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("M SP 01 ")
self.oHelper.SetValue("Lote", "CTB666")
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("Tipo Lcto" ,"1 - Debito" ,grid=True)
self.oHelper.SetValue("CT2_DEBITO","10101010001",grid=True)
self.oHelper.SetValue("CT2_CREDIT","" ,grid=True)
self.oHelper.SetValue("Hist Lanc" ,"TESTE" ,grid=True)
self.oHelper.SetValue("CT2_VALR02","100,00" ,grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetKey("DOWN",grid=True)
self.oHelper.SetValue("Tipo Lcto" ,"2 - Credito",grid=True)
self.oHelper.SetValue("CT2_DEBITO","" ,grid=True)
self.oHelper.SetValue("CT2_CREDIT","10101010002",grid=True)
self.oHelper.SetValue("Hist Lanc" ,"TESTE" ,grid=True)
self.oHelper.SetValue("CT2_VALR02","100,15" ,grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("CT2_DEBITO", "10101010003", grid=True, line=3)
self.oHelper.CheckResult("CT2_VALR02", "0,15" , grid=True, line=3)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.RestoreParameters()
self.oHelper.AssertTrue()
################################################################################
# Inclusão de lançamento com rateio online
# https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50023
################################################################################
def test_CTBA102_015(self):
codLote = 'RTON01'
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("D RJ 02 ")
self.oHelper.SetValue("Data", "14/04/2015")
self.oHelper.SetValue("Lote", codLote)
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("Tipo Lcto" ,"5 - Rateio",grid=True, row=1)
self.oHelper.LoadGrid()
self.oHelper.SetValue("nValRat", "100,00",name_attr=True)
self.oHelper.SetValue("cHistorico", "CT015 CTBA102 RATEIO ONLINE",name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SearchBrowse(f"D RJ 02 14/04/2015RTON01001000001", "Filial+data Lcto + Numero Lote + Sub Lote + Numero Doc + Seq Auxiliar + Empre")
# self.oHelper.SearchBrowse(f"D RJ 02 14/04/2015RTON01001000001001")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("Tipo Lcto", "Partida Dobrada", grid=True, line=1)
self.oHelper.CheckResult("CT2_DEBITO", "RTONCTBA102D", grid=True, line=1)
self.oHelper.CheckResult("CT2_CREDIT", "RTONCTBA102C", grid=True, line=1)
self.oHelper.CheckResult("CT2_VALOR", "50,00", grid=True, line=1)
self.oHelper.CheckResult("CT2_HIST", "CT015 CTBA102 RATEIO ONLINE", grid=True, line=1)
self.oHelper.CheckResult("Tipo Lcto", "Partida Dobrada", grid=True, line=2)
self.oHelper.CheckResult("CT2_DEBITO", "RTONCTBA102D", grid=True, line=2)
self.oHelper.CheckResult("CT2_CREDIT", "RTONCTBA102C", grid=True, line=2)
self.oHelper.CheckResult("CT2_VALOR", "50,00", grid=True, line=2)
self.oHelper.CheckResult("CT2_HIST", "CT015 CTBA102 RATEIO ONLINE", grid=True, line=2)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
################################################################################
# Alteração de histórico de lançamento utilizando a funcionalidade de replica
# https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50025
################################################################################
def test_CTBA102_016(self):
self.oHelper.SearchBrowse(f"M SP 01 14/05/2015TIR016001000001", "Filial+data Lcto + Numero Lote + Sub Lote + Numero Doc + Seq Auxiliar + Empre")
self.oHelper.SetButton("Alterar")
self.oHelper.SetButton("Ok")
# self.oHelper.SetFocus("Hist Lanc", grid_cell=True, row_number=2)
# self.oHelper.SetKey("ESC")
self.oHelper.ClickGridCell("Hist Lanc", row =2)
self.oHelper.SetButton("Outras Ações", "Replicar")
self.oHelper.ClickCheckBox("Replicar conteúdo do campo em todas as linhas anteriores")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Sim")
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SearchBrowse(f"M SP 01 14/05/2015TIR016001000001", "Filial+data Lcto + Numero Lote + Sub Lote + Numero Doc + Seq Auxiliar + Empre")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("CT2_DEBITO", "RPLCTBA102TR16", grid=True, line=1)
self.oHelper.CheckResult("CT2_CREDIT", "RPLCTBA102TR16C", grid=True, line=1)
self.oHelper.CheckResult("CT2_VALOR", "6.000,00", grid=True, line=1)
self.oHelper.CheckResult("CT2_HIST", "REPLICA DE HISTORICO", grid=True, line=1)
self.oHelper.CheckResult("CT2_DEBITO", "RPLCTBA102TR16", grid=True, line=2)
self.oHelper.CheckResult("CT2_CREDIT", "RPLCTBA102TR16C", grid=True, line=2)
self.oHelper.CheckResult("CT2_VALOR", "5.000,00", grid=True, line=2)
self.oHelper.CheckResult("CT2_HIST", "REPLICA DE HISTORICO", grid=True, line=2)
self.oHelper.CheckResult("CT2_DEBITO", "RPLCTBA102TR16", grid=True, line=3)
self.oHelper.CheckResult("CT2_CREDIT", "RPLCTBA102TR16C", grid=True, line=3)
self.oHelper.CheckResult("CT2_VALOR", "4.000,00", grid=True, line=3)
self.oHelper.CheckResult("CT2_HIST", "REPLICA DE HISTORICO", grid=True, line=3)
self.oHelper.CheckResult("Tipo Lcto", "Cont.Hist", grid=True, line=4)
self.oHelper.CheckResult("CT2_VALOR", "0,00", grid=True, line=4)
self.oHelper.CheckResult("CT2_HIST", "CONTINUACAO DE HISTORICO REPLICA", grid=True, line=4)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
def test_CTBA102_017(self):
##TESTE EXPLORATÓRIO DE TELA - pesquisa de expressoes
self.oHelper.SetButton("Alterar")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Outras Ações", "Localizar")
self.oHelper.SetValue("Expressao:","003")
self.oHelper.SetButton("Adiciona")
self.oHelper.SetButton("Avançar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
def test_CTBA102_018(self):
##TESTE EXPLORATÓRIO DE TELA - Inconsistencias proximas e anterior
self.oHelper.SetButton("Alterar")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Outras Ações","Próxima")
##Confirmando help de tudo ok
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Outras Ações","Anterior")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
def test_CTBA102_019(self):
self.oHelper.SearchBrowse(f"D MG 01 01/06/2016CTDELL001000001", "Filial+data Lcto + Numero Lote + Sub Lote + Numero Doc + Seq Auxiliar + Empre")
self.oHelper.SetButton("Alterar")
self.oHelper.SetButton("Ok")
self.oHelper.LoadGrid()
self.oHelper.ClickGridCell("Tipo Lcto", row=1)
# self.oHelper.SetKey("Down",grid=True) #Deletando 1 linha
self.oHelper.SetKey("Delete",grid=True)
self.oHelper.ClickGridCell("Tipo Lcto", row=4)
self.oHelper.SetKey("Delete",grid=True) #Deletando continuação de historico
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
def test_CTBA102_020(self):
self.oHelper.SearchBrowse(f"D MG 01 01/06/2016CTCRIT001000001", "Filial+data Lcto + Numero Lote + Sub Lote + Numero Doc + Seq Auxiliar + Empre")
self.oHelper.SetButton("Alterar")
self.oHelper.SetButton("Ok")
self.oHelper.LoadGrid()
self.oHelper.ClickGridCell("Crit Conv")
self.oHelper.SetValue("Crit Conv","15555",grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.WaitHide("Processando")
self.oHelper.SearchBrowse(f"D MG 01 01/06/2016CTCRIT001000001", "Filial+data Lcto + Numero Lote + Sub Lote + Numero Doc + Seq Auxiliar + Empre")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("Valor Moeda2", "0,00", grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
################################################################################
# Inclusão de lançamento utilizando lançamento padrao gravando continuacao de historico
# https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T51979
################################################################################
def test_CTBA102_021(self):
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("D MG 01")
self.oHelper.SetValue("Data", "05/06/2015")
self.oHelper.SetValue("Lote", "LANPAD")
self.oHelper.SetValue("cPadrao", "003",name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("CT2_VALOR", "20.000,00",grid=True,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SearchBrowse(f"D MG 01 05/06/2015LANPAD001000001", "Filial+data Lcto + Numero Lote + Sub Lote + Numero Doc + Seq Auxiliar + Empre")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("Tipo Lcto", "Partida Dobrada", grid=True, line=1)
self.oHelper.CheckResult("CT2_DEBITO", "CTBA102PADD", grid=True, line=1)
self.oHelper.CheckResult("CT2_CREDIT", "CTBA102PADC", grid=True, line=1)
self.oHelper.CheckResult("CT2_VALOR", "20.000,00", grid=True, line=1)
self.oHelper.CheckResult("Tipo Lcto", "Cont.Hist", grid=True, line=2)
self.oHelper.CheckResult("Tipo Lcto", "Cont.Hist", grid=True, line=3)
self.oHelper.CheckResult("Tipo Lcto", "Cont.Hist", grid=True, line=4)
self.oHelper.CheckResult("Tipo Lcto", "Cont.Hist", grid=True, line=5)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGACTB/CTBA211TESTCASE.py
```python
from tir import Webapp
import unittest
class CTBA211(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGACTB", "30/06/2015", "T1", "M PR 02 ", "34")
inst.oHelper.Program("CTBA211")
###########################################################################################
# Caso de teste 001 - Incluir Rateio #
# 29/08/2019 #
###########################################################################################
def test_CTBA211_001(self):
self.oHelper.ClickTree("Apuracao de Lucros / Perdas > Perguntas")
#Perguntes
self.oHelper.SetValue("mv_par01", "01062015")
self.oHelper.SetValue("mv_par02", "30062015")
self.oHelper.SetValue("mv_par03", "APUR15")
self.oHelper.SetValue("mv_par04", "001")
self.oHelper.SetValue("mv_par05", "000001")
self.oHelper.SetValue("mv_par06", "001")
self.oHelper.SetValue("mv_par07", "CTB211ELC")
self.oHelper.SetValue("mv_par08", "CTB211ELD")
self.oHelper.SetValue("Moedas ?", "Todas") #Todas / Específica
self.oHelper.SetValue("mv_par10", "01")
self.oHelper.SetValue("Considera Ent.Ponte ?", "Sim")
self.oHelper.SetValue("mv_par12", "1")
self.oHelper.SetValue("Considera Entidades ?", "Rotina de Apur.")
self.oHelper.SetValue("mv_par14", "CTB211CP")
self.oHelper.SetValue("mv_par15", "CTB211CA")
self.oHelper.SetValue("mv_par16", "")
self.oHelper.SetValue("mv_par17", "")
self.oHelper.SetValue("mv_par18", "")
self.oHelper.SetValue("mv_par19", "")
self.oHelper.SetValue("mv_par20", "")
self.oHelper.SetValue("mv_par21", "")
self.oHelper.SetValue("mv_par22", "")
self.oHelper.SetValue("mv_par23", "ZZZZZZZZZ")
self.oHelper.SetValue("mv_par24", "")
self.oHelper.SetValue("mv_par25", "ZZZZZZZZZ")
self.oHelper.SetValue("mv_par26", "")
self.oHelper.SetValue("mv_par27", "ZZZZZZZZZ")
self.oHelper.SetValue("Reproces. Saldos ?", "Sim")#
self.oHelper.SetValue("Seleciona Filiais ?", "Sim")#
self.oHelper.SetValue("mv_par30", "M PR 02")
self.oHelper.SetValue("mv_par31", "M PR 02")
self.oHelper.ClickIcon("Iniciar Execução")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Sim")
self.oHelper.Program("CTBA211")
self.oHelper.AssertTrue()
def test_CTBA211_002(self):
self.oHelper.ClickTree("Apuracao de Lucros / Perdas > Perguntas")
#Perguntes
self.oHelper.SetValue("mv_par01", "01052014")
self.oHelper.SetValue("mv_par02", "31052014")
self.oHelper.SetValue("mv_par03", "")
self.oHelper.SetValue("mv_par04", "")
self.oHelper.SetValue("mv_par05", "")
self.oHelper.SetValue("mv_par06", "006")
self.oHelper.SetValue("mv_par07", "")
self.oHelper.SetValue("mv_par08", "")
self.oHelper.SetValue("Moedas ?", "Todas") #Todas / Específica
self.oHelper.SetValue("mv_par10", "")
self.oHelper.SetValue("Considera Ent.Ponte ?", "Sim")
self.oHelper.SetValue("mv_par12", "")
self.oHelper.SetValue("Considera Entidades ?", "Rotina de Apur.")
self.oHelper.SetValue("mv_par14", "")
self.oHelper.SetValue("mv_par15", "")
self.oHelper.SetValue("mv_par16", "")
self.oHelper.SetValue("mv_par17", "")
self.oHelper.SetValue("mv_par18", "")
self.oHelper.SetValue("mv_par19", "")
self.oHelper.SetValue("mv_par20", "")
self.oHelper.SetValue("mv_par21", "")
self.oHelper.SetValue("mv_par22", "")
self.oHelper.SetValue("mv_par23", "ZZZZZZZZZ")
self.oHelper.SetValue("mv_par24", "")
self.oHelper.SetValue("mv_par25", "ZZZZZZZZZ")
self.oHelper.SetValue("mv_par26", "")
self.oHelper.SetValue("mv_par27", "ZZZZZZZZZ")
self.oHelper.SetValue("Reproces. Saldos ?", "Sim")#
self.oHelper.SetValue("Seleciona Filiais ?", "Sim")#
self.oHelper.SetValue("mv_par30", "M PR 02")
self.oHelper.SetValue("mv_par31", "M PR 02")
self.oHelper.ClickIcon("Iniciar Execução")
self.oHelper.CheckHelp(text_help="CT210NOHP", button="Fechar")
self.oHelper.CheckHelp(text_help="NOCT210LOT", button="Fechar")
self.oHelper.CheckHelp(text_help="NOCTSUBLOT", button="Fechar")
self.oHelper.CheckHelp(text_help="NOCT210DOC", button="Fechar")
self.oHelper.CheckHelp(text_help="NOCT210CT", button="Fechar")
self.oHelper.CheckHelp(text_help="NO210TPSLD", button="Fechar")
self.oHelper.SetButton("Fechar")
self.oHelper.Program("CTBA211")
self.oHelper.AssertTrue()
def test_CTBA211_003(self):
self.oHelper.ClickTree("Apuracao de Lucros / Perdas > Perguntas")
#Perguntes
self.oHelper.SetValue("mv_par01", "")
self.oHelper.SetValue("mv_par02", "31052014")
self.oHelper.SetValue("mv_par03", "")
self.oHelper.SetValue("mv_par04", "")
self.oHelper.SetValue("mv_par05", "")
self.oHelper.SetValue("mv_par06", "")
self.oHelper.SetValue("mv_par07", "")
self.oHelper.SetValue("mv_par08", "")
self.oHelper.SetValue("Moedas ?", "Específica") #Todas / Específica
self.oHelper.SetValue("mv_par10", "01")
self.oHelper.SetValue("Considera Ent.Ponte ?", "Não")
self.oHelper.SetValue("mv_par12", "")
self.oHelper.SetValue("Considera Entidades ?", "Rotina de Apur.") #Cadastros
self.oHelper.SetValue("mv_par14", "")
self.oHelper.SetValue("mv_par15", "")
self.oHelper.SetValue("mv_par16", "")
self.oHelper.SetValue("mv_par17", "")
self.oHelper.SetValue("mv_par18", "")
self.oHelper.SetValue("mv_par19", "")
self.oHelper.SetValue("mv_par20", "")
self.oHelper.SetValue("mv_par21", "")
self.oHelper.SetValue("mv_par22", "")
self.oHelper.SetValue("mv_par23", "ZZZZZZZZZ")
self.oHelper.SetValue("mv_par24", "")
self.oHelper.SetValue("mv_par25", "ZZZZZZZZZ")
self.oHelper.SetValue("mv_par26", "")
self.oHelper.SetValue("mv_par27", "ZZZZZZZZZ")
self.oHelper.SetValue("Reproces. Saldos ?", "Sim")#
self.oHelper.SetValue("Seleciona Filiais ?", "Sim")#
self.oHelper.SetValue("mv_par30", "M PR 02")
self.oHelper.SetValue("mv_par31", "M PR 02")
self.oHelper.ClickIcon("Iniciar Execução")
self.oHelper.CheckHelp(text_help="CTHPVAZIO", button="Fechar")
self.oHelper.CheckHelp(text_help="NOCT210LOT", button="Fechar")
self.oHelper.CheckHelp(text_help="NOCTSUBLOT", button="Fechar")
self.oHelper.CheckHelp(text_help="NOCT210DOC", button="Fechar")
self.oHelper.CheckHelp(text_help="NOCT210CT", button="Fechar")
self.oHelper.CheckHelp(text_help="NO210TPSLD", button="Fechar")
self.oHelper.SetButton("Fechar")
self.oHelper.Program("CTBA211")
self.oHelper.AssertTrue()
def test_CTBA211_004(self):
self.oHelper.ClickTree("Apuracao de Lucros / Perdas > Perguntas")
#Perguntes
self.oHelper.SetValue("mv_par01", "01052014")
self.oHelper.SetValue("mv_par02", "31052014")
self.oHelper.SetValue("mv_par03", "")
self.oHelper.SetValue("mv_par04", "")
self.oHelper.SetValue("mv_par05", "")
self.oHelper.SetValue("mv_par06", "")
self.oHelper.SetValue("mv_par07", "")
self.oHelper.SetValue("mv_par08", "")
self.oHelper.SetValue("Moedas ?", "Específica") #Todas / Específica
self.oHelper.SetValue("mv_par10", "")
self.oHelper.SetValue("Considera Ent.Ponte ?", "Não")
self.oHelper.SetValue("mv_par12", "")
self.oHelper.SetValue("Considera Entidades ?", "Rotina de Apur.") #Cadastros
self.oHelper.SetValue("mv_par14", "")
self.oHelper.SetValue("mv_par15", "")
self.oHelper.SetValue("mv_par16", "")
self.oHelper.SetValue("mv_par17", "")
self.oHelper.SetValue("mv_par18", "")
self.oHelper.SetValue("mv_par19", "")
self.oHelper.SetValue("mv_par20", "")
self.oHelper.SetValue("mv_par21", "")
self.oHelper.SetValue("mv_par22", "")
self.oHelper.SetValue("mv_par23", "ZZZZZZZZZ")
self.oHelper.SetValue("mv_par24", "")
self.oHelper.SetValue("mv_par25", "ZZZZZZZZZ")
self.oHelper.SetValue("mv_par26", "")
self.oHelper.SetValue("mv_par27", "ZZZZZZZZZ")
self.oHelper.SetValue("Reproces. Saldos ?", "Sim")#
self.oHelper.SetValue("Seleciona Filiais ?", "Sim")#
self.oHelper.SetValue("mv_par30", "M PR 02")
self.oHelper.SetValue("mv_par31", "M PR 02")
self.oHelper.ClickIcon("Iniciar Execução")
self.oHelper.AssertTrue()
self.oHelper.WaitShow("NOMOEDA")
# self.oHelper.SetButton("Fechar")
self.oHelper.CheckHelp(text_help="NOMOEDA",button="Fechar")
# self.oHelper.CheckHelp(text_problem="Moeda não preenchida e/ou não existente.",button="Fechar")
self.oHelper.WaitShow("TOTVS")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/ACDA030TESTCASE.py
```python
from tir import Webapp
import unittest
#//-------------------------------------------------------------------
#/*/{Protheus.doc} ACDA030 - Mestre de Inventario
#
#@author <NAME>
#@since 17/10/2019
#@version 0.1
#/*/
#//-------------------------------------------------------------------
class ACDA030(unittest.TestCase):
@classmethod
def setUpClass(inst):
'''
SETUP
Test Case Initial Setup
'''
#Endereço do webapp e o nome do Browser
inst.oHelper = Webapp()
#Parametros de inicializacao
inst.oHelper.Setup("SIGAEST","17/10/2019","T1","D MG 01 ","04")
#Nome da rotina do Caso de Teste
inst.oHelper.Program("ACDA030")
def test_ACDA030_001(self):
#TIR001 - Inclusao simples de Mestre com Produto
#@author: <NAME>
#@date: 17/10/2019
self.oHelper.AddParameter("MV_INTACD", "D MG 01", "1", "1", "1")
self.oHelper.AddParameter("MV_CBPE012", "D MG 01", ".T.", ".T.", ".T.")
self.oHelper.SetParameters()
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("D MG 01 ")
self.oHelper.SetValue("Data", "17/10/2019")
self.oHelper.SetValue("Contagens", "1")
self.oHelper.SetValue("Almoxarifado", "01")
self.oHelper.SetValue("Tipo", "1 - Produto")
self.oHelper.SetValue("Produto", "ESTSE0000000000000000000002349")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_ACDA030_002(self):
#TIR002 - Alteracao simples de Mestre
#@author: <NAME>
#@date: 17/10/2019
self.oHelper.SearchBrowse("D MG 01 000000008", key="Filial+cod.invent.")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue("Produto", "ESTSE0000000000000000000006349")
self.oHelper.SetValue("Classe A", "1 - Sim")
self.oHelper.SetValue("Classe B", "1 - Sim")
self.oHelper.SetValue("Classe C", "1 - Sim")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
def test_ACDA030_003(self):
#TIR003 - Inclusao simples de Mestre com Endereco
#@author: <NAME>
#@date: 17/10/2019
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("D MG 01 ")
self.oHelper.SetValue("Data", "17/10/2019")
self.oHelper.SetValue("Contagens", "1")
self.oHelper.SetValue("Almoxarifado", "01")
self.oHelper.SetValue("Tipo", "2 - Endereco")
self.oHelper.SetValue("Endereco", "EST001")
self.oHelper.SetValue("Classe A", "1 - Sim")
self.oHelper.SetValue("Classe B", "1 - Sim")
self.oHelper.SetValue("Classe C", "1 - Sim")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_ACDA030_004(self):
#TIR004 - Visualizacao de Mestre
#@author: <NAME>
#@date: 17/10/2019
self.oHelper.SearchBrowse("D MG 01 000000009", key="Filial+cod.invent.")
self.oHelper.SetButton('Visualizar')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
def test_ACDA030_005(self):
#TIR005 - Exclusão simples de Mestre
#@author: <NAME>
#@date: 17/10/2019
self.oHelper.SearchBrowse(f"D MG 01 000000010", "Filial+cod.invent.")
self.oHelper.SetButton('Outras Ações','Excluir')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
def test_ACDA030_006(self):
#TIR006 - Relatorio - Legenda - Monitor -
#@author: <NAME>
#@date: 17/10/2019
self.oHelper.SearchBrowse("D MG 01 000000007", key="Filial+cod.invent.")
self.oHelper.SetButton('Outras Ações','Relatorio')
self.oHelper.SetButton('OK')
self.oHelper.SetButton('Sair')
self.oHelper.SetButton('Outras Ações','Legenda')
self.oHelper.SetButton('OK')
self.oHelper.SetButton('Fechar')
self.oHelper.SearchBrowse("D MG 01 000000001", key="Filial+cod.invent.")
self.oHelper.SetButton('Outras Ações','Monitor')
self.oHelper.SetButton('OK')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
def test_ACDA030_007(self):
#TIR007 - Automatico
#@author: <NAME>
#@date: 17/10/2019
self.oHelper.SearchBrowse("D MG 01 000000007", key="Filial+cod.invent.")
self.oHelper.SetButton('Outras Ações','Automatico')
self.oHelper.SetButton('OK')
self.oHelper.SetButton('OK')
self.oHelper.SetButton('OK')
self.oHelper.SetButton('OK')
self.oHelper.SetButton('OK')
self.oHelper.WaitShow('O numero de contagens nao pode ser igual ou inferior a zero, favor verificar !!!')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_ACDA030_008(self):
#TIR008 - Exclusão de Mestre - Status "Em Andamento"
#@author: <NAME>
#@date: 17/10/2019
self.oHelper.SearchBrowse(f"D MG 01 000000011", "Filial+cod.invent.")
self.oHelper.SetButton('Outras Ações','Excluir')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Sim')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
def test_ACDA030_009(self):
#TIR009 - Exclusão de Mestre - Status "Finalizado"
#@author: <NAME>
#@date: 17/10/2019
self.oHelper.SearchBrowse("D MG 01 000000012")
self.oHelper.SetButton('Outras Ações','Excluir')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Sim')
#self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
def test_ACDA030_010(self):
#TIR010 - Exclusão de Mestre - Inventário Não Finalizado
#@author: <NAME>
#@date: 17/10/2019
self.oHelper.SearchBrowse("D MG 01 000000013")
self.oHelper.SetButton('Outras Ações','Excluir')
self.oHelper.WaitShow('Nao e permitida a exclusao de Mestres de Inventario com contagens em andamento!!!')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_ACDA030_011(self):
#TIR011 - Exclusão de Mestre - Analise "Divergente"
#@author: <NAME>
#@date: 17/10/2019
self.oHelper.SearchBrowse("D MG 01 000000014")
self.oHelper.SetButton('Outras Ações','Excluir')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Sim')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
def test_ACDA030_012(self):
#TIR012 - Execução do acerto de inventário e tentativa de exclusão
#@author: <NAME>
#@date: 17/10/2019
self.oHelper.SearchBrowse("D MG 01 000000020")
self.oHelper.SetButton("Outras Ações","Monitor")
self.oHelper.SetValue("Atualiza Browse ?", "Não")
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Outras Ações","Executa Acerto de Inventario")
self.oHelper.SetButton("Sim")
#Validações após execução do acerto de inventário
self.oHelper.SearchBrowse("D MG 01 000000020")
self.oHelper.SetButton("Outras Ações","Excluir")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_ACDA030_013(self):
#TIR013 - GTSER-T51407 - Registros de Inventário no Monitor do ACD exibindo somente produtos relacionados
#@author: carlos.capeli
#@date: 27/05/2020
self.oHelper.SearchBrowse("D MG 01 000000024")
self.oHelper.SetButton("Outras Ações","Monitor")
self.oHelper.SetButton("OK")
self.oHelper.ClickFolder("Registros de Inventario")
self.oHelper.CheckResult("Produto","ACDACDA03000000000000000000001",grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
'''
Method that finishes the test case.
'''
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/FISA110ESTTESTCASE.py
```python
from tir import Webapp
import unittest
import time
#//-------------------------------------------------------------------
#@author <NAME>
#@since 31/08/2020
#@version 1.0
#/*/
#//-------------------------------------------------------------------
class FISA110(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAFIS","31/08/2020","T1","D MG 01")
inst.oHelper.Program("FISA110")
inst.oHelper.AddParameter("MV_CAT8309", "", ".T.", ".T.", ".T.")
inst.oHelper.SetParameters()
def test_FISA110_001(self):
#Definições dos perguntes iniciais
self.oHelper.SetValue('Data Inicial ?', '31/08/2020')
self.oHelper.SetValue('Data Final ?', '31/08/2020')
self.oHelper.SetValue('Seleciona Filiais ?', '2-Não')
self.oHelper.SetValue('Grv Doc.Entrada ?', '2-Não')
self.oHelper.SetValue('Grv Doc.Saídas ?', '2-Não')
self.oHelper.SetValue('Grv Mov.Interno ?', '1-Sim')
self.oHelper.SetValue('Sobrepõe ?', '1-Sim')
self.oHelper.SetButton("OK")
self.oHelper.WaitShow("Processo finalizado com Sucesso")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Finalizar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/MATA010TESTCASE.py
```python
from tir import Webapp
import unittest
import time
from datetime import datetime
DateSystem = datetime.today().strftime("%d/%m/%Y")
#//-------------------------------------------------------------------
#/*/{Protheus.doc} MATA010 - Inclusão e Visualização de Produto
#TABELA SB1
#
#@author <NAME>
#@since 04/17/2019
#@version 0.1
#/*/
#//-------------------------------------------------------------------
class MATA010(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAADV","25/11/2019","T1","D MG 01 ","04")
# inst.oHelper.Program("MATA010")
inst.oHelper.SetLateralMenu('Atualizações > Cadastros > Produto > Produtos')
def test_MATA010_001(self):
self.oHelper.AddParameter("MV_CADPROD", "","|SA5|SBZ|SB5|DH5|SGI|","|SA5|SBZ|SB5|DH5|SGI|","|SA5|SBZ|SB5|DH5|SGI|")
self.oHelper.AddParameter("MV_QALOGIX", "","0","0","0")
self.oHelper.AddParameter("MV_RASTRO", "","S","S","S")
self.oHelper.AddParameter("MV_LOCALIZ", "","S","S","S")
self.oHelper.SetParameters()
#Incluir/Visualização/Excluir
cod = 'ESTSE0001100221'
desc = 'MATA010TIR'
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("D MG 01 ")
self.oHelper.SetValue("B1_COD", cod)
self.oHelper.SetValue("B1_DESC",desc)
self.oHelper.SetValue("B1_TIPO",'PA')
self.oHelper.SetValue("B1_UM",'UN')
self.oHelper.SetValue("B1_LOCPAD",'01')
self.oHelper.SetValue("B1_LOCALIZ",'S')
self.oHelper.SetValue("B1_RASTRO",'L')
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Não")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("B1_COD", cod)
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton('Outras Ações','Excluir')
self.oHelper.CheckResult("B1_COD", cod)
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_MATA010_002(self):
#Incluir/Alterar/Excluir
cod2 = 'ESTSE0001200221'
desc2 = 'MATA010TIR'
descAlt = 'MATA010TIR ALTERADO'
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("D MG 01 ")
self.oHelper.SetValue("B1_COD", cod2)
self.oHelper.SetValue("B1_DESC",desc2)
self.oHelper.SetValue("B1_TIPO",'PA')
self.oHelper.SetValue("B1_UM",'UN')
self.oHelper.SetValue("B1_LOCPAD",'01')
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Não")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse(f"D MG 01 {cod2}", "Filial+codigo")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue("B1_DESC",descAlt)
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse(f"D MG 01 {cod2}", "Filial+codigo")
self.oHelper.SetButton('Outras Ações','Excluir')
self.oHelper.CheckResult("B1_COD", cod2)
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_MATA010_003(self):
#Incluir/Copia
cod3 = 'ESTSE0001300221'
cod31 = 'ESTSE0003100221'
desc3 = 'MATA010TIR'
desc31 = 'MATA010TIR COPIA'
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton('Ok')
self.oHelper.SetValue("B1_COD", cod3)
self.oHelper.SetValue("B1_DESC",desc3)
self.oHelper.SetValue("B1_TIPO",'PA')
self.oHelper.SetValue("B1_UM",'UN')
self.oHelper.SetValue("B1_LOCPAD",'01')
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Não")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse(f"D MG 01 {cod3}", "Filial+codigo")
self.oHelper.SetButton('Outras Ações','Copia')
self.oHelper.SetValue("B1_COD", cod31)
self.oHelper.SetValue("B1_DESC",desc31)
self.oHelper.SetValue("B1_TIPO",'PA')
self.oHelper.SetValue("B1_UM",'UN')
self.oHelper.SetValue("B1_LOCPAD",'01')
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Não")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_MATA010_004(self):
#Inclusao Preechendo B1/B5/A5/GI - MV_CADPROD - Alteração/Vizualização/Exclusão
self.oHelper.AddParameter("MV_CADPROD", "","|SA5|SBZ|SB5|DH5|SGI|","|SA5|SBZ|SB5|DH5|SGI|","|SA5|SBZ|SB5|DH5|SGI|")
self.oHelper.SetParameters()
cod = 'ESTSE0000000000000000000000T20'
desc = 'ESTSE0000000000000000000000T20'
cod2 = "ESTSE0000000000000000000000T19"
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("D MG 01 ")
self.oHelper.SetValue("B1_COD", cod)
self.oHelper.SetValue("B1_DESC",desc)
self.oHelper.F3(field='B1_TIPO',name_attr=True,send_key=True)
self.oHelper.SearchBrowse(f'PA', 'Código')
self.oHelper.SetButton('Ok')
self.oHelper.F3(field='B1_UM', name_attr=True,send_key=True)
self.oHelper.SearchBrowse(f'UN', 'Código')
self.oHelper.SetButton('Ok')
self.oHelper.F3(field='B1_LOCPAD', name_attr=True,send_key=True)
self.oHelper.SetButton('Ok')
self.oHelper.SetValue("B1_CONV", "1,00")
self.oHelper.SetValue("B1_PRV1", "1,00")
self.oHelper.SetValue("B1_CUSTD", "1,00")
self.oHelper.SetValue("B1_UPRC", "1,00")
self.oHelper.SetValue("B5_CEME",cod)
self.oHelper.ClickGridCell("Fornecedor", 1)
self.oHelper.SetValue("A5_FORNECE","FORN01", grid=True)
self.oHelper.LoadGrid()
self.oHelper.ClickGridCell("Alternativo", 1, grid_number=2)
self.oHelper.SetValue("GI_PRODALT",cod2, grid=True, grid_number=2)
self.oHelper.LoadGrid()
self.oHelper.ClickFolder("Impostos")
self.oHelper.SetValue("B1_PICM", "1,00")
self.oHelper.SetValue("B1_IPI", "1,00")
self.oHelper.SetValue("B1_ORIGEM", "1")
self.oHelper.ClickFolder("MRP / Suprimentos")
self.oHelper.SetValue("B1_QE", "1.00")
self.oHelper.ClickFolder("C.Q.")
self.oHelper.SetValue("B1_NOTAMIN", "1")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Não")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue("B1_DESC","ALTERADO")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton('Outras Ações','Excluir')
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_MATA010_005(self):
#Incluir/Visualização/Excluir
cod = 'ESTSE00000000000000000023750PA'
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue("B1_LOCALIZ",'S')
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("B1_LOCALIZ", 'S')
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_MATA010_006(self):
cod = 'ESTSE0000000000000000000000001'
cod2 = 'ESTSE0000000000000000000000002'
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton('Outras Ações','Alternativos')
self.oHelper.SetValue("Alternativo",cod2, grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.AssertTrue()
def test_MATA010_007(self):
cod = 'ESTSE0000000000000000000000001'
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton('Outras Ações','Facilitador')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
def test_MATA010_008(self):
self.oHelper.AddParameter("MV_HISTFIS", "",".T.",".T.",".T.")
self.oHelper.SetParameters()
cod = 'EST000000000000000000000000016'
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton('Alterar')
self.oHelper.SetButton('Outras Ações','Opcionais')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Outras Ações','Histórico')
self.oHelper.SetButton('Sair')
self.oHelper.AssertTrue()
def test_MATA010_009(self):
cod = 'EST000000000000000000000000016'
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton('Outras Ações','Consulta')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
def test_MATA010_010(self):
cod = 'EST000000000000000000000000016'
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
time.sleep(5)
self.oHelper.SetKey("F4")
self.oHelper.SetButton("Voltar")
self.oHelper.AssertTrue()
def test_MATA010_011(self):
# self.oHelper.AddParameter("MV_QALOGIX", "","0","0","0")
# self.oHelper.SetParameters()
cod = 'ESTSE0000000000000000000000420'
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue("Forn. Padrao", "")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_MATA010_012(self):
cod = 'ESTSE0000000000000000000009999'
desc = 'PROD COM COD BARRA'
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("D MG 01 ")
self.oHelper.SetValue("B1_COD", cod)
self.oHelper.SetValue("B1_DESC",desc)
self.oHelper.SetValue("B1_TIPO",'PA')
self.oHelper.SetValue("B1_UM",'UN')
self.oHelper.SetValue("B1_LOCPAD",'01')
self.oHelper.SetValue("B1_CODBAR", "1635")
self.oHelper.SetValue("B1_CODGTIN", "1635")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Não")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_MATA010_013(self):
self.oHelper.AddParameter("MV_QALOGIX", "","1","1","1")
self.oHelper.SetParameters()
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_MATA010_014(self):
time.sleep(5)
self.oHelper.SetButton("x")
time.sleep(5)
self.oHelper.ChangeEnvironment("25/11/2019", "T1","D MG 01 ","73")
time.sleep(10)
self.oHelper.SetLateralMenu('Atualizações > Administração > Portfólio > Produtos')
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Outras Ações", "Relacionadas, Conhecimento")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_MATA010_015(self):
self.oHelper.AddParameter("MV_EIC0011", "",".T.",".T.",".T.")
self.oHelper.SetParameters()
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("25/11/2019", "T1","D MG 01 ","17")
time.sleep(10)
self.oHelper.SetLateralMenu('Atualizações > Cadastros > Produtos')
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_MATA010_016(self):
self.oHelper.AddParameter("MV_QALOGIX", "","0","0","0")
self.oHelper.SetParameters()
cod = 'ESTSE0000000000000000000000422'
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_MATA010_017(self):
cod = 'ESTSE0000000000000000000000423'
self.oHelper.AddParameter("MV_QALOGIX", "","0","0","0")
self.oHelper.SetParameters()
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("25/11/2019", "T1","D MG 01 ","17")
time.sleep(10)
self.oHelper.SetLateralMenu('Atualizações > Cadastros > Produtos')
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_MATA010_018(self):
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("D MG 01 ")
self.oHelper.SetValue("B1_COD", "DMANMAT01-26543PROD00000000001")
self.oHelper.SetValue("B1_DESC", "DMANMAT01-26543PROD00000000001")
self.oHelper.SetValue("B1_TIPO", "PA")
self.oHelper.SetValue("B1_UM", "UN")
self.oHelper.SetValue("B1_LOCPAD", "01")
self.oHelper.SetValue("B1_PROC", "ESTBLQ")
self.oHelper.SetValue("B1_LOJPROC", "01")
self.oHelper.SetButton("Confirmar")
self.oHelper.WaitShow("REGBLOQ")
self.oHelper.CheckHelp(text_help="REGBLOQ", button="Fechar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Sair da página")
self.oHelper.AssertTrue()
def test_MATA010_019(self):
#GTSER-T49508
#Consulta padrao de armazem e ncm
cod = 'ESTSE0000000000000000000000427'
desc = 'ESTSE0000000000000000000000427'
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("D MG 01 ")
self.oHelper.SetValue("B1_COD", cod)
self.oHelper.SetValue("B1_DESC",desc)
self.oHelper.SetValue("B1_TIPO",'PA')
self.oHelper.SetValue("B1_UM",'UN')
#consulta padrao armazem
self.oHelper.SetFocus("B1_LOCPAD")
self.oHelper.SetKey("F3")
self.oHelper.SearchBrowse("02")
self.oHelper.SetButton("OK")
#Consulta padrao ncm
self.oHelper.ClickFolder("Impostos")
self.oHelper.SetFocus("B1_POSIPI")
self.oHelper.SetKey("F3")
self.oHelper.SearchBrowse("01019090")
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Não")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("B1_COD", cod)
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_MATA010_020(self):
#GTSER-T28892
#Incluir/Visualização/Excluir
cod = 'ESTSE0000000092'
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment(DateSystem, "T1","D MG 01 ","04")
self.oHelper.SetLateralMenu('Atualizações > Cadastros > Produto > Produtos')
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton("Alterar")
self.oHelper.ClickFolder("Impostos")
self.oHelper.SetButton("Outras Ações","Opcionais")
self.oHelper.ClickBox("Grupos/Itens Opcionais","01 - OPCIONAL 01")
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Confirmar")
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("B1_OPC", '7701 /')
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
'''
Method that finishes the test case.
'''
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/MATA037TESTCASE.py
```python
from tir import Webapp
import unittest
import time
class MATA037(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAEST','13/11/2019','T1','D MG 01')
inst.oHelper.Program('MATA037')
def test_MAT037_001(self):
self.oHelper.SearchBrowse("D MG 01 EST023")
self.oHelper.SetButton("Carregar")
self.oHelper.SetValue("Cliente","EST006", grid=True, grid_number=2)
self.oHelper.SetValue("Loja","01", grid=True, grid_number=2)
self.oHelper.SetValue("Quantidade","80,00", grid=True, grid_number=2)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/MATA220TESTCASE.py
```python
from tir import Webapp
import unittest
import time
class MATA220(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAEST','20/09/2019','T1','D MG 01')
inst.oHelper.Program('MATA220')
def test_MAT220_001(self):
self.oHelper.AddParameter("MV_GRADE", "", ".T.", ".T.", ".T.")
self.oHelper.SetParameters()
self.oHelper.SetButton('Incluir')
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('Produto','ESTMATA220GRADETIR00000000')
self.oHelper.SetValue('Armazem','01')
self.oHelper.SetValue('Qtd.Inic.Mes','50,00')
self.oHelper.SetValue('[BR] BRANCO','50,00', grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.SetValue('Qt.Ini.2a UM','800,00')
self.oHelper.SetValue('[BR] BRANCO','800,00', grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Outras Ações', 'Inf. lote')
self.oHelper.SetValue('Lote','0000000001', grid=True, grid_number=2)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
def test_MAT220_002(self):
self.oHelper.AddParameter("MV_GRADE", "", ".F.", ".F.", ".F.")
self.oHelper.SetParameters()
self.oHelper.SetButton('Incluir')
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('Produto','ESTMATA220TIR00000000000000000')
self.oHelper.SetValue('Armazem','01')
self.oHelper.SetValue('Qtd.Inic.Mes','100,00')
self.oHelper.SetButton('Outras Ações', 'Inf. lote')
self.oHelper.SetValue('Lote','0000000001', grid=True)
self.oHelper.SetValue('Potência','5,00', grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
def test_MAT220_003(self):
self.oHelper.SearchBrowse("D MG 01 ESTMATA220TIR00000000000000001")
self.oHelper.SetButton('Visualizar')
self.oHelper.CheckResult('Produto','ESTMATA220TIR00000000000000001')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
def test_MAT220_004(self):
self.oHelper.SearchBrowse("D MG 01 ESTSE0000000000000000000009003")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('Qtd.Inic.Mes','101,00')
self.oHelper.SetButton('Salvar')
self.oHelper.AssertTrue()
def test_MAT220_005(self):
self.oHelper.SearchBrowse("D MG 01 ESTMATA220TIR00000000000000003")
self.oHelper.SetButton('Outras Ações', 'Excluir')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
#CT006 INCLUIR SALDO INICIAL PARA PRODUTO EMPENHADO EM OP
#@author <NAME>
#@since 26/11/2019
#@version 1.0
#
def test_MAT220_006(self):
self.oHelper.AddParameter("MV_RASTRO", "", "S", "S", "S")
self.oHelper.AddParameter("MV_LOCALIZ", "", "S", "S", "S")
self.oHelper.SetParameters()
self.oHelper.SetButton('Incluir')
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('Produto','ESTSE0000000000000000000009001')
self.oHelper.SetValue('Armazem','01')
self.oHelper.SetValue('Qtd.Inic.Mes','10,00')
self.oHelper.SetButton('Outras Ações', 'Inf. lote')
self.oHelper.SetValue('Lote','X', grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Cancelar')
self.oHelper.SetButton("X")
self.oHelper.Program("MATA390")
self.oHelper.SearchBrowse("D MG 01 ESTSE000000000000000000000900101X",key='Filial+produto + Armazem + Lote +...')
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("B8_PRODUTO", "ESTSE0000000000000000000009001")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("X")
self.oHelper.Program("MATA265")
self.oHelper.SearchBrowse("D MG 01 ESTSE000000000000000000000900101X",key='Filial+produto + Armazem + Lote')
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("DA_PRODUTO", "ESTSE0000000000000000000009001")
self.oHelper.CheckResult("DA_SALDO", "10,00")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("X")
self.oHelper.Program("MATA220")
self.oHelper.SetButton("X")
self.oHelper.AssertTrue()
#CT007 Valida se quantidade fisica e igual ao saldo do lote
#@author <NAME>
#@since 11/12/2019
#@version 1.
#
def test_MAT220_007(self):
self.oHelper.AddParameter("MV_RASTRO", "", "S", "S", "S")
self.oHelper.SetParameters()
self.oHelper.SetButton('Incluir')
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('Produto','ESTSE0000000000000000000000589')
self.oHelper.SetValue('Armazem','01')
self.oHelper.SetValue('Qtd.Inic.Mes','999999999,99')
self.oHelper.SetButton('Outras Ações', 'Inf. lote')
self.oHelper.CheckResult("Quantidade", "999999999,99", grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Cancelar')
self.oHelper.SetButton('Cancelar')
self.oHelper.SetButton("X")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/MATA265TESTCASE.py
```python
from tir import Webapp
import unittest
import time
#//-------------------------------------------------------------------
#/*/{Protheus.doc} MATA265 - Endereçamento
#TABELA sda sdb
#
#@author <NAME>
#@since 13/09/2019
#@version 0.1
#/*/
#//-------------------------------------------------------------------
class MATA265(unittest.TestCase):
@classmethod
def setUpClass(inst):
'''
SETUP
Test Case Initial Setup
'''
#Endereço do webapp e o nome do Browser
inst.oHelper = Webapp()
#Parametros de inicializaçao
inst.oHelper.Setup("SIGAEST","13/09/2019","T1","D MG 01 ","04")
#Nome da rotina do Caso de Teste
inst.oHelper.Program("MATA265")
#CT001 ENDEREÇAR COM GERAÇAO DE NUMERO DE SERIE
def test_MATA265_001(self):
#Variaveis de inclusar
prod = 'ESTSE0000000000000000000000554'
endereco = 'ENDSE01'
filial = 'D MG 01 '
seqserie = 'MATA265001'
self.oHelper.SearchBrowse(f"{filial}{prod}", "Filial+produto + Armazem + Sequen..")
self.oHelper.SetButton("EnDerecar")
time.sleep(3)
self.oHelper.SetButton('Outras Ações','Gerar Números de Série')
self.oHelper.SetValue("Endereco", endereco)
self.oHelper.SetValue("Valor Inicial:",seqserie)
self.oHelper.SetButton("Confirmar")
self.oHelper.CheckResult('DB_NUMSERI','MATA265001', grid=True, line=1)
self.oHelper.CheckResult('DB_NUMSERI','MATA265002', grid=True, line=2)
self.oHelper.CheckResult('DB_NUMSERI','MATA265003', grid=True, line=3)
self.oHelper.CheckResult('DB_NUMSERI','MATA265004', grid=True, line=4)
self.oHelper.CheckResult('DB_NUMSERI','MATA265005', grid=True, line=5)
self.oHelper.CheckResult('DB_NUMSERI','MATA265006', grid=True, line=6)
self.oHelper.CheckResult('DB_NUMSERI','MATA265007', grid=True, line=7)
self.oHelper.CheckResult('DB_NUMSERI','MATA265008', grid=True, line=8)
self.oHelper.CheckResult('DB_NUMSERI','MATA265009', grid=True, line=9)
self.oHelper.CheckResult('DB_NUMSERI','MATA26500A', grid=True, line=10)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
'''
Method that finishes the test case.
'''
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/MATA310TESTCASE.py
```python
from tir import Webapp
import unittest
import time
class MATA310(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAEST','','T1','D MG 01','04')
inst.oHelper.Program('MATA310')
def test_MATA310_001(self):
self.oHelper.SetValue('De produto ? ','ESTSE0000000000000000000000354')
self.oHelper.SetValue('Ate produto ?','ESTSE0000000000000000000000354')
self.oHelper.SetValue('Ate filial ?','D RJ 01')
self.oHelper.SetValue('Ate armazem ?','02')
self.oHelper.SetValue('Ate tipo ?','ZZ')
self.oHelper.SetValue('Ate grupo ?','9999')
self.oHelper.SetValue('Filtra produtos por categ. ? ', 'Nao')
self.oHelper.SetValue('Quebra informacoes ?','Por armazem')
self.oHelper.SetValue('TES para notas de saida ?','549')
self.oHelper.SetValue('Gera documento de entrada ?','Classificado')
self.oHelper.SetValue('TES para notas de entrada ?','400')
self.oHelper.SetValue('Condicao de pagamento ?','101')
self.oHelper.SetValue('Considera como preco no PV ?','Tabela de Preco')
self.oHelper.SetValue('Dados da origem ?','Todas filiais')
self.oHelper.SetValue('Utilizar Saldo de Terceiros ?','Nao')
self.oHelper.SetValue('Espécie documento de entrada ?','NF')
self.oHelper.SetValue('Descrição de produtos ?','Não')
self.oHelper.SetValue('Informa prod. manualmente ?','Não')
self.oHelper.SetValue('Abre tela da nota de entrada ?','Não')
self.oHelper.SetButton('OK')
self.oHelper.ClickTree('Filial D MG 01 Filial BELO HOR > Armazem 01 > ESTSE0000000000000000000000354 - 100,00')
self.oHelper.ClickTree('Filial D RJ 01 Filial RIO DE J', position=2)
self.oHelper.ClickTree('Armazem 01 > ESTSE0000000000000000000000354 - 0,00', position=0)
self.oHelper.SetButton('Outras Ações', 'Relacao')
self.oHelper.SetValue('Lote','LOTE01')
self.oHelper.SetValue('Endereço','ENDSE01')
self.oHelper.SetValue('Quantidade','10,00')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('OK')
time.sleep(50)
self.oHelper.Program('MATA310')
self.oHelper.AssertTrue()
def test_MATA310_002(self):
self.oHelper.SetValue('De produto ? ','ESTSE0000000000000000000000363')
self.oHelper.SetValue('Ate produto ?','ESTSE0000000000000000000000363')
self.oHelper.SetValue('Ate filial ?','D RJ 01')
self.oHelper.SetValue('Ate armazem ?','02')
self.oHelper.SetValue('Ate tipo ?','ZZ')
self.oHelper.SetValue('Ate grupo ?','9999')
self.oHelper.SetValue('Filtra produtos por categ. ? ', 'Nao')
self.oHelper.SetValue('Quebra informacoes ?','Por armazem')
self.oHelper.SetValue('TES para notas de saida ?','549')
self.oHelper.SetValue('Gera documento de entrada ?','Classificado')
self.oHelper.SetValue('TES para notas de entrada ?','400')
self.oHelper.SetValue('Condicao de pagamento ?','101')
self.oHelper.SetValue('Considera como preco no PV ?','Tabela de Preco')
self.oHelper.SetValue('Dados da origem ?','Todas filiais')
self.oHelper.SetValue('Utilizar Saldo de Terceiros ?','Nao')
self.oHelper.SetValue('Espécie documento de entrada ?','NF')
self.oHelper.SetValue('Descrição de produtos ?','Não')
self.oHelper.SetValue('Informa prod. manualmente ?','Não')
self.oHelper.SetValue('Abre tela da nota de entrada ?','Não')
self.oHelper.SetButton('OK')
self.oHelper.ClickTree('Filial D MG 01 Filial BELO HOR > Armazem 01 > ESTSE0000000000000000000000363 - 100,00')
self.oHelper.ClickTree('Filial D RJ 01 Filial RIO DE J', position=2)
self.oHelper.ClickTree('Armazem 01 > ESTSE0000000000000000000000363 - 0,00', position=0)
self.oHelper.SetButton('Outras Ações', 'Relacao')
self.oHelper.SetValue('Lote', 'LOTE01')
self.oHelper.SetValue('Endereço', 'ENDSE01')
self.oHelper.SetValue('Quantidade', '10,00')
self.oHelper.SetButton('Confirmar')
time.sleep(10)
self.oHelper.SetButton('Outras Ações', 'Estorno')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Sim')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Cancelar')
self.oHelper.Program('MATA310')
self.oHelper.AssertTrue()
def test_MATA310_003(self):
self.oHelper.SetValue('De produto ? ', 'ESTSE0000000000000000000000363')
self.oHelper.SetValue('Ate produto ?','ESTSE0000000000000000000000363')
self.oHelper.SetValue('Ate filial ?','D RJ 01')
self.oHelper.SetValue('Ate armazem ?','02')
self.oHelper.SetValue('Ate tipo ?','ZZ')
self.oHelper.SetValue('Ate grupo ?','9999')
self.oHelper.SetValue('Filtra produtos por categ. ? ', 'Nao')
self.oHelper.SetValue('Quebra informacoes ?','Por armazem')
self.oHelper.SetValue('TES para notas de saida ?','549')
self.oHelper.SetValue('Gera documento de entrada ?','Classificado')
self.oHelper.SetValue('TES para notas de entrada ?','400')
self.oHelper.SetValue('Condicao de pagamento ?','101')
self.oHelper.SetValue('Considera como preco no PV ?','Tabela de Preco')
self.oHelper.SetValue('Dados da origem ?','Todas filiais')
self.oHelper.SetValue('Utilizar Saldo de Terceiros ?','Nao')
self.oHelper.SetValue('Espécie documento de entrada ?','NF')
self.oHelper.SetValue('Descrição de produtos ?','Não')
self.oHelper.SetValue('Informa prod. manualmente ?','Não')
self.oHelper.SetValue('Abre tela da nota de entrada ?','Não')
self.oHelper.SetButton('OK')
self.oHelper.ClickTree('Filial D MG 01 Filial BELO HOR > Armazem 01 > ESTSE0000000000000000000000363 - 100,00')
self.oHelper.ClickTree('Filial D RJ 01 Filial RIO DE J', position=2)
self.oHelper.ClickTree('Armazem 01 > ESTSE0000000000000000000000363 - 0,00', position=0)
self.oHelper.SetButton('Outras Ações', 'Relacao')
self.oHelper.SetValue('Lote', 'LOTE01')
self.oHelper.SetValue('Endereço', 'ENDSE01')
self.oHelper.SetValue('Quantidade', '10,00')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Outras Ações', 'Itens')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Outras Ações', 'Legenda')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Outras Ações', 'Pesquisar')
self.oHelper.SetButton('Cancelar')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
self.oHelper.Finish()
def test_MATA310_004(self):
if self.oHelper.GetRelease() >= '12.1.030':
self.oHelper.AddParameter("MV_TRFVLDP", "","2","2","2")
self.oHelper.SetParameters()
self.oHelper.SetValue('De produto ? ', 'ESTSE0000000000000000000000962')
self.oHelper.SetValue('Ate produto ?','ESTSE000000000000964')
self.oHelper.SetValue('Ate filial ?','D RJ 01')
self.oHelper.SetValue('Ate armazem ?','02')
self.oHelper.SetValue('Ate tipo ?','ZZ')
self.oHelper.SetValue('De grupo ?','TRF')
self.oHelper.SetValue('Ate grupo ?','TRF')
self.oHelper.SetValue('Filtra produtos por categ. ? ', 'Nao')
self.oHelper.SetValue('Quebra informacoes ?','Por armazem')
self.oHelper.SetValue('TES para notas de saida ?','549')
self.oHelper.SetValue('Gera documento de entrada ?','Classificado')
self.oHelper.SetValue('TES para notas de entrada ?','400')
self.oHelper.SetValue('Condicao de pagamento ?','101')
self.oHelper.SetValue('Considera como preco no PV ?','C Unitario')
self.oHelper.SetValue('Dados da origem ?','Todas filiais')
self.oHelper.SetValue('Utilizar Saldo de Terceiros ?','Nao')
self.oHelper.SetValue('Espécie documento de entrada ?','NF')
self.oHelper.SetValue('Descrição de produtos ?','Não')
self.oHelper.SetValue('Informa prod. manualmente ?','Não')
self.oHelper.SetValue('Abre tela da nota de entrada ?','Não')
self.oHelper.SetButton('OK')
self.oHelper.ClickTree('Filial D MG 01 Filial <NAME> > Armazem 01 > ESTSE000000000000964 - 10.000,00')
self.oHelper.ClickTree('Filial D RJ 01 Filial RIO DE J', position=2)
self.oHelper.ClickTree('Armazem 01 > ESTSE0000000000000000000000964 - 0,00', position=0)
self.oHelper.SetButton('Outras Ações', 'Relacao')
self.oHelper.SetValue('Quantidade', '100,00')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('OK')
time.sleep(50)
self.oHelper.Program('MATA310')
self.oHelper.AssertTrue()
self.oHelper.Finish()
def test_MATA310_005(self):
if self.oHelper.GetRelease() >= '12.1.030':
self.oHelper.AddParameter("MV_TRFVLDP", "","3","3","3")
self.oHelper.SetParameters()
self.oHelper.SetValue('De produto ? ', 'ESTSE0000000000000000000000962')
self.oHelper.SetValue('Ate produto ?','ESTSE0000000000000000000000963')
self.oHelper.SetValue('Ate filial ?','D RJ 01')
self.oHelper.SetValue('Ate armazem ?','02')
self.oHelper.SetValue('Ate tipo ?','ZZ')
self.oHelper.SetValue('De grupo ?','TRF5')
self.oHelper.SetValue('Ate grupo ?','TRF5')
self.oHelper.SetValue('Filtra produtos por categ. ? ', 'Nao')
self.oHelper.SetValue('Quebra informacoes ?','Por armazem')
self.oHelper.SetValue('TES para notas de saida ?','549')
self.oHelper.SetValue('Gera documento de entrada ?','Classificado')
self.oHelper.SetValue('TES para notas de entrada ?','400')
self.oHelper.SetValue('Condicao de pagamento ?','101')
self.oHelper.SetValue('Considera como preco no PV ?','C Unitario')
self.oHelper.SetValue('Dados da origem ?','Todas filiais')
self.oHelper.SetValue('Utilizar Saldo de Terceiros ?','Nao')
self.oHelper.SetValue('Espécie documento de entrada ?','NF')
self.oHelper.SetValue('Descrição de produtos ?','Não')
self.oHelper.SetValue('Informa prod. manualmente ?','Não')
self.oHelper.SetValue('Abre tela da nota de entrada ?','Não')
self.oHelper.SetButton('OK')
self.oHelper.ClickTree('Filial D MG 01 Filial BELO HOR > Armazem 01 > ESTSE0000000000000000000000962 - 10.000,00')
self.oHelper.ClickTree('Filial D RJ 01 Filial RIO DE J', position=2)
self.oHelper.ClickTree('Armazem 01 > ESTSE0000000000000000000000963 - 0,00', position=0)
self.oHelper.SetButton('Outras Ações', 'Relacao')
self.oHelper.SetValue('Quantidade', '100,00')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('OK')
time.sleep(50)
self.oHelper.Program('MATA310')
self.oHelper.AssertTrue()
self.oHelper.Finish()
def test_MATA310_006(self):
self.oHelper.AddParameter("MV_M310TRV", "", ".T.", ".T.", ".T.")
self.oHelper.SetParameters()
self.oHelper.SetValue('De produto ? ','EST000000000000000000000000025')
self.oHelper.SetValue('Ate produto ?','EST000000000000000000000000025')
self.oHelper.SetValue('Ate filial ?','D RJ 01')
self.oHelper.SetValue('Ate armazem ?','98')
self.oHelper.SetValue('Ate tipo ?','ZZ')
self.oHelper.SetValue('Ate grupo ?','9999')
self.oHelper.SetValue('Filtra produtos por categ. ? ', 'Nao')
self.oHelper.SetValue('Quebra informacoes ?','Por armazem')
self.oHelper.SetValue('TES para notas de saida ?','672')
self.oHelper.SetValue('Gera documento de entrada ?','Classificado')
self.oHelper.SetValue('TES para notas de entrada ?','072')
self.oHelper.SetValue('Condicao de pagamento ?','001')
self.oHelper.SetValue('Considera como preco no PV ?','C Unitario')
self.oHelper.SetValue('Dados da origem ?','Todas filiais')
self.oHelper.SetValue('Utilizar Saldo de Terceiros ?','Nao')
self.oHelper.SetValue('Espécie documento de entrada ?','NF')
self.oHelper.SetValue('Descrição de produtos ?','Não')
self.oHelper.SetValue('Informa prod. manualmente ?','Não')
self.oHelper.SetValue('Abre tela da nota de entrada ?','Não')
self.oHelper.SetButton('OK')
self.oHelper.ClickTree('Filial D MG 01 <NAME> > Armazem 98 > EST000000000000000000000000025 - 100,00')
self.oHelper.ClickTree('Filial D MG 02 <NAME>', position=2)
self.oHelper.ClickTree('Armazem 98 > EST000000000000000000000000025 - 0,00', position=0)
self.oHelper.SetButton('Outras Ações', 'Relacao')
self.oHelper.SetButton('Outras Ações', 'Consulta Saldo CQ')
self.oHelper.SetButton('OK')
self.oHelper.SetValue('Quantidade','10,00')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('OK')
time.sleep(50)
self.oHelper.Program('MATA310')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/MATA311TESTCASE.py
```python
from tir import Webapp
import unittest
import time
class MATA311(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAEST','21/01/2021','T1','D MG 01')
inst.oHelper.Program('MATA311')
def test_MAT311_001(self):
self.oHelper.SearchBrowse("D MG 01 0000000010")
self.oHelper.SetButton('Outras Ações', 'Copia')
self.oHelper.CheckResult("NNS_DATA", "21/01/2021")
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Sair da página')
self.oHelper.AssertTrue()
def test_MAT311_002(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch("D MG 01 ")
time.sleep(1)
self.oHelper.ClickGridCell("Produto", 1)
self.oHelper.SetValue("Produto","ESTSE0000000000000000000001152",grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetFocus("Endereço", grid_cell=True, row_number=1)
time.sleep(1)
self.oHelper.SetKey("F4",grid=True)
self.oHelper.SetButton("Ok")
time.sleep(2)
self.oHelper.SetKey("ENTER",grid=True)
self.oHelper.LoadGrid()
self.oHelper.CheckResult("Lote","LOTE001",grid=True)
self.oHelper.LoadGrid()
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/MATA340TESTCASE.py
```python
from tir import Webapp
import unittest
import time
#//-------------------------------------------------------------------
#/*/{Protheus.doc} MATA340 - ACERTO DE INVENTARIO
#
#@author <NAME>
#@since 29/10/2019
#@version 1.0
#/*/
#//-------------------------------------------------------------------
class MATA340(unittest.TestCase):
@classmethod
def setUpClass(inst):
'''
SETUP
Test Case Initial Setup
'''
#Endereco do webapp e o nome do Browser
inst.oHelper = Webapp()
#Parametros de inicializacao
inst.oHelper.Setup("SIGAEST","15/01/2020","T1","D MG 01 ","04")
#Nome da rotina do Caso de Teste
inst.oHelper.Program("MATA340")
def test_MATA340_001(self):
#MATA340 - CT021: Produto com Endereco e Numero de Serie
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Detalhes")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Sair")
self.oHelper.SetButton("Parâmetros")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Ok")
time.sleep(22)
self.oHelper.AssertTrue()
def test_MATA340_002(self):
#MATA340 - Verifica se a tela de estornar reserva esta sendo apresentada
self.oHelper.AddParameter("MV_RESORD","","1", "1", "1")
self.oHelper.AddParameter("MV_RESSEQ","","1", "1", "1")
self.oHelper.AddParameter("MV_M340THR","","", "", "")
self.oHelper.AddParameter("MV_DELRES","",".T.", ".T.", ".T.")
self.oHelper.AddParameter("MV_ESTNEG","","N", "N", "N")
self.oHelper.AddParameter("MV_LIBNODP","","S", "S", "S")
self.oHelper.AddParameter("MV_RESEST","",".T.", ".T.", ".T.")
self.oHelper.SetParameters()
self.oHelper.SetButton("Parâmetros")
self.oHelper.SetValue("Data de Selecao ?","15/01/2020")
self.oHelper.SetValue("Mostra Lanctos. Contabeis ?","Nao")
self.oHelper.SetValue("Aglutina Lanctos. Contabeis ?","Nao")
self.oHelper.SetValue("Do Produto ?","ESTSE0000000000000000000000381")
self.oHelper.SetValue("Ate o Produto ?","ESTSE0000000000000000000000381")
self.oHelper.SetValue("Do Armazem ?","01")
self.oHelper.SetValue("Ate o Armazem ?","01")
self.oHelper.SetValue("Do Grupo ?","")
self.oHelper.SetValue("Ate o Grupo ?","ZZZ")
self.oHelper.SetValue("Do Documento ?","ESTSEX")
self.oHelper.SetValue("Ate o Documento ?","ESTSEX")
self.oHelper.SetValue("Considera os Empenhos ?","Todos")
self.oHelper.SetValue("Atualiza Saldo do Fechamento ?","Nao")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Ajustes - Acerto do Inventario")
time.sleep(15)
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
'''
Method that finishes the test case.
'''
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/MATA550TESTCASE.py
```python
from tir import Webapp
import unittest
import time
#//-------------------------------------------------------------------
#/*/{Protheus.doc} MATA550 - Inclusão e Visualização de Produto
#TABELA SB4
#
#@author <NAME>
#@since 20/09/2010
#@version 0.1
#/*/
#//-------------------------------------------------------------------
class MATA550(unittest.TestCase):
@classmethod
def setUpClass(inst):
'''
SETUP
Test Case Initial Setup
'''
#Endereço do webapp e o nome do Browser
inst.oHelper = Webapp()
#Parametros de inicializaçao
inst.oHelper.Setup("SIGAEST","20/09/2019","T1","D MG 01 ","04")
#Nome da rotina do Caso de Teste
inst.oHelper.Program("MATA550")
def test_MATA550_001(self):
#Incluir
cod = 'ESTSEGRADE01'
desc = 'MATA550TIR'
tipo = 'PA'
unidade = 'UN'
armazem = '01'
linha = '12'
coluna = '13'
self.oHelper.SetButton("Incluir")
time.sleep(1)
self.oHelper.SetButton("OK")
self.oHelper.SetValue("Codigo", cod)
self.oHelper.SetValue("Descricao", desc)
self.oHelper.SetValue("Tipo", tipo)
self.oHelper.SetValue("Unidade", unidade)
self.oHelper.SetValue("Armazem Pad.", armazem)
self.oHelper.SetValue("Tabela Linha", linha)
self.oHelper.SetValue("Tabela Colun", coluna)
self.oHelper.ClickFolder("E-Commerce")
self.oHelper.SetValue("Título ", desc)
self.oHelper.SetButton("Salvar")
time.sleep(2)
self.oHelper.SetKey("RIGHT", grid=True)
self.oHelper.SetValue("[01] PRETO", "X", grid=True,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
time.sleep(2)
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_MATA550_002(self):
#VISUALIZAR
cod = 'ESTSEGRADE01'
filial = 'D MG '
desc = 'MATA550TIR'
self.oHelper.SearchBrowse(f"{filial}{cod}", "Filial+Codigo")
self.oHelper.SetButton("Visualizar")
time.sleep(1)
self.oHelper.SetFocus("B4_DESC")
time.sleep(1)
self.oHelper.CheckResult("B4_DESC", desc)
self.oHelper.CheckResult("[01] PRETO","X",grid=True,line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_MATA550_003(self):
#Alterar
cod = 'ESTSEGRADE01'
desc = 'mata550 tir alt'
filial = 'D MG '
self.oHelper.SearchBrowse(f"{filial}{cod}", "Filial+Codigo")
self.oHelper.SetButton("Alterar")
time.sleep(1)
self.oHelper.CheckResult("B4_COD", cod)
self.oHelper.SetValue("Descricao", desc)
self.oHelper.SetButton("Salvar")
time.sleep(1)
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
def test_MATA550_004(self):
#Excluir
cod = 'ESTSEGRADE01'
filial = 'D MG '
self.oHelper.SearchBrowse(f"{filial}{cod}", "Filial+Codigo")
self.oHelper.SetButton('Outras Ações','Excluir')
time.sleep(1)
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
'''
Method that finishes the test case.
'''
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/MATC015TESTCASE.py
```python
from tir import Webapp
import unittest
import time
class MATC015(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAEST','21/06/2019','T1','D MG 01')
inst.oHelper.Program('MATC015')
def test_MATC015_CT001(self):
self.oHelper.SetButton('Ok')
self.oHelper.SearchBrowse('D MG 01 ESTSE0000000000000000000000212')
self.oHelper.SetButton('POsicionado')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
def test_MATC015_CT002(self):
#self.oHelper.SetButton('Ok')
self.oHelper.SearchBrowse('D MG 01 ESTSE0000000000000000000000212')
self.oHelper.SetButton('POsicionado')
self.oHelper.ClickTree('ESTSE0000000000000000000000212 - ESTSE0000000000000000000000212 > Roteiros de Operacao')
time.sleep(2)
self.oHelper.ClickTree('ESTSE0000000000000000000000212 - ESTSE0000000000000000000000212 > Ordens de Producao')
time.sleep(2)
self.oHelper.ClickTree('ESTSE0000000000000000000000212 - ESTSE0000000000000000000000212 > Estruturas')
time.sleep(2)
self.oHelper.ClickTree('ESTSE0000000000000000000000212 - ESTSE0000000000000000000000212 > Estruturas > Revisão')
time.sleep(2)
self.oHelper.ClickTree('ESTSE0000000000000000000000212 - ESTSE0000000000000000000000212 > Painel de custos')
time.sleep(2)
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/MATR270TESTCASE.py
```python
from tir import Webapp
import unittest
import time
class MATR270(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAEST','30/09/2019','T1','D MG 01')
inst.oHelper.Program('MATR270')
def test_MATR270_CT001(self):
self.oHelper.SetButton('Param.')
self.oHelper.SetValue('Armazem de ?','01')
self.oHelper.SetValue('Armazem ate ?','01')
self.oHelper.SetValue('Produto de ?','')
self.oHelper.SetValue('Produto ate ?','ZZZZZ')
self.oHelper.SetValue('Tipo de ?','')
self.oHelper.SetValue('Tipo ate ?','ZZ')
self.oHelper.SetValue('Grupo de ?','')
self.oHelper.SetValue('Grupo ate ?','ZZZ')
self.oHelper.SetValue('Descricao de ?','')
self.oHelper.SetValue('Descricao ate ?','ZZZZZZ')
self.oHelper.SetValue('Proximo Numero ?','123456')
self.oHelper.SetValue('Data Selecao de ?','30/09/2019')
self.oHelper.SetValue('Data Selecao ate ?','30/09/2019')
self.oHelper.SetValue('Qual Ordem de Col. ?','123')
self.oHelper.SetValue('Endereco De ?','')
self.oHelper.SetValue('Endereco Ate ?','ZZZZZZ')
self.oHelper.SetValue('Imprime etiqueta de produtos ?','Ambos')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Ok')
time.sleep(5)
self.oHelper.SetButton('sair')
self.oHelper.AssertTrue()
def test_MATR270_CT002(self):
self.oHelper.Program('MATR270')
self.oHelper.SetButton('Param.')
self.oHelper.SetValue('Armazem de ?','01')
self.oHelper.SetValue('Armazem ate ?','01')
self.oHelper.SetValue('Produto de ?','ESTSE0000000000000000000023748')
self.oHelper.SetValue('Produto ate ?','ESTSE0000000000000000000023748')
self.oHelper.SetValue('Tipo de ?','')
self.oHelper.SetValue('Tipo ate ?','ZZ')
self.oHelper.SetValue('Grupo de ?','')
self.oHelper.SetValue('Grupo ate ?','ZZZ')
self.oHelper.SetValue('Descricao de ?','')
self.oHelper.SetValue('Descricao ate ?','ZZZZZZ')
self.oHelper.SetValue('Proximo Numero ?','123456')
self.oHelper.SetValue('Data Selecao de ?','09/12/2019')
self.oHelper.SetValue('Data Selecao ate ?','09/12/2019')
self.oHelper.SetValue('Qual Ordem de Col. ?','123')
self.oHelper.SetValue('Endereco De ?','')
self.oHelper.SetValue('Endereco Ate ?','ZZZZZZ')
self.oHelper.SetValue('Imprime etiqueta de produtos ?','Ambos')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Sim')
time.sleep(5)
self.oHelper.SetButton('sair')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/MATR462TESTCASE.py
```python
from tir import Webapp
import unittest
import time
class MATR462(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAEST','30/09/2019','T1','D MG 01')
inst.oHelper.Program('MATR462')
def test_MATR462_CT001(self):
self.oHelper.SetButton('Param.')
self.oHelper.SetValue('De Produto ?','ESTSE0000000000000000000000550')
self.oHelper.SetValue('Ate Produto ?','ESTSE0000000000000000000000550')
self.oHelper.SetValue('De Armazem ?','')
self.oHelper.SetValue('Ate Armazem ?','ZZ')
self.oHelper.SetValue('De Grupo ?','')
self.oHelper.SetValue('Ate Grupo ?','ZZ')
self.oHelper.SetValue('De Tipo ?','')
self.oHelper.SetValue('Ate Tipo ?','ZZ')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Ok')
#self.oHelper.SetButton('Sim')
time.sleep(20)
self.oHelper.SetButton('sair')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAEST/TECA470ESTTESTCASE.py
```python
from tir import Webapp
import unittest
import time
#//-------------------------------------------------------------------
#@author <NAME>
#@since 16/11/2020
#@version 1.0
#/*/
#//-------------------------------------------------------------------
class TECA470(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGATEC","16/11/2020","T1","D MG 01")
inst.oHelper.Program("TECA470")
def test_TECA470_001(self):
#Definição dos perguntes iniciais
self.oHelper.SetButton("Visualizar")
time.sleep(2)
self.oHelper.ClickGridCell("Quantidade", 1)
self.oHelper.SetKey("F4")
self.oHelper.SetButton('X')
time.sleep(1)
self.oHelper.SetKey("F4")
time.sleep(1)
self.oHelper.SetButton("OK")
time.sleep(1)
self.oHelper.SetButton("OK")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAFAT/FATA150TESTCASE.py
```python
from tir import Webapp
import unittest
from datetime import datetime
DateSystem = datetime.today().strftime("%d/%m/%Y")
class FATA150(unittest.TestCase):
@classmethod
def setUpClass(self):
self.oHelper = Webapp()
self.oHelper.Setup("SIGAFAT", DateSystem, "T1", "D MG 01 ", "05")
self.oHelper.Program("FATA150")
def test_FATA150_CT001(self):
cCategory = 'FATC01'
cProduct01 = 'FATC00000000000000000000000001'
cProduct02 = 'FATC00000000000000000000000002'
self.oHelper.WaitShow("Parametros")
self.oHelper.SetValue("Tipo de Interface","Por Categoria")
self.oHelper.SetButton("OK")
self.oHelper.WaitShow("Amarração Categoria x Grupo ou Produto")
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("D MG 01 ")
self.oHelper.WaitShow("Amarração Categoria x Grupo ou Produto - INCLUIR")
self.oHelper.SetValue("Categoria", cCategory)
self.oHelper.SetValue("Produto", cProduct01, grid=True, row=1)
self.oHelper.SetKey("DOWN", grid=True, grid_number=1)
self.oHelper.SetValue("Produto", cProduct02, grid=True, row=2)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SearchBrowse(f"D MG {cCategory}", "Filial+categoria + Grupo + Produto")
self.oHelper.SetButton("Visualizar")
self.oHelper.WaitShow("Amarração Categoria x Grupo ou Produto - VISUALIZAR")
self.oHelper.CheckResult("Categoria", cCategory)
self.oHelper.CheckResult("Produto", cProduct01, grid=True, line=1)
self.oHelper.CheckResult("Produto", cProduct02, grid=True, line=2)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(self):
self.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGAFAT/FATA400TESTCASE.py
```python
from tir import Webapp
from datetime import datetime
DataSystem = datetime.today().strftime('%d/%m/%Y')
import unittest
class FATA400(unittest.TestCase):
Contr = ""
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAFAT", DataSystem,"T1","D MG 01 ","05")
inst.oHelper.Program("FATA400")
def test_FATA400_CT001(self):
global Contr
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("D MG 01 ")
Contr = self.oHelper.GetValue("ADA_NUMCTR")
self.oHelper.SetValue("ADA_NUMCTR", Contr)
self.oHelper.SetValue("ADA_EMISSA","04/07/2019")
self.oHelper.SetValue("ADA_CODCLI","000001")
self.oHelper.SetValue("ADA_LOJCLI","01")
self.oHelper.SetValue("ADA_CONDPG","000")
self.oHelper.SetValue("ADB_CODPRO", "FAT000000000000000000000000001", grid=True)
self.oHelper.SetValue("ADB_QUANT", "1,00", grid=True)
self.oHelper.SetValue("ADB_PRCVEN", "1,00", grid=True)
self.oHelper.SetValue("ADB_TES", "501", grid=True)
self.oHelper.SetValue("ADB_TESCOB", "503", grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SearchBrowse(f"D MG 01 {Contr}", "Filial+contrato N.")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("ADA_NUMCTR", Contr)
self.oHelper.CheckResult("ADA_CODCLI","000001")
self.oHelper.CheckResult("ADA_LOJCLI","01")
self.oHelper.CheckResult("ADA_CONDPG","000")
self.oHelper.CheckResult("ADB_CODPRO", " FAT000000000000000000000000001", grid=True, line=1)
self.oHelper.CheckResult("ADB_QUANT", "1,00", grid=True, line=1)
self.oHelper.CheckResult("ADB_PRCVEN", "1,00", grid=True, line=1)
self.oHelper.CheckResult("ADB_TES", "501", grid=True, line=1)
self.oHelper.CheckResult("ADB_TESCOB", "503", grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAFAT/MATA430TESTCASE.py
```python
from tir import Webapp
import unittest
class MATA430(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAFAT','03/07/2019','T1','D MG 01 ','05')
inst.oHelper.Program('MATA430')
def test_MATA430_CT001(self):
self.oHelper.SetButton('Outras Ações','LeGenda')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAFAT/MATA450TESTCASE.py
```python
from tir import Webapp
import unittest
class MATA450(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAFAT','17/07/2019','T1','D MG 01 ','05')
inst.oHelper.Program('MATA450')
def test_MATA450_CT001(self):
self.oHelper.SetValue('Somente Bloqueados ?', 'Sim')
self.oHelper.SetButton('Ok')
self.oHelper.SearchBrowse("D MG 01 FAT175")
self.oHelper.SetButton('Manual')
self.oHelper.SetButton('Ok')
self.oHelper.SearchBrowse("D MG 01 FAT175")
self.oHelper.SetButton('Manual')
self.oHelper.SetButton('Pedido')
pedido = self.oHelper.GetValue("C5_NUM")
if pedido == 'FAT175':
self.oHelper.AssertFalse()
else:
self.oHelper.SetButton('Cancelar')
self.oHelper.SetButton('Estoque')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAFAT/TRKXFUNTESTCASE.py
```python
from tir import Webapp
import unittest
from datetime import datetime
DateSystem = datetime.today().strftime("%d/%m/%Y")
class TRKXFUN(unittest.TestCase):
@classmethod
def setUpClass(self):
self.oHelper = Webapp(autostart=False)
self.oHelper.SetTIRConfig(config_name="User", value="telemarketing")
self.oHelper.SetTIRConfig(config_name="Password", value="1")
def test_TRKXFUN_CT001(self):
self.oHelper.Start()
self.oHelper.Setup("SIGATMK",DateSystem,"T1","D MG 01","13")
self.oHelper.Program("TMKA271")
self.oHelper.AddParameter("MV_FATPROP","D MG 01","O","O","O")
self.oHelper.SetParameters()
self.oHelper.SearchBrowse(f"D MG 01 000020", "Filial+atendimento")
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Outras Ações", "Tracker da Entidade")
self.oHelper.SetButton("Rastrear")
self.oHelper.ClickTree("Atendimento Telemarketing - 000020")
self.oHelper.SetButton("Abandonar")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("X")
self.oHelper.RestoreParameters()
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(self):
self.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGAFIN/FINA080TESTCASE.py
```python
import unittest
import time
from tir import Webapp
from datetime import datetime
DateSystem = datetime.today().strftime('%d/%m/%Y')
class FINA080(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAFIN", DateSystem, "T1", "D MG 01 ", "06")
inst.oHelper.Program("FINA080")
#{Protheus.doc} test_FINA080_CT110
#Baixa de título Moeda 2, com banco moeda 1 informando cheque
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/project/10231/testCase?folderId=17808
def test_FINA080_CT110(self):
prefixo = "TIR"
titulo = "F080CT110"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
cheque = "F080CT110"
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetKey("F12")
self.oHelper.WaitShow("Parametros")
self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "NORMAL")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Cheque No.", cheque)
self.oHelper.CheckResult("Taxa contratada", "5,0000")
self.oHelper.CheckResult("= Valor Pago", "5.000,00")
self.oHelper.CheckResult("Valor US$", "1.000,00")
self.oHelper.CheckResult("+ Corr.Monetária", "0,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT113
#Baixa de título Moeda 2 (com banco moeda 1 cheque cadastrado)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/project/10231/testCase?folderId=17808
def test_FINA080_CT113(self):
prefixo = "TIR"
titulo = "F080CT112"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
cheque = "F080CT112"
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "NORMAL")
self.oHelper.SetValue("Banco", banco)
self.oHelper.CheckResult("Agência", agencia)
self.oHelper.CheckResult("Conta", conta)
self.oHelper.CheckResult("Cheque No.", cheque)
self.oHelper.CheckResult("Taxa contratada", "5,0000")
self.oHelper.CheckResult("= Valor Pago", "10.000,00")
self.oHelper.CheckResult("Valor US$", "2.000,00")
self.oHelper.CheckResult("+ Corr.Monetária", "0,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT114
#Baixa total de título Moeda 2, com taxa de permanência informada, (banco moeda 1, taxa do dia, – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50384
def test_FINA080_CT114(self):
prefixo = "TIR"
titulo = "F080CT114"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
data = "16/04/2020"
#Parametrização default
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.SetParameters()
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("16/04/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("Data Pagto.", data)
self.oHelper.CheckResult("Data Debito", data)
self.oHelper.SetValue("Taxa contratada", "140,0000")
self.oHelper.SetValue("+ Tx.Permanenc.", "140,00")
self.oHelper.CheckResult("= Valor Pago", "140.140,00")
self.oHelper.CheckResult("Valor US$", "1.001,00")
self.oHelper.CheckResult("+ Corr.Monetária", "1.011,01")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT115
#Baixa total de título Moeda 2, com taxa de permanência calculada (banco moeda 1, taxa do Contratada – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50385
def test_FINA080_CT115(self):
prefixo = "TIR"
titulo = "F080CT115"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
self.oHelper.WaitShow("Baixa de Titulos")
#Parametrização default
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.SetParameters()
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("26/04/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Taxa contratada", "5,0000")
self.oHelper.CheckResult("+ Tx.Permanenc.", "50,00")
self.oHelper.CheckResult("= Valor Pago", "10.050,00")
self.oHelper.CheckResult("Valor US$", "2.010,00")
self.oHelper.CheckResult("+ Corr.Monetária", "1.005,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT116
#Baixa Parcial de título Moeda 2 com desconto informado, (banco moeda 1, taxa do dia – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50386
def test_FINA080_CT116(self):
prefixo = "TIR"
titulo = "F080CT116"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
#Parametrização default
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.SetParameters()
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("16/04/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Taxa contratada", "140,0000")
self.oHelper.SetValue("= Valor Pago", "56.000,00")
self.oHelper.CheckResult("Valor US$", "400,00")
self.oHelper.CheckResult("+ Corr.Monetária", "404,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Taxa contratada", "135,0000")
self.oHelper.CheckResult("- Pagtos.Parciais", "400,00")
self.oHelper.SetValue("- Descontos", "1000,00")
self.oHelper.CheckResult("= Valor Pago", "80.000,00")
self.oHelper.CheckResult("Valor US$", "592,59")
self.oHelper.CheckResult("+ Corr.Monetária", "-2.364,43")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT117
#Baixa parcial de título Moeda 2 com acréscimo (banco moeda 1, taxa do Contratada – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50387
def test_FINA080_CT117(self):
prefixo = "TIR"
titulo = "F080CT117"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
self.oHelper.WaitShow("Baixa de Titulos")
#Parametrização default
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.SetParameters()
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Taxa contratada", "5,0000")
self.oHelper.CheckResult("+ Acrescimo", "100,00")
self.oHelper.SetValue("= Valor Pago", "2.000,00")
self.oHelper.CheckResult("Valor US$", "400,00")
self.oHelper.CheckResult("+ Corr.Monetária", "200,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Taxa contratada", "4,8000")
self.oHelper.CheckResult("+ Acrescimo", "0,00")
self.oHelper.CheckResult("- Pagtos.Parciais", "300,00")
self.oHelper.CheckResult("= Valor Pago", "8.160,00")
self.oHelper.CheckResult("Valor US$", "1700,00")
self.oHelper.CheckResult("+ Corr.Monetária", "510,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT120
#Baixa total de título Moeda 2 (banco moeda 2, taxa do dia – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50467
def test_FINA080_CT120(self):
prefixo = "TIR"
titulo = "F080CT120"
parcela = " "
tipo = "NF "
banco = "002"
agencia = "08000"
conta = "080110"
#Data Definida no CT114
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("16/04/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("= Valor Pago", "1.000,00")
self.oHelper.CheckResult("Valor US$", "1.000,00")
self.oHelper.CheckResult("+ Corr.Monetária", "0,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT121
#Baixa Parcial de título Moeda 2 (banco moeda 2, taxa do Contratada – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50468
def test_FINA080_CT121(self):
prefixo = "TIR"
titulo = "F080CT121"
parcela = " "
tipo = "NF "
banco = "002"
agencia = "08000"
conta = "080110"
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("= Valor Pago", "600,00")
self.oHelper.CheckResult("Valor US$", "600,00")
self.oHelper.CheckResult("+ Corr.Monetária", "0,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("= Valor Pago", "1.400,00")
self.oHelper.CheckResult("Valor US$", "1.400,00")
self.oHelper.CheckResult("+ Corr.Monetária", "0,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT122
#Baixa em lote de título Moeda 2 (banco moeda 2, taxa do dia – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50469
def test_FINA080_CT122(self):
banco = "002"
agencia = "08000"
conta = "080110"
ntitulos = '2'
lote ='LTC122'
natureza ='FIN080SIMP'
data = "16/04/2020"
titulo1 = "LOTACT122"
titulo2 = "LOTBCT122"
#Data Definida no CT114
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("16/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.SetButton("Outras Ações", "Lote")
self.oHelper.SetValue("cBanco", banco, name_attr=True)
self.oHelper.SetValue("cAgencia", agencia, name_attr=True)
self.oHelper.SetValue("cConta", conta, name_attr=True)
self.oHelper.SetValue("nNroTit", ntitulos, name_attr=True)
self.oHelper.SetValue("cLoteFin", lote, name_attr=True)
self.oHelper.SetValue("DVENCINI", data, name_attr=True)
self.oHelper.SetValue("DVENCFIM", data, name_attr=True)
self.oHelper.SetValue("cNatDe", natureza, name_attr=True)
self.oHelper.SetValue("cNatAte", natureza, name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.ClickBox("No. Titulo", titulo1)
self.oHelper.ClickBox("No. Titulo", titulo2)
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("= Valor Pago", "1.000,00")
self.oHelper.CheckResult("Valor US$", "1.000,00")
self.oHelper.CheckResult("+ Corr.Monetária", "0,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("= Valor Pago", "2.000,00")
self.oHelper.CheckResult("Valor US$", "2.000,00")
self.oHelper.CheckResult("+ Corr.Monetária", "0,00")
self.oHelper.SetButton("Salvar")
self.oHelper.CheckHelp(text='TOTGERAL',button='Fechar')
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT123
#Baixa lote de título Moeda 2 com multa informada (banco moeda 1, taxa do Contratada – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50470
def test_FINA080_CT123(self):
banco = "001"
agencia = "08000"
conta = "080110"
ntitulos = '2'
lote ='LTC123'
natureza ='FIN080SIMP'
data = "16/04/2020"
titulo1 = "LOTACT123"
titulo2 = "LOTBCT123"
#Parametrização default
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.SetParameters()
self.oHelper.SetButton("Outras Ações", "Lote")
self.oHelper.SetValue("cBanco", banco, name_attr=True)
self.oHelper.SetValue("cAgencia", agencia, name_attr=True)
self.oHelper.SetValue("cConta", conta, name_attr=True)
self.oHelper.SetValue("nNroTit", ntitulos, name_attr=True)
self.oHelper.SetValue("cLoteFin", lote, name_attr=True)
self.oHelper.SetValue("DVENCINI", data, name_attr=True)
self.oHelper.SetValue("DVENCFIM", data, name_attr=True)
self.oHelper.SetValue("cNatDe", natureza, name_attr=True)
self.oHelper.SetValue("cNatAte", natureza, name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.ClickBox("No. Titulo", titulo1)
self.oHelper.ClickBox("No. Titulo", titulo2)
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.SetValue("Taxa contratada", "5,0000")
self.oHelper.SetValue("+ Multa", "20,00")
self.oHelper.CheckResult("= Valor Pago", "5.020,00")
self.oHelper.CheckResult("Valor US$", "1.004,00")
self.oHelper.CheckResult("+ Corr.Monetária", "502,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.SetValue("Taxa contratada", "5,0000")
self.oHelper.SetValue("+ Multa", "30,00")
self.oHelper.CheckResult("= Valor Pago", "10.030,00")
self.oHelper.CheckResult("Valor US$", "2.006,00")
self.oHelper.CheckResult("+ Corr.Monetária", "0,00")
self.oHelper.SetButton("Salvar")
self.oHelper.CheckHelp(text='TOTGERAL',button='Fechar')
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT124
#Baixa total de título (Sem impostos, com acréscimo, valores acessórios - Moeda 1 – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50488
def test_FINA080_CT124(self):
prefixo = "TIR"
titulo = "F080CT124"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "NORMAL")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("+ Acrescimo", "100,00")
self.oHelper.CheckResult("+ Valores Acessórios", "35,00")
self.oHelper.CheckResult("= Valor Pago", "10.135,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT125
#Baixa parcial de título (Sem impostos, com acréscimo, valores acessórios - Moeda 1 – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50489
def test_FINA080_CT125(self):
prefixo = "TIR"
titulo = "F080CT125"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("+ Acrescimo", "90,00")
self.oHelper.CheckResult("+ Valores Acessórios", "15,00")
self.oHelper.SetValue("= Valor Pago", "600,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("- Pagtos.Parciais", "495,00")
self.oHelper.CheckResult("+ Acrescimo", "0,00")
self.oHelper.CheckResult("+ Valores Acessórios", "0,00")
self.oHelper.CheckResult("= Valor Pago", "1.505,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT126
#Baixa total de título (Com motivo de baixa DACAO – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50490
def test_FINA080_CT126(self):
prefixo = "TIR"
titulo = "F080CT126"
parcela = " "
tipo = "NF "
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DACAO")
self.oHelper.CheckResult("= Valor Pago", "1.000,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT127
#Baixa total de título Moeda 1 (Motivo de baixa VENDOR – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50491
def test_FINA080_CT127(self):
prefixo = "TIR"
titulo = "F080CT127"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
Contrato = "000000000000001"
data = "16/04/2020"
PrefVen = "VEN"
tipoven = "DP"
#Data Definida no CT114
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("16/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "VENDOR")
self.oHelper.SetValue("cContrato", Contrato, name_attr=True)
self.oHelper.SetValue("cBancoV", banco, name_attr=True)
self.oHelper.SetValue("cAgenciaV", agencia, name_attr=True)
self.oHelper.SetValue("cPrefV", PrefVen, name_attr=True)
self.oHelper.SetValue("cNumV", titulo, name_attr=True)
self.oHelper.SetValue("cTipV", tipoven, name_attr=True)
self.oHelper.SetValue("dDataVencV", data, name_attr=True)
self.oHelper.CheckResult("nTxAcresV", "5,0000", name_attr=True)
self.oHelper.CheckResult("cNaturV", "VENDOR", name_attr=True)
self.oHelper.CheckResult("nValTitV", "3.000,00", name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.SetValue("Data Debito", data)
self.oHelper.CheckResult("= Valor Pago", "3.000,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {PrefVen}{titulo}{parcela}{tipoven}")
self.oHelper.SetButton("Visualizar")
self.oHelper.WaitShow("Baixa de Titulos - VISUALIZAR")
self.oHelper.CheckResult("E2_SALDO", "3.000,00")
self.oHelper.ClickFolder('Administrativo')
self.oHelper.CheckResult("E2_ACRESC", "150,00")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT128
#Baixa lote de título Moeda 1 (Sem impostos, com abatimento - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50492
def test_FINA080_CT128(self):
banco = "001"
agencia = "08000"
conta = "080110"
ntitulos = '2'
lote ='LTC128'
natureza='FIN080SIMP'
data = "17/04/2020"
prefixo = "TIR"
titulo1 = "LOTACT128"
titulo2 = "LOTBCT128"
parcela = " "
tipo = "NF"
tipoabt = "AB-"
fornecedor = "FINA01"
loja = "01"
#Data Definida no CT114
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("16/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.SetButton("Outras Ações", "Lote")
self.oHelper.SetValue("cBanco", banco, name_attr=True)
self.oHelper.SetValue("cAgencia", agencia, name_attr=True)
self.oHelper.SetValue("cConta", conta, name_attr=True)
self.oHelper.SetValue("nNroTit", ntitulos, name_attr=True)
self.oHelper.SetValue("cLoteFin", lote, name_attr=True)
self.oHelper.SetValue("DVENCINI", data, name_attr=True)
self.oHelper.SetValue("DVENCFIM", data, name_attr=True)
self.oHelper.SetValue("cNatDe", natureza, name_attr=True)
self.oHelper.SetValue("cNatAte", natureza, name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.ClickBox("No. Titulo", titulo1)
self.oHelper.ClickBox("No. Titulo", titulo2)
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetButton("Salvar")
self.oHelper.CheckHelp(text='TOTGERAL',button='Fechar')
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT135
#Baixa total de título (Com PCC/IRF na baixa e ISS/INSS na emissão - Moeda 1 – Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50568
def test_FINA080_CT135(self):
prefixo = "TIR"
titulo = "F080CT135"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
self.oHelper.SetParameters()
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("- Irrf", "150,00")
self.oHelper.CheckResult("- Pis", "65,00")
self.oHelper.CheckResult("- Cofins", "300,00")
self.oHelper.CheckResult("- Csll", "100,00")
self.oHelper.CheckResult("= Valor Pago", "7.785,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT136
#Baixa parcial de título (Com PCC/IRF na baixa e ISS/INSS na emissão - Moeda 1 – Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50569
def test_FINA080_CT136(self):
prefixo = "TIR"
titulo = "F080CT136"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.SetParameters()
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("= Valor Pago", "4.000,00")
self.oHelper.CheckResult("- Irrf", "60,00")
self.oHelper.CheckResult("- Pis", "26,00")
self.oHelper.CheckResult("- Cofins", "120,00")
self.oHelper.CheckResult("- Csll", "40,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("- Irrf", "90,00")
self.oHelper.CheckResult("- Pis", "39,00")
self.oHelper.CheckResult("- Cofins", "180,00")
self.oHelper.CheckResult("- Csll", "60,00")
self.oHelper.CheckResult("= Valor Pago", "3.785,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT137
#Baixa total de título (Com PCC/IRF/ ISS na baixa e INSS na emissão - Moeda 1 – Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50570
def test_FINA080_CT137(self):
prefixo = "TIR"
titulo = "F080CT137"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
data = "16/04/2020"
self.oHelper.AddParameter("MV_MRETISS", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
self.oHelper.SetParameters()
#Data Definida no CT114
#time.sleep(15)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("16/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("Data Pagto.", data)
self.oHelper.SetValue("Data Debito", "17/04/2020")
self.oHelper.CheckResult("- Iss", "500,00")
self.oHelper.CheckResult("- Irrf", "150,00")
self.oHelper.CheckResult("- Pis", "65,00")
self.oHelper.CheckResult("- Cofins", "300,00")
self.oHelper.CheckResult("- Csll", "100,00")
self.oHelper.CheckResult("= Valor Pago", "7.785,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT138
#Baixa parcial de título (Com PCC/IRF/ ISS na baixa e INSS na emissão - Moeda 1 – Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50571
def test_FINA080_CT138(self):
prefixo = "TIR"
titulo = "F080CT138"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
data = "16/04/2020"
#Parametrização CT137
#self.oHelper.AddParameter("MV_MRETISS", "", "2", "2", "2")
#self.oHelper.SetParameters()
#Data Definida no CT114
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("16/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("Data Pagto.", data)
self.oHelper.SetValue("Data Debito", "17/04/2020")
self.oHelper.SetValue("= Valor Pago", "4.000,00")
self.oHelper.CheckResult("- Iss", "200,00")
self.oHelper.CheckResult("- Irrf", "60,00")
self.oHelper.CheckResult("- Pis", "26,00")
self.oHelper.CheckResult("- Cofins", "120,00")
self.oHelper.CheckResult("- Csll", "40,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("Data Pagto.", data)
self.oHelper.SetValue("Data Debito", "17/04/2020")
self.oHelper.CheckResult("- Iss", "300,00")
self.oHelper.CheckResult("- Irrf", "90,00")
self.oHelper.CheckResult("- Pis", "39,00")
self.oHelper.CheckResult("- Cofins", "180,00")
self.oHelper.CheckResult("- Csll", "60,00")
self.oHelper.CheckResult("= Valor Pago", "3.785,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT141
#Baixa total de título (Com PCC/IRF na baixa e ISS/INSS na emissão - Moeda 1 – Acréscimo, desconto - Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50578
def test_FINA080_CT141(self):
prefixo = "TIR"
titulo = "F080CT139"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
data = "16/04/2020"
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
self.oHelper.SetParameters()
#Data Definida no CT114
#time.sleep(15)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("16/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("Data Pagto.", data)
self.oHelper.SetValue("Data Debito", "17/04/2020")
self.oHelper.SetValue("- Descontos", "50,00")
self.oHelper.CheckResult("+ Acrescimo", "200,00")
self.oHelper.CheckResult("- Irrf", "150,00")
self.oHelper.CheckResult("- Pis", "65,00")
self.oHelper.CheckResult("- Cofins", "300,00")
self.oHelper.CheckResult("- Csll", "100,00")
self.oHelper.CheckResult("= Valor Pago", "7.935,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT142
#Baixa parcial de título (Com PCC/IRF na baixa e ISS/INSS na emissão – Decréscimo, Valores acessórios e Multa - Moeda 1 – Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50579
def test_FINA080_CT142(self):
prefixo = "TIR"
titulo = "F080CT140"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
data = "17/04/2020"
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.SetParameters()
#Data Definida no CT114
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("16/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.SetValue("= Valor Pago", "4.000,00")
self.oHelper.CheckResult("- Decrescimo" , "50,00")
self.oHelper.CheckResult("+ Valores Acessórios", "-15,00")
self.oHelper.CheckResult("- Irrf", "60,75")
self.oHelper.CheckResult("- Pis", "26,42")
self.oHelper.CheckResult("- Cofins", "121,95")
self.oHelper.CheckResult("- Csll", "40,65")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.CheckResult("- Decrescimo" , "0,00")
self.oHelper.CheckResult("+ Valores Acessórios", "0,00")
self.oHelper.CheckResult("- Irrf", "89,25")
self.oHelper.CheckResult("- Pis", "38,57")
self.oHelper.CheckResult("- Cofins", "178,05")
self.oHelper.CheckResult("- Csll", "59,35")
self.oHelper.CheckResult("= Valor Pago", "3.720,01")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT143
#Baixa total de título em lote (Com PCC/IRF na baixa e ISS /INSS na emissão – Valores acessórios e multa - Moeda 1 – Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50580
def test_FINA080_CT143(self):
banco = "001"
agencia = "08000"
conta = "080110"
ntitulos = '2'
lote ='LTC143'
natureza='FIN080CIMP'
data = "16/04/2020"
titulo1 = "LOTACT141"
titulo2 = "LOTBCT141"
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.SetParameters()
#Data Definida no CT114
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("16/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.SetButton("Outras Ações", "Lote")
self.oHelper.SetValue("cBanco", banco, name_attr=True)
self.oHelper.SetValue("cAgencia", agencia, name_attr=True)
self.oHelper.SetValue("cConta", conta, name_attr=True)
self.oHelper.SetValue("nNroTit", ntitulos, name_attr=True)
self.oHelper.SetValue("cLoteFin", lote, name_attr=True)
self.oHelper.SetValue("DVENCINI", data, name_attr=True)
self.oHelper.SetValue("DVENCFIM", data, name_attr=True)
self.oHelper.SetValue("cNatDe", natureza, name_attr=True)
self.oHelper.SetValue("cNatAte", natureza, name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.ClickBox("No. Titulo", titulo1)
self.oHelper.ClickBox("No. Titulo", titulo2)
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("+ Valores Acessórios", "35,00")
self.oHelper.SetValue("+ Multa", "20,00")
self.oHelper.CheckResult("- Irrf", "150,00")
self.oHelper.CheckResult("- Pis", "65,00")
self.oHelper.CheckResult("- Cofins", "300,00")
self.oHelper.CheckResult("- Csll", "100,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("+ Valores Acessórios", "58,00")
self.oHelper.SetValue("+ Multa", "15,00")
self.oHelper.CheckResult("- Irrf", "150,00")
self.oHelper.CheckResult("- Pis", "65,00")
self.oHelper.CheckResult("- Cofins", "300,00")
self.oHelper.CheckResult("- Csll", "100,00")
self.oHelper.SetButton("Salvar")
self.oHelper.CheckHelp(text='TOTGERAL',button='Fechar')
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT144
#Baixa total de título (Com PCC/IRF/ ISS na baixa e INSS na emissão - Moeda 1 – Taxa de permanência - Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50599
def test_FINA080_CT144(self):
prefixo = "TIR"
titulo = "F080CT144"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
data = "27/04/2020"
self.oHelper.AddParameter("MV_MRETISS", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
self.oHelper.SetParameters()
time.sleep(30)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("26/04/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("Data Pagto.", "26/04/2020")
self.oHelper.SetValue("Data Debito", data)
self.oHelper.CheckResult("+ Tx.Permanenc.", "10,00")
self.oHelper.CheckResult("- Iss", "500,00")
self.oHelper.CheckResult("- Irrf", "150,00")
self.oHelper.CheckResult("- Pis", "65,00")
self.oHelper.CheckResult("- Cofins", "300,00")
self.oHelper.CheckResult("- Csll", "100,00")
self.oHelper.CheckResult("= Valor Pago", "7.795,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT145
#Baixa parcial de título (Com PCC/IRF/ ISS na baixa e INSS na emissão – Taxa de permanência - Moeda 1 – Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50601
def test_FINA080_CT145(self):
prefixo = "TIR"
titulo = "F080CT145"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
data = "27/04/2020"
#Definida no CT144
#self.oHelper.AddParameter("MV_MRETISS", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.SetParameters()
#Data Definida no CT144
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("26/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("Data Pagto.", "26/04/2020")
self.oHelper.SetValue("Data Debito", data)
self.oHelper.CheckResult("+ Tx.Permanenc.", "10,00")
self.oHelper.SetValue("= Valor Pago", "4.000,00")
self.oHelper.CheckResult("- Iss", "199,50")
self.oHelper.CheckResult("- Irrf", "59,85")
self.oHelper.CheckResult("- Pis", "25,93")
self.oHelper.CheckResult("- Cofins", "119,70")
self.oHelper.CheckResult("- Csll", "39,90")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("Data Pagto.", "26/04/2020")
self.oHelper.SetValue("Data Debito", data)
self.oHelper.CheckResult("+ Tx.Permanenc.", "0,00")
self.oHelper.CheckResult("- Iss", "300,50")
self.oHelper.CheckResult("- Irrf", "90,15")
self.oHelper.CheckResult("- Pis", "39,06")
self.oHelper.CheckResult("- Cofins", "180,30")
self.oHelper.CheckResult("- Csll", "60,10")
self.oHelper.CheckResult("= Valor Pago", "3.795,01")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT146
#Baixa total de título em lote (Com PCC/IRF/ ISS na baixa e INSS na emissão – taxa de permanecia - Moeda 1 – Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50602
def test_FINA080_CT146(self):
banco = "001"
agencia = "08000"
conta = "080110"
ntitulos = '2'
lote ='LTC146'
natureza='FIN080CIMP'
data = "16/04/2020"
prefixo = "TIR"
titulo1 = "LOTACT146"
titulo2 = "LOTBCT146"
parcela = " "
tipo = "NF"
fornecedor = "FINA02"
loja = "01"
#Definida no CT144
#self.oHelper.AddParameter("MV_MRETISS", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.SetParameters()
#Data Definida no CT144
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("26/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Outras Ações", "Lote")
self.oHelper.SetValue("cBanco", banco, name_attr=True)
self.oHelper.SetValue("cAgencia", agencia, name_attr=True)
self.oHelper.SetValue("cConta", conta, name_attr=True)
self.oHelper.SetValue("nNroTit", ntitulos, name_attr=True)
self.oHelper.SetValue("cLoteFin", lote, name_attr=True)
self.oHelper.SetValue("DVENCINI", data, name_attr=True)
self.oHelper.SetValue("DVENCFIM", data, name_attr=True)
self.oHelper.SetValue("cNatDe", natureza, name_attr=True)
self.oHelper.SetValue("cNatAte", natureza, name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.ClickBox("No. Titulo", titulo1)
self.oHelper.ClickBox("No. Titulo", titulo2)
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("Data Pagto.", "26/04/2020")
self.oHelper.SetValue("+ Tx.Permanenc.", "35,00")
self.oHelper.CheckResult("- Iss", "500,00")
self.oHelper.CheckResult("- Irrf", "150,00")
self.oHelper.CheckResult("- Pis", "65,00")
self.oHelper.CheckResult("- Cofins", "300,00")
self.oHelper.CheckResult("- Csll", "100,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("+ Tx.Permanenc.", "58,00")
self.oHelper.CheckResult("- Iss", "500,00")
self.oHelper.CheckResult("- Irrf", "150,00")
self.oHelper.CheckResult("- Pis", "65,00")
self.oHelper.CheckResult("- Cofins", "300,00")
self.oHelper.CheckResult("- Csll", "100,00")
self.oHelper.SetButton("Salvar")
self.oHelper.CheckHelp(text='TOTGERAL',button='Fechar')
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT147
#Baixa total de título em Moeda 2 (Com PCC/IRF na baixa e ISS na emissão - banco moeda 2, taxa do dia – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50672
def test_FINA080_CT147(self):
prefixo = "TIR"
titulo = "F080CT147"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
data = "28/04/2020"
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
self.oHelper.SetParameters()
time.sleep(30)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("27/04/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.SetValue("Data Debito", data)
self.oHelper.CheckResult("Taxa contratada", "2,8965")
self.oHelper.CheckResult("- Irrf", "43,45")
self.oHelper.CheckResult("- Pis", "18,82")
self.oHelper.CheckResult("- Cofins", "86,89")
self.oHelper.CheckResult("- Csll", "28,96")
self.oHelper.CheckResult("= Valor Pago", "2.573,56")
self.oHelper.CheckResult("Valor US$", "888,51")
self.oHelper.CheckResult("+ Corr.Monetária", "389,79")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT148
#Baixa total de título em Moeda 2 (Com PCC/IRF na baixa e ISS na emissão - banco moeda 2, taxa Contratada – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50673
def test_FINA080_CT148(self):
prefixo = "TIR"
titulo = "F080CT148"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
data = "28/04/2020"
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.SetParameters()
#Data definida no CT147
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("27/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.SetValue("Data Debito", data)
self.oHelper.SetValue("Taxa contratada", "3,0000")
self.oHelper.CheckResult("- Irrf", "45,00")
self.oHelper.CheckResult("- Pis", "19,50")
self.oHelper.CheckResult("- Cofins", "90,00")
self.oHelper.CheckResult("- Csll", "30,00")
self.oHelper.CheckResult("= Valor Pago", "2.665,50")
self.oHelper.CheckResult("Valor US$", "888,50")
self.oHelper.CheckResult("+ Corr.Monetária", "888,50")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT149
#Baixa parcial de título em Moeda 2 (Com PCC/IRF na baixa e ISS na emissão - banco moeda 2, taxa do dia – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50674
def test_FINA080_CT149(self):
prefixo = "TIR"
titulo = "F080CT149"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
data = "28/04/2020"
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.SetParameters()
#Data definida no CT147
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("27/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.SetValue("Data Debito", data)
self.oHelper.CheckResult("Taxa contratada", "2,8965")
self.oHelper.SetValue("= Valor Pago", "1.000,00")
self.oHelper.CheckResult("- Irrf", "15,00")
self.oHelper.CheckResult("- Pis", "6,50")
self.oHelper.CheckResult("- Cofins", "30,00")
self.oHelper.CheckResult("- Csll", "10,00")
self.oHelper.CheckResult("Valor US$", "345,24")
self.oHelper.CheckResult("+ Corr.Monetária", "151,46")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.SetValue("Data Debito", data)
self.oHelper.CheckResult("Taxa contratada", "2,8965")
self.oHelper.CheckResult("- Irrf", "28,45")
self.oHelper.CheckResult("- Pis", "12,32")
self.oHelper.CheckResult("- Cofins", "56,89")
self.oHelper.CheckResult("- Csll", "18,96")
self.oHelper.CheckResult("= Valor Pago", "1.573,55")
self.oHelper.CheckResult("Valor US$", "543,26")
self.oHelper.CheckResult("+ Corr.Monetária", "238,33")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT150
#Baixa parcial de título em Moeda 2 (Com PCC/IRF na baixa e ISS na emissão - banco moeda 2, taxa Contratada – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50675
def test_FINA080_CT150(self):
prefixo = "TIR"
titulo = "F080CT150"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
data = "28/04/2020"
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.SetParameters()
#Data definida no CT147
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("27/04/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.SetValue("Data Debito", data)
self.oHelper.SetValue("Taxa contratada", "3,0000")
self.oHelper.SetValue("= Valor Pago", "1.000,00")
self.oHelper.CheckResult("- Irrf", "15,00")
self.oHelper.CheckResult("- Pis", "6,50")
self.oHelper.CheckResult("- Cofins", "30,00")
self.oHelper.CheckResult("- Csll", "10,00")
self.oHelper.CheckResult("Valor US$", "333,33")
self.oHelper.CheckResult("+ Corr.Monetária", "333,33")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.SetValue("Data Debito", data)
self.oHelper.SetValue("Taxa contratada", "3,0000")
self.oHelper.CheckResult("- Irrf", "30,00")
self.oHelper.CheckResult("- Pis", "13,00")
self.oHelper.CheckResult("- Cofins", "60,00")
self.oHelper.CheckResult("- Csll", "20,00")
self.oHelper.CheckResult("= Valor Pago", "1.665,51")
self.oHelper.CheckResult("Valor US$", "555,17")
self.oHelper.CheckResult("+ Corr.Monetária", "555,17")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT151
#Baixa total em lote de título em Moeda 2 (Com PCC/IRF na baixa e ISS na emissão - banco moeda 1, taxa do dia – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50676
def test_FINA080_CT151(self):
banco = "001"
agencia = "08000"
conta = "080110"
ntitulos = '2'
lote ='LTC151'
natureza='FIN080SINS'
data = "28/04/2020"
titulo1 = "LOTACT151"
titulo2 = "LOTBCT151"
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.SetParameters()
#Data definida no CT147
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("27/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Outras Ações", "Lote")
self.oHelper.SetValue("cBanco", banco, name_attr=True)
self.oHelper.SetValue("cAgencia", agencia, name_attr=True)
self.oHelper.SetValue("cConta", conta, name_attr=True)
self.oHelper.SetValue("nNroTit", ntitulos, name_attr=True)
self.oHelper.SetValue("cLoteFin", lote, name_attr=True)
self.oHelper.SetValue("DVENCINI", "27/04/2020", name_attr=True)
self.oHelper.SetValue("DVENCFIM", "27/04/2020", name_attr=True)
self.oHelper.SetValue("cNatDe", natureza, name_attr=True)
self.oHelper.SetValue("cNatAte", natureza, name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.ClickBox("No. Titulo", titulo1)
self.oHelper.ClickBox("No. Titulo", titulo2)
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.CheckResult("Taxa contratada", "2,8965")
self.oHelper.CheckResult("- Irrf", "43,44")
self.oHelper.CheckResult("- Pis", "18,82")
self.oHelper.CheckResult("- Cofins", "86,89")
self.oHelper.CheckResult("- Csll", "28,96")
self.oHelper.CheckResult("= Valor Pago", "2.573,57")
self.oHelper.CheckResult("Valor US$", "888,51")
self.oHelper.CheckResult("+ Corr.Monetária", "389,79")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.CheckResult("Taxa contratada", "2,8965")
self.oHelper.CheckResult("- Irrf", "43,44")
self.oHelper.CheckResult("- Pis", "18,82")
self.oHelper.CheckResult("- Cofins", "86,89")
self.oHelper.CheckResult("- Csll", "28,96")
self.oHelper.CheckResult("= Valor Pago", "2.573,57")
self.oHelper.CheckResult("Valor US$", "888,51")
self.oHelper.CheckResult("+ Corr.Monetária", "389,79")
self.oHelper.SetButton("Salvar")
self.oHelper.CheckHelp(text='TOTGERAL',button='Fechar')
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT152
#Baixa em lote de título Moeda 2 (Com PCC/IRF na baixa e ISS na emissão - banco moeda 1, taxa Contratada – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T50678
def test_FINA080_CT152(self):
banco = "001"
agencia = "08000"
conta = "080110"
ntitulos = '2'
lote ='LTC152'
natureza='FIN080SINS'
data = "28/04/2020"
titulo1 = "LOTACT152"
titulo2 = "LOTBCT152"
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.SetParameters()
#Data definida no CT147
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("27/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Outras Ações", "Lote")
self.oHelper.SetValue("cBanco", banco, name_attr=True)
self.oHelper.SetValue("cAgencia", agencia, name_attr=True)
self.oHelper.SetValue("cConta", conta, name_attr=True)
self.oHelper.SetValue("nNroTit", ntitulos, name_attr=True)
self.oHelper.SetValue("cLoteFin", lote, name_attr=True)
self.oHelper.SetValue("DVENCINI", "27/04/2020", name_attr=True)
self.oHelper.SetValue("DVENCFIM", "27/04/2020", name_attr=True)
self.oHelper.SetValue("cNatDe", natureza, name_attr=True)
self.oHelper.SetValue("cNatAte", natureza, name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.ClickBox("No. Titulo", titulo1)
self.oHelper.ClickBox("No. Titulo", titulo2)
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.SetValue("Taxa contratada", "3,0000")
self.oHelper.CheckResult("- Irrf", "45,00")
self.oHelper.CheckResult("- Pis", "19,50")
self.oHelper.CheckResult("- Cofins", "90,00")
self.oHelper.CheckResult("- Csll", "30,00")
self.oHelper.CheckResult("= Valor Pago", "2.665,50")
self.oHelper.CheckResult("Valor US$", "888,50")
self.oHelper.CheckResult("+ Corr.Monetária", "888,50")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Data Pagto.", data)
self.oHelper.SetValue("Taxa contratada", "4,0000")
self.oHelper.CheckResult("- Irrf", "60,00")
self.oHelper.CheckResult("- Pis", "26,00")
self.oHelper.CheckResult("- Cofins", "120,00")
self.oHelper.CheckResult("- Csll", "40,00")
self.oHelper.CheckResult("= Valor Pago", "3.554,00")
self.oHelper.CheckResult("Valor US$", "888,50")
self.oHelper.CheckResult("+ Corr.Monetária", "1.777,00")
self.oHelper.SetButton("Salvar")
self.oHelper.CheckHelp(text='TOTGERAL',button='Fechar')
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT186
#Cancelamento de baixa total de título (Com PCC/IRF na baixa e ISS/INSS na emissão - Moeda 1 - Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T51039
def test_FINA080_CT186(self):
prefixo = "TIR"
titulo = "F080CT186"
parcela = " "
tipo = "NF "
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.SetParameters()
#Data definida no CT147
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("27/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Outras Ações", "Cancelar Baixa")
self.oHelper.SetButton("Confirmar")
# verifica se foi cancelado
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Visualizar")
self.oHelper.WaitShow("Baixa de Titulos - VISUALIZAR")
self.oHelper.CheckResult("E2_SALDO", "8.400,00")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT187
#Cancelamento e exclusão de baixa parcial de título (Com PCC/IRF na baixa e ISS/INSS na emissão - Moeda 1 - Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T51040
def test_FINA080_CT187(self):
prefixo = "TIR"
titulo = "F080CT187"
parcela = " "
tipo = "NF "
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.SetParameters()
#Data definida no CT147
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("27/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Outras Ações", "Cancelar Baixa")
self.oHelper.ClickListBox("TIR F080CT187 NF FINA02 01 20/04/2020 3.785,00 02")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
# verifica se foi cancelado
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Visualizar")
self.oHelper.WaitShow("Baixa de Titulos - VISUALIZAR")
self.oHelper.CheckResult("E2_SALDO", "8.400,00")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT188
#Cancelamento de baixa total de título (Taxa contratada - Moeda 2 - Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T51041
def test_FINA080_CT188(self):
prefixo = "TIR"
titulo = "F080CT188"
parcela = " "
tipo = "NF "
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.SetParameters()
#Data definida no CT147
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("27/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Outras Ações", "Cancelar Baixa")
self.oHelper.SetButton("Confirmar")
# verifica se foi cancelado
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Visualizar")
self.oHelper.WaitShow("Baixa de Titulos - VISUALIZAR")
self.oHelper.CheckResult("E2_SALDO", "1.000,00")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT189
#Cancelamento e exclusão de baixa parcial de título (Taxa contratada - Moeda 2 - Fornecedor PJ - TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T51042
def test_FINA080_CT189(self):
prefixo = "TIR"
titulo = "F080CT189"
parcela = " "
tipo = "NF "
#Parametrização default
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.SetParameters()
#Data definida no CT147
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("27/04/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Outras Ações", "Cancelar Baixa")
self.oHelper.ClickListBox("TIR F080CT189 NF FINA01 01 20/04/2020 1.400,00 02")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
# verifica se foi cancelado
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Visualizar")
self.oHelper.WaitShow("Baixa de Titulos - VISUALIZAR")
self.oHelper.CheckResult("E2_SALDO", "1.000,00")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT192
#Baixa e cancelamento de título em moeda 1, sem impostos com banco moeda 2 - TIR
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T51722
def test_FINA080_CT192(self):
prefixo = "TIR"
titulo = "F080CT192"
parcela = " "
tipo = "NF "
banco = "002"
agencia = "08000"
conta = "080110"
#Parametrização
self.oHelper.AddParameter("MV_MOEDBCO", "", "T", "T", "T")
self.oHelper.SetParameters()
time.sleep(30)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("09/06/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
# Baixa do título
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("= Valor Pago", "384,62")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
#Cancelamento da Baixa
self.oHelper.SetButton("Outras Ações", "Cancelar Baixa")
self.oHelper.SetButton("Confirmar")
# verifica se foi cancelado
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Visualizar")
self.oHelper.WaitShow("Baixa de Titulos - VISUALIZAR")
self.oHelper.CheckResult("E2_SALDO", "1.000,00")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT193
#Baixar título moeda 1, com retenção de INSS/ISS na emissão e PCC/IRF na baixa, utilizando banco moeda 2.
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T51723
def test_FINA080_CT193(self):
prefixo = "TIR"
titulo = "F080CT193"
parcela = " "
tipo = "NF "
banco = "002"
agencia = "08000"
conta = "080110"
#Parametrização CT192
#self.oHelper.AddParameter("MV_MOEDBCO", "", "T", "T", "T")
#self.oHelper.SetParameters()
#Definido no CT192
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("09/06/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
# Baixa do título
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckHelp(text='FA100NAT',button='Fechar')
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT194
#Baixa parcial de título moeda 1, sem impostos, com banco moeda 3
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T51724
def test_FINA080_CT194(self):
prefixo = "TIR"
titulo = "F080CT194"
parcela = " "
tipo = "NF "
banco = "003"
agencia = "08000"
conta = "080110"
#Parametrização CT192
#self.oHelper.AddParameter("MV_MOEDBCO", "", "T", "T", "T")
#self.oHelper.SetParameters()
#Definido no CT192
#time.sleep(5)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("09/06/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("= Valor Pago", "1.200,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("= Valor Pago", "356,42")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT196
#Baixa total de título moeda 2, sem impostos, com banco moeda 1, multa, taxa de permanencia e correcao monetaria
#author fabio.casagrande
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T51813
def test_FINA080_CT196(self):
prefixo = "TIR"
titulo = "F080CT196"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
#Parametrização
self.oHelper.AddParameter("MV_TIPOCM", "", "O", "O", "O")
self.oHelper.SetParameters()
#Definido no CT196
time.sleep(30)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("18/02/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Taxa contratada", "4,0000")
self.oHelper.SetValue("+ Multa", "300,00")
self.oHelper.CheckResult("+ Tx.Permanenc.", "82,00")
self.oHelper.CheckResult("= Valor Pago", "40.382,00")
self.oHelper.CheckResult("Valor US$", "10.095,50")
self.oHelper.CheckResult("+ Corr.Monetária", "15.000,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT199
#Baixa total em lote de título em Moeda 2 com atraso (Com PCC/IRF na baixa e ISS na emissão - banco moeda 1, taxa do contratada – TIR)
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T51855
def test_FINA080_CT199(self):
banco = "001"
agencia = "08000"
conta = "080110"
ntitulos = '2'
lote ='LTC199'
natureza='FIN080SINS'
titulo1 = "LOTACT199"
titulo2 = "LOTBCT199"
#Parametrização
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
self.oHelper.AddParameter("MV_TIPOCM", "", "O", "O", "O")
self.oHelper.SetParameters()
time.sleep(30)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("12/06/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Outras Ações", "Lote")
self.oHelper.SetValue("cBanco", banco, name_attr=True)
self.oHelper.SetValue("cAgencia", agencia, name_attr=True)
self.oHelper.SetValue("cConta", conta, name_attr=True)
self.oHelper.SetValue("nNroTit", ntitulos, name_attr=True)
self.oHelper.SetValue("cLoteFin", lote, name_attr=True)
self.oHelper.SetValue("DVENCINI", "12/06/2020", name_attr=True)
self.oHelper.SetValue("DVENCFIM", "12/06/2020", name_attr=True)
self.oHelper.SetValue("cNatDe", natureza, name_attr=True)
self.oHelper.SetValue("cNatAte", natureza, name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.ClickBox("No. Titulo", titulo1)
self.oHelper.ClickBox("No. Titulo", titulo2)
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Taxa contratada", "4,5000")
self.oHelper.SetValue("+ Multa", "100,00")
self.oHelper.CheckResult("- Irrf", "67,50")
self.oHelper.CheckResult("- Pis", "29,25")
self.oHelper.CheckResult("- Cofins", "135,00")
self.oHelper.CheckResult("- Csll", "45,00")
#self.oHelper.CheckResult("= Valor Pago", "4.098,25")
self.oHelper.CheckResult("Valor US$", "910,72")
self.oHelper.CheckResult("+ Corr.Monetária", "1.472,50")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Taxa contratada", "4,0000")
self.oHelper.SetValue("+ Multa", "50,00")
self.oHelper.CheckResult("- Irrf", "60,00")
self.oHelper.CheckResult("- Pis", "26,00")
self.oHelper.CheckResult("- Cofins", "120,00")
self.oHelper.CheckResult("- Csll", "40,00")
#self.oHelper.CheckResult("= Valor Pago", "3.604,00")
self.oHelper.CheckResult("Valor US$", "901,00")
self.oHelper.CheckResult("+ Corr.Monetária", "1.615,00")
self.oHelper.SetButton("Salvar")
self.oHelper.CheckHelp(text='TOTGERAL',button='Fechar')
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT203
#Baixa parcial de título moeda 2, taxa dia, com ISS e INSS na emissão e IRF e PCC na baixa, com correção monetária
# e taxa de permanência calculada em um banco moeda 1 - TIR
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T52048
def test_FINA080_CT203(self):
prefixo = "TIR"
titulo = "F080CT203"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
#Parametrização
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
self.oHelper.AddParameter("MV_BP10925", "", "2", "2", "2")
self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
self.oHelper.SetParameters()
time.sleep(30)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("22/06/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("= Valor Pago", "6.000,00")
self.oHelper.CheckResult("Taxa contratada", "3,8000")
self.oHelper.CheckResult("+ Tx.Permanenc.", "38,00")
self.oHelper.CheckResult("- Irrf", "89,43")
self.oHelper.CheckResult("- Pis", "38,75")
self.oHelper.CheckResult("- Cofins", "178,86")
self.oHelper.CheckResult("- Csll", "59,62")
self.oHelper.CheckResult("= Valor Pago", "5.633,34")
self.oHelper.CheckResult("Valor US$", "1.482,46")
self.oHelper.CheckResult("+ Corr.Monetária", "1.482,46")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Taxa contratada", "2,5000")
self.oHelper.CheckResult("+ Tx.Permanenc.", "0,00")
self.oHelper.CheckResult("- Irrf", "316,16")
self.oHelper.CheckResult("- Pis", "137,00")
self.oHelper.CheckResult("- Cofins", "632,32")
self.oHelper.CheckResult("- Csll", "210,77")
self.oHelper.CheckResult("= Valor Pago", "15.781,38")
self.oHelper.CheckResult("Valor US$", "6.312,55")
self.oHelper.CheckResult("+ Corr.Monetária", "-1.893,77")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT204
#Baixa Parcial de título Moeda 2 (banco moeda 2, taxa do Contratada, MV_EASYFIN)
#author <NAME>
#since 24/06/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T52150
def test_FINA080_CT204(self):
prefixo = "TIR"
titulo = "F080CT204"
parcela = " "
tipo = "NF "
banco = "002"
agencia = "08000"
conta = "080110"
self.oHelper.WaitShow("Baixa de Titulos")
#Parametrização
self.oHelper.AddParameter("MV_EASYFIN", "", "S", "S", "S")
self.oHelper.SetParameters()
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("= Valor Pago", "600,00")
self.oHelper.CheckResult("Valor US$", "600,00")
self.oHelper.CheckResult("+ Corr.Monetária", "0,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("= Valor Pago", "1.400,00")
self.oHelper.CheckResult("Valor US$", "1.400,00")
self.oHelper.CheckResult("+ Corr.Monetária", "0,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT233
#Baixa parcial de título em dólar com banco em reais, e retenção de INSS/ISS na emissão de PCC/IRF na baixa,
# informando valores em dólar, com taxa do dia
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T52635
def test_FINA080_CT233(self):
prefixo = "TIR"
titulo = "F080CT233"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
#Parametrização
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
self.oHelper.AddParameter("MV_EASYFIN", "", "N", "N", "N")
self.oHelper.SetParameters()
time.sleep(30)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("22/06/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Valor US$", "4.000,00")
self.oHelper.CheckResult("Taxa contratada", "3,8000")
self.oHelper.CheckResult("- Irrf", "228,00")
self.oHelper.CheckResult("- Pis", "98,80")
self.oHelper.CheckResult("- Cofins", "456,00")
self.oHelper.CheckResult("- Csll", "152,00")
self.oHelper.CheckResult("= Valor Pago", "14.265,20")
self.oHelper.CheckResult("Valor US$", "3.754,00")
self.oHelper.CheckResult("+ Corr.Monetária", "3.754,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("- Irrf", "342,00")
self.oHelper.CheckResult("- Pis", "148,20")
self.oHelper.CheckResult("- Cofins", "684,00")
self.oHelper.CheckResult("- Csll", "228,00")
self.oHelper.CheckResult("= Valor Pago", "15.317,80")
self.oHelper.CheckResult("Valor US$", "4.031,00")
self.oHelper.CheckResult("+ Corr.Monetária", "4.031,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT234
#Baixa parcial de título em dólar com banco em reais, e retenção de INSS/ISS na emissão de PCC/IRF na baixa,
# informando valores em dólar, com taxa contratada
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T52636
def test_FINA080_CT234(self):
prefixo = "TIR"
titulo = "F080CT234"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
#Parametrização
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_BP10925", "", "2", "2", "2")
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.AddParameter("MV_EASYFIN", "", "N", "N", "N")
#self.oHelper.SetParameters()
#time.sleep(30)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("22/06/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Valor US$", "4.000,00")
self.oHelper.CheckResult("Taxa contratada", "2,3500")
self.oHelper.CheckResult("- Irrf", "141,00")
self.oHelper.CheckResult("- Pis", "61,10")
self.oHelper.CheckResult("- Cofins", "282,00")
self.oHelper.CheckResult("- Csll", "94,00")
self.oHelper.CheckResult("= Valor Pago", "8.821,90")
self.oHelper.CheckResult("Valor US$", "3.754,00")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("- Irrf", "211,50")
self.oHelper.CheckResult("- Pis", "91,65")
self.oHelper.CheckResult("- Cofins", "423,00")
self.oHelper.CheckResult("- Csll", "141,00")
self.oHelper.CheckResult("= Valor Pago", "9.472,85")
self.oHelper.CheckResult("Valor US$", "4.031,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT240
#Baixa parcial de título em dólar com banco em reais, e retenção de INSS/ISS na emissão de PCC/IRF na baixa,
# com acréscimo e taxa de permanência, com taxa do dia
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T52718
def test_FINA080_CT240(self):
prefixo = "TIR"
titulo = "F080CT240"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
#Parametrização
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
self.oHelper.AddParameter("MV_IMPBAIX", "", "1", "1", "1")
self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.AddParameter("MV_EASYFIN", "", "N", "N", "N")
self.oHelper.SetParameters()
time.sleep(30)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("22/06/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("= Valor Pago", "4.000,00")
self.oHelper.CheckResult("Taxa contratada", "3,8000")
self.oHelper.CheckResult("+ Acrescimo", "100,00")
self.oHelper.CheckResult("+ Tx.Permanenc.", "38,00")
self.oHelper.CheckResult("- Irrf", "60,00")
self.oHelper.CheckResult("- Pis", "26,00")
self.oHelper.CheckResult("- Cofins", "120,00")
self.oHelper.CheckResult("- Csll", "40,00")
self.oHelper.CheckResult("= Valor Pago", "4.000,00")
self.oHelper.CheckResult("Valor US$", "1.052,63")
self.oHelper.CheckResult("+ Corr.Monetária", "1.052,63")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("+ Acrescimo", "0,00")
self.oHelper.CheckResult("+ Tx.Permanenc.", "0,00")
self.oHelper.CheckResult("- Irrf", "516,27")
self.oHelper.CheckResult("- Pis", "223,71")
self.oHelper.CheckResult("- Cofins", "1.032,54")
self.oHelper.CheckResult("- Csll", "344,18")
self.oHelper.CheckResult("= Valor Pago", "25.975,29")
self.oHelper.CheckResult("Valor US$", "6.835,60")
self.oHelper.CheckResult("+ Corr.Monetária", "6.835,60")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT241
#Baixa total de título em dólar com banco em reais, e retenção de INSS/ISS na emissão de PCC/IRF na baixa,
# informando desconto, com taxa contratada - TIR
#author <NAME>
#since 16/04/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T52719
def test_FINA080_CT241(self):
prefixo = "TIR"
titulo = "F080CT241"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
#Parametrização
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.AddParameter("MV_EASYFIN", "", "N", "N", "N")
#self.oHelper.SetParameters()
#time.sleep(30)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("22/06/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("- Descontos", "100,00")
self.oHelper.CheckResult("- Irrf", "351,00")
self.oHelper.CheckResult("- Pis", "152,10")
self.oHelper.CheckResult("- Cofins", "702,00")
self.oHelper.CheckResult("- Csll", "234,00")
self.oHelper.CheckResult("= Valor Pago", "18.200,90")
self.oHelper.CheckResult("Valor US$", "7.745,06")
self.oHelper.CheckResult("+ Corr.Monetária", "0,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT243
# MV_MB10925 = 1 Alteração do motivo de baixa de DACAO para DEBITO para recalcular os impostos
#author <NAME>
#since 23/07/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T37573
def test_FINA080_CT243(self):
prefixo = "FIN"
titulo = "MB001 "
parcela = " "
tipo = "NF "
banco = "001"
agencia = "0001"
conta = "000001"
#Parametrização
self.oHelper.AddParameter("MV_MB10925", "", "1", "1", "1")
self.oHelper.SetParameters()
time.sleep(30)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("23/07/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("- Irrf", "150,00")
self.oHelper.CheckResult("- Pis", "65,00")
self.oHelper.CheckResult("- Cofins", "300,00")
self.oHelper.CheckResult("- Csll", "100,00")
self.oHelper.CheckResult("= Valor Pago", "7.785,00")
self.oHelper.SetValue("Mot.Baixa", "DACAO")
self.oHelper.CheckResult("- Irrf", "0,00")
self.oHelper.CheckResult("- Pis", "0,00")
self.oHelper.CheckResult("- Cofins", "0,00")
self.oHelper.CheckResult("- Csll", "0,00")
self.oHelper.CheckResult("= Valor Pago", "8.400,00")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT251
#Baixa parcial de título em dólar com banco em reais, acrescimo, taxa contratada,
# retenção de INSS/ISS na emissão, PCC/IRF na baixa, informando valores em dólar
#author <NAME>
#since 12/08/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T53373
def test_FINA080_CT251(self):
prefixo = "TIR"
titulo = "F080CT251"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
#Parametrização
#self.oHelper.AddParameter("MV_BX10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_MRETISS", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_IMPBAIX", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_BP10925", "", "1", "1", "1")
#self.oHelper.AddParameter("MV_TIPOCM", "", "T", "T", "T")
#self.oHelper.AddParameter("MV_EASYFIN", "", "N", "N", "N")
#self.oHelper.SetParameters()
#time.sleep(30)
#self.oHelper.SetButton("x")
#self.oHelper.ChangeEnvironment("23/07/2020","T1", "D MG 01 ","06")
#self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
#Definido no CT110
#self.oHelper.SetKey("F12")
#self.oHelper.WaitShow("Parametros")
#self.oHelper.SetValue("Mostra Lanc Contab ?" ,"Nao")
#self.oHelper.SetValue("Contabiliza On Line ?" ,"Nao")
#self.oHelper.SetValue("Utiliza Banco Anterior ?" ,"Nao")
#self.oHelper.SetButton("Ok")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("Taxa contratada", "3,8000")
self.oHelper.SetValue("Valor US$", "2.000,00")
self.oHelper.CheckResult("Taxa contratada", "3,8000")
self.oHelper.CheckResult("- Irrf", "114,00")
self.oHelper.CheckResult("- Pis", "49,40")
self.oHelper.CheckResult("- Cofins", "228,00")
self.oHelper.CheckResult("- Csll", "76,00")
self.oHelper.CheckResult("= Valor Pago", "7.600,00")
self.oHelper.CheckResult("Valor US$", "2.000,00")
self.oHelper.CheckResult("+ Corr.Monetária", "2.000,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT263
#Entrar na tela da baixa
#Altear para motivo de baixa NORMAL,
#Alterara para motivo de baixa DACAO
#Validar o valor de pagamento.
#author <NAME>
#since 09/09/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/project/10231/testCase?folderId=2589
def test_FINA080_CT263(self):
prefixo = "FIN"
titulo = "FIN521311"
parcela = " "
tipo = "NF "
banco = "001"
agencia = "00001"
conta = "0000000001"
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "NORMAL")
self.oHelper.SetValue("Banco", banco)
self.oHelper.CheckResult("Agência", agencia)
self.oHelper.CheckResult("Conta", conta)
self.oHelper.SetValue("Mot.Baixa", "DACAO")
self.oHelper.CheckResult("Taxa contratada", "2,0000")
self.oHelper.CheckResult("= Valor Pago", "2.000,00")
self.oHelper.CheckResult("Valor US$", "1.000,00")
self.oHelper.CheckResult("+ Corr.Monetária", "0,00")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT264
#Entrar na tela da baixa
#Altear para motivo de baixa SPB_TESTE,
#Validar preenchimento das telas do SPB
#author <NAME>
#since 26/11/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T56222
def test_FINA080_CT264(self):
prefixo = "FIN"
titulo = "FIN000XX7"
parcela = " "
tipo = "NF "
#Parametrização default
self.oHelper.AddParameter("MV_USASPB ", "", "S", "S", "S")
self.oHelper.SetParameters()
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parcela}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "SPB")
#self.oHelper.WaitShow("Informado")
self.oHelper.SetValue("Baixado", "TED")
self.oHelper.SetValue("Tipo Pgto.", "03")
self.oHelper.SetValue("Hora Agendamento", "24:00")
self.oHelper.CheckHelp('VLDHORA','Fechar')
self.oHelper.SetValue("Hora Agendamento", "12:00")
self.oHelper.SetButton("Ok")
self.oHelper.CheckHelp('TOTVS','Fechar')
self.oHelper.SetValue("Baixado", "CIP")
self.oHelper.CheckResult("Tipo Pgto.", "03")
self.oHelper.CheckResult("Hora Agendamento", "12:00")
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#self.oHelper.RestoreParameters()
#{Protheus.doc} test_FINA080_CT266
#Entrar na tela da baixa e
#tentar realizar a baixa de um título referente ao PCC, que foi gerado na rotina FINA241
#e o título principal está em aberto.
#author <NAME>
#since 02/12/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T56225
def test_FINA080_CT266(self):
prefixo = "FIN"
titulo = "FIN000XX8"
parc1 = "1"
parc2 = "2"
parc3 = "3"
tipo = "TX "
#Parametrização default
self.oHelper.AddParameter("MV_BX10925 ", "", "1", "1", "1")
self.oHelper.AddParameter("MV_USASPB ", "", "N", "N", "N")
self.oHelper.SetParameters()
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parc1}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.CheckHelp('BXIMPBOR','Não')
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parc1}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.CheckHelp('BXIMPBOR','Sim')
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetButton("Cancelar")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parc2}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.CheckHelp('BXIMPBOR','Não')
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parc2}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.CheckHelp('BXIMPBOR','Sim')
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetButton("Cancelar")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parc3}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.CheckHelp('BXIMPBOR','Não')
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parc3}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.CheckHelp('BXIMPBOR','Sim')
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#self.oHelper.RestoreParameters()
#{Protheus.doc} test_FINA080_CT275
#Entrar na tela da baixa e
#alterar o valor do imposto em outras ações/retenção de impostos, confirmar e não realizar a baixa do título
#author <NAME>
#since 02/12/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T56226
def test_FINA080_CT275(self):
prefixo = "FIN"
titulo = "FIN000XX9"
parc1 = " "
tipo = "NF "
banco = "001"
agencia = "08000"
conta = "080110"
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("07/12/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
#Parametrização default
self.oHelper.AddParameter("MV_BX10925 ", "", "1", "1", "1")
self.oHelper.SetParameters()
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parc1}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("= Valor Pago", "9.535,00")
self.oHelper.SetButton("Outras Ações", "Retenção de Impostos")
self.oHelper.SetValue("Valor a Reter", "200,00", grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.CheckResult("= Valor Pago", "9.635,00")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT276
#Entrar na tela da baixa e tentar realizar a baixa de um título que esteja em borderô, com baixa com lote e conciliado.
#Entrar na tela da baixa e tentar realizar a baixa de um título que esteja conciliado.
#author <NAME>
#since 11/12/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T56427
def test_FINA080_CT276(self):
prefixo1 = "FIN"
titulo1 = "FIN000X13"
parc1 = " "
tipo1 = "NF "
prefixo2 = "FIN"
titulo2 = "FIN000X14"
parc2 = " "
tipo2 = "NF "
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("11/12/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo1}{titulo1}{parc1}{tipo1}")
self.oHelper.SetButton("Outras Ações", "Cancelar Baixa")
self.oHelper.CheckHelp('F080BORD','Fechar')
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo2}{titulo2}{parc2}{tipo2}")
self.oHelper.SetButton("Outras Ações", "Cancelar Baixa")
self.oHelper.CheckHelp('BXCONCIL','Fechar')
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT277
#Ativar o parâmetro MV_VLTITAD e tentar realizar a baixa em lote de um título cujo fornecedor
#já tenha um adiantamento existente.
#author <NAME>
#since 16/12/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T56428
def test_FINA080_CT277(self):
banco = "001"
agencia = "08000"
conta = "080110"
ntitulos = '1'
lote ='LTC277'
natureza ='FIN0000X13'
data = "16/12/2020"
prefixo = "FIN"
titulo = "FIN000X13"
parc = " "
tipo = "NF "
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("16/12/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
#Parametrização default
self.oHelper.AddParameter("MV_VLTITAD ", "", ".T.", ".T.", ".T.")
self.oHelper.SetParameters()
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parc}{tipo}")
self.oHelper.SetButton("Outras Ações", "Lote")
self.oHelper.SetValue("cBanco", banco, name_attr=True)
self.oHelper.SetValue("cAgencia", agencia, name_attr=True)
self.oHelper.SetValue("cConta", conta, name_attr=True)
self.oHelper.SetValue("nNroTit", ntitulos, name_attr=True)
self.oHelper.SetValue("cLoteFin", lote, name_attr=True)
self.oHelper.SetValue("DVENCINI", data, name_attr=True)
self.oHelper.SetValue("DVENCFIM", data, name_attr=True)
self.oHelper.SetValue("cNatDe", natureza, name_attr=True)
self.oHelper.SetValue("cNatAte", natureza, name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.ClickBox("No. Titulo", titulo)
self.oHelper.CheckHelp(text='TOTVS',button='Não')
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT280
#Simulação de Baixa do título com origem MNTA765/MNTA766, verificação do desconto
#author <NAME>
#since 18/12/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T56484
def test_FINA080_CT280(self):
prefixo = "MNT"
titulo = "000015 "
parc = "A "
tipo = "BOL"
banco = "001"
agencia = "08000"
conta = "080110"
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("18/12/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
#Parametrização default
self.oHelper.AddParameter("MV_NGMNTFI ", "", "S", "S", "S")
self.oHelper.SetParameters()
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parc}{tipo}")
self.oHelper.SetButton("Baixar")
self.oHelper.WaitShow("Baixa de Titulos - BAIXAR")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.CheckResult("- Descontos", "25,54")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT281
#Simulação de baixa de título com cheque amarrado.
#author <NAME>
#since 18/12/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-T56485
def test_FINA080_CT281(self):
banco = "001"
agencia = "08000"
conta = "080110"
ntitulos = '1'
lote ='LTC281'
natureza ='FIN0000X17'
data = "18/12/2020"
prefixo = "FIN"
titulo = "FIN000X17"
parc = " "
tipo = "NF "
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("21/12/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parc}{tipo}")
self.oHelper.SetButton("Outras Ações", "Lote")
self.oHelper.SetValue("cBanco", banco, name_attr=True)
self.oHelper.SetValue("cAgencia", agencia, name_attr=True)
self.oHelper.SetValue("cConta", conta, name_attr=True)
self.oHelper.SetValue("nNroTit", ntitulos, name_attr=True)
self.oHelper.SetValue("cLoteFin", lote, name_attr=True)
self.oHelper.SetValue("DVENCINI", data, name_attr=True)
self.oHelper.SetValue("DVENCFIM", data, name_attr=True)
self.oHelper.SetValue("cNatDe", natureza, name_attr=True)
self.oHelper.SetValue("cNatAte", natureza, name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.ClickBox("No. Titulo", titulo)
self.oHelper.SetButton("Salvar")
self.oHelper.CheckHelp(text='CH_BAIXA',button='Fechar')
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "NORMAL")
self.oHelper.SetValue("- Descontos", "50,00")
self.oHelper.SetButton("Salvar")
self.oHelper.CheckHelp(text='JACHQSTIT',button='Fechar')
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#{Protheus.doc} test_FINA080_CT285
#Ativar os parâmetros MV_FINVDOC e MV_MULNATP para realização de baixa em lote com contabilização.
#author <NAME>
#since 23/12/2020
#version 1.0
#See FAZER KANOAH
def test_FINA080_CT285(self):
banco = "001"
agencia = "08000"
conta = "080110"
ntitulos = '1'
lote ='LTC285'
natureza ='FIN0000X20'
data = "23/12/2020"
prefixo = "FIN"
titulo = "FIN000X20"
parc = " "
tipo = "NF "
time.sleep(5)
self.oHelper.SetButton("x")
self.oHelper.ChangeEnvironment("23/12/2020","T1", "D MG 01 ","06")
self.oHelper.Program("FINA080")
#Parametrização default
self.oHelper.AddParameter("MV_FINVDOC ", "", "1", "1", "1")
self.oHelper.AddParameter("MV_MULNATP ", "", ".T.", ".T.", ".T.")
self.oHelper.SetParameters()
self.oHelper.WaitShow("Baixa de Titulos")
self.oHelper.SearchBrowse(f"D MG 01 {prefixo}{titulo}{parc}{tipo}")
self.oHelper.SetButton("Outras Ações", "Lote")
self.oHelper.SetValue("cBanco", banco, name_attr=True)
self.oHelper.SetValue("cAgencia", agencia, name_attr=True)
self.oHelper.SetValue("cConta", conta, name_attr=True)
self.oHelper.SetValue("nNroTit", ntitulos, name_attr=True)
self.oHelper.SetValue("cLoteFin", lote, name_attr=True)
self.oHelper.SetValue("DVENCINI", data, name_attr=True)
self.oHelper.SetValue("DVENCFIM", data, name_attr=True)
self.oHelper.SetValue("cNatDe", natureza, name_attr=True)
self.oHelper.SetValue("cNatAte", natureza, name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.ClickBox("No. Titulo", titulo)
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Baixa de Titulos - LOTE")
self.oHelper.SetValue("Mot.Baixa", "DEBITO CC")
self.oHelper.SetValue("Banco", banco)
self.oHelper.SetValue("Agência", agencia)
self.oHelper.SetValue("Conta", conta)
self.oHelper.SetValue("", True)
self.oHelper.SetButton("Salvar")
#Tela de rateio por multiplas-naturezas
#Primeira linha
self.oHelper.SetValue('Natureza','0001', grid=True, grid_number=1)
self.oHelper.SetValue('Vlr.Movim.','500,00', grid=True, grid_number=1)
self.oHelper.LoadGrid()
#Segunda linha
self.oHelper.SetKey("DOWN", grid=True, grid_number=1)
self.oHelper.SetValue('Natureza','001', grid=True, grid_number=1)
self.oHelper.SetValue('Vlr.Movim.','500,00', grid=True, grid_number=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.CheckHelp(text='TOTGERAL',button='Fechar')
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGAFIN/FINA560TESTCASE.py
```python
import unittest
import time
from tir import Webapp
from datetime import datetime
DateSystem = datetime.today().strftime('%d/%m/%Y')
"""-------------------------------------------------------------------
/*/{Protheus.doc} FINA560TestCase
TIR - Casos de testes da rotina movimentos de caixinha
@author <NAME>
@since 23/06/2020
@version 12
-------------------------------------------------------------------"""
class FINA560(unittest.TestCase):
#-------------------------------------------
# Inicialiação setUpClass para TIR - FINA560
#-------------------------------------------
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAFIN",DateSystem,"T1","D MG 01 ","06")
inst.oHelper.Program('FINA560')
#-----------------------------------------
#{Protheus.doc} FINA560_CT010
#Valida褯 de inclus䯠de adiantamento com valor maior que o saldo.
#author <NAME>
#since 23/06/2020
#version 1.0
#See https://jiraproducao.totvs.com.br/secure/Tests.jspa#/testCase/GTSER-
#-----------------------------------------
def test_FINA560_CT010(self):
self.oHelper.WaitShow("Movimento do Caixinha")
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch('D MG 01')
self.oHelper.SetValue('EU_CAIXA','110')
self.oHelper.SetValue('EU_TIPO','01')
self.oHelper.SetValue('EU_HISTOR','TESTE VALOR')
self.oHelper.SetValue('EU_NRCOMP','00001')
self.oHelper.SetValue('EU_VALOR',"10.000,00")
self.oHelper.SetValue('EU_BENEF','BENEF. TESTE')
self.oHelper.SetValue('EU_CAIXA','120')
self.oHelper.SetButton('Salvar')
self.oHelper.CheckHelp(text='FA560SALDO',button='Fechar')
self.oHelper.WaitShow("Movimento do Caixinha")
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
#-------------------------------------------
# Encerramento class para TIR - FINA560
#-------------------------------------------
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAFIS/FISA001TESTCASE.py
```python
from tir import Webapp
import unittest
from datetime import datetime
DateSystem = datetime.today().strftime('%d/%m/%Y')
class FISA001(unittest.TestCase):
@classmethod
def setUpClass(inst):
'''
SETUP
Test Case Initial Setup
'''
#Endereco do webapp e o nome do Browser
inst.oHelper = Webapp()
DateSystem = datetime.today()
#Parametros de inicializacao
inst.oHelper.Setup("SIGAFIS",DateSystem.strftime('%d/%m/%Y'),"T1","XIFIS26","09")
#Nome da rotina do Caso de Teste
inst.oHelper.Program("FISA001")
def test_FISA001_APURACAO(self):
DateSystem = datetime.today()
self.oHelper.ClickTree('Apuração EFD Contribuições > Processar Apuração da EFD Contribuições')
self.oHelper.SetValue('Data Inicial: ?',DateSystem.strftime('%d/%m/%Y'))
self.oHelper.SetValue('Data Final: ?',DateSystem.strftime('%d/%m/%Y'))
self.oHelper.SetValue('Livro: ?','*')
self.oHelper.SetValue('Seleciona Filial ?','2')
self.oHelper.SetValue('Tributos: ?','1')
self.oHelper.SetValue('Regime PIS/COFINS: ?','1')
self.oHelper.SetValue('PIS Folha de Salario ?','2')
self.oHelper.SetValue('Sociedade Cooperativa ?','2')
self.oHelper.SetValue('Instituicao Financeira ?','2')
self.oHelper.SetValue('Diferimento ?','2')
self.oHelper.SetValue('Cupom Fiscal ?','2')
self.oHelper.SetValue('Detalhamento Regime Caixa ?','4')
self.oHelper.SetValue('Gera Titulo ?','2')
self.oHelper.SetValue('Contabiliza ?','2')
self.oHelper.SetValue('Opção Gravação ?','1')
self.oHelper.SetValue('Cod. Receita Servico ?','')
self.oHelper.SetValue('Cod. Receita Demais Operacoe ?','')
self.oHelper.SetValue('Indicador Natureza PJ ?','')
self.oHelper.SetValue('Processa Retenções - Saídas ?','1')
self.oHelper.SetValue('Indicador Regime Cumulativo ? ','1')
self.oHelper.SetButton('OK')
self.oHelper.WaitShow('Apuração Processada com Sucesso')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Finalizar')
self.oHelper.WaitShow('TOTVS - Filial: XIFIS26 - Filial SAO PAUL')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_FISA001_DEMAISDOCS(self):
#FONTE FISA048
self.oHelper.ClickTree('Apuração EFD Contribuições > Demais Documentos PIS/COFINS')
self.oHelper.SetButton('Incluir')
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('OK')
self.oHelper.SetValue('CF8_TPREG','2')
self.oHelper.SetValue('CF8_INDOPE','1')
self.oHelper.SetValue('CF8_CLIFOR','SP0001')
self.oHelper.SetValue('CF8_LOJA','01')
self.oHelper.SetValue('CF8_DTOPER',DateSystem)
self.oHelper.SetValue('CF8_VLOPER','1000,00')
self.oHelper.SetValue('CF8_CSTPIS','01')
self.oHelper.SetValue('CF8_CSTCOF','01')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('CF8_INDOPE','2')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('Outras Ações', 'Excluir', 2)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_FISA001_DEDPISCOF(self):
#FONTE FISA041
self.oHelper.ClickTree('Apuração EFD Contribuições > Deduções Diversas PIS COFINS')
self.oHelper.SetButton('Incluir')
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('OK')
self.oHelper.SetValue('CF2_PER','102019')
self.oHelper.SetValue('CF2_ORIDED','99')
self.oHelper.SetValue('CF2_INDNAT','0')
self.oHelper.SetValue('CF2_DEDPIS','16,50')
self.oHelper.SetValue('CF2_DEDCOF','76,00')
self.oHelper.SetValue('CF2_BASE','1000,00')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('CF2_DEDPIS','18,00')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('Outras Ações', 'Excluir', 2)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_FISA001_AJUSTEPISCOF(self):
#FONTE FISA042
self.oHelper.ClickTree('Apuração EFD Contribuições > Ajuste de PIS/COFINS e CPRB')
self.oHelper.SetButton('Incluir')
self.oHelper.SetValue('CF5_INDAJU','0')
self.oHelper.SetValue('CF5_PISCOF','0')
self.oHelper.SetValue('CF5_VALAJU','500,00')
self.oHelper.SetValue('CF5_CODAJU','05')
self.oHelper.SetValue('CF5_DTREF',DateSystem)
self.oHelper.SetValue('CF5_TPAJST','2')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("000001 ")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('CF5_PISCOF','1')
self.oHelper.SetValue('CF5_TPAJST','2')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("000001 ")
self.oHelper.SetButton('Outras Ações', 'Excluir', 2)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_FISA001_AJUSBCPISCOF(self):
#FONTE FISA210
self.oHelper.ClickTree('Apuração EFD Contribuições > Ajustes Base de Cálculo de PIS e COFINS')
self.oHelper.SetButton('Incluir')
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('OK')
self.oHelper.SetValue('F2Z_TRIB','1')
self.oHelper.SetValue('F2Z_INDAJU','1')
self.oHelper.SetValue('F2Z_VALAJU','200,00')
self.oHelper.SetValue('F2Z_CODAJU','02')
self.oHelper.SetValue('F2Z_CODCON','01')
self.oHelper.SetValue('F2Z_DTREF',DateSystem)
self.oHelper.SetValue('F2Z_CNPJ','86845790000121')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('F2Z_CODAJU','41')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('Outras Ações', 'Excluir', 2)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_FISA001_CONTCREDPIS(self):
#FONTE FISA044
self.oHelper.ClickTree('Apuração EFD Contribuições > Controle de saldo de Crédito de PIS')
self.oHelper.SetButton('Incluir')
self.oHelper.SetValue('Período','102019')
self.oHelper.SetValue('Cod Cred','101')
self.oHelper.SetValue('Tot. Cred','500,00')
self.oHelper.SetValue('Cred. Utiliz','300,00')
self.oHelper.SetValue('Cred. Disp','200,00')
self.oHelper.SetValue('Ano.Origem','2019')
self.oHelper.SetValue('Mes.Origem','10')
self.oHelper.SetValue('Origem Créd','01')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("102019 ")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('Cred. Utiliz','400,00')
self.oHelper.SetValue('Cred. Disp','100,00')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("102019 ")
self.oHelper.SetButton('Outras Ações', 'Excluir', 2)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_FISA001_CONTCREDCOF(self):
#FONTE FISA045
self.oHelper.ClickTree('Apuração EFD Contribuições > Controle de saldo de Crédito da COFINS')
self.oHelper.SetButton('Incluir')
self.oHelper.SetValue('Período','102019')
self.oHelper.SetValue('Cod Cred','101')
self.oHelper.SetValue('Tot. Cred','1500,00')
self.oHelper.SetValue('Cred. Utiliz','800,00')
self.oHelper.SetValue('Cred. Disp','700,00')
self.oHelper.SetValue('Ano.Origem','2019')
self.oHelper.SetValue('Mes.Origem','10')
self.oHelper.SetValue('Origem Créd','01')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("102019 ")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('Cred. Utiliz','1000,00')
self.oHelper.SetValue('Cred. Disp','500,00')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("102019 ")
self.oHelper.SetButton('Outras Ações', 'Excluir', 2)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_FISA001_RESCREDPISCOF(self):
#FONTE FISA050
self.oHelper.ClickTree('Apuração EFD Contribuições > Ressarcimento de crédito de PIS e COFINS ')
self.oHelper.SetButton('Incluir')
self.oHelper.SetValue('PIS/COF','0')
self.oHelper.SetValue('Período','102019')
self.oHelper.SetValue('Origem','012019')
self.oHelper.SetValue('Codigo','101')
self.oHelper.SetValue('Vlr Ress','700,00')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("0 ")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('Vlr Comp','1000,00')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("0 ")
self.oHelper.SetButton('Outras Ações', 'Excluir', 2)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_FISA001_DEMAISRETENCOES(self):
#FONTE FISA006
self.oHelper.ClickTree('Apuração EFD Contribuições > Demais Retenções')
self.oHelper.SetButton('Incluir')
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('OK')
self.oHelper.SetValue('Dt.retenção',DateSystem)
self.oHelper.SetValue('Ind.Nat.Ret','03')
self.oHelper.SetValue('Base Ret','200,00')
self.oHelper.SetValue('Tot.Retido','1,30')
self.oHelper.SetValue('Regime','1')
self.oHelper.SetValue('CNPJ','86845790000121')
self.oHelper.SetValue('Indic.Ret.','0')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('Indic.Ret.','1')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('Outras Ações', 'Excluir', 2)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_FISA001_PERDISPEFDPC(self):
#FONTE FISA089
self.oHelper.ClickTree('Apuração EFD Contribuições > Período Dispensado da EFD-Contribuições')
self.oHelper.SetButton('Incluir')
self.oHelper.SetValue('Mês EFD','02')
self.oHelper.SetValue('Ano EFD.','2019')
self.oHelper.SetValue('Mês Disp.','01')
self.oHelper.SetValue('Ano Disp.','2019')
self.oHelper.SetValue('Motivo','04')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("02 ")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('Motivo','99')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("02 ")
self.oHelper.SetButton('Outras Ações', 'Excluir', 2)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_FISA001_RECTRANSMISSAO(self):
#FONTE FISA211
self.oHelper.ClickTree('Apuração EFD Contribuições > Recibos de Transmissão do SPED')
self.oHelper.SetButton('Incluir')
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('OK')
self.oHelper.SetValue('Mês','02')
self.oHelper.SetValue('Ano','2019')
self.oHelper.SetValue('Num Recibo','2019120390901940149103KAKDNXL9348928W912O')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('Mês','03')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SearchBrowse("XIFIS26 ")
self.oHelper.SetButton('Outras Ações', 'Excluir', 2)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
self.oHelper.SetButton('Sair da página')
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAFIS/FISA008TESTCASE.py
```python
from tir import Webapp
import unittest
from datetime import datetime
class FISA008(unittest.TestCase):
@classmethod
def setUpClass(inst):
'''
SETUP
Test Case Initial Setup
'''
#Endereço do webapp e o nome do Browser
inst.oHelper = Webapp()
DateSystem = datetime.today()
#Parametros de inicializaçao
inst.oHelper.Setup("SIGAFIS",DateSystem.strftime('%d/%m/%Y'),"T1","XIFIS26","09")
#Nome da rotina do Caso de Teste
inst.oHelper.Program("FISA008")
def test_FISA008_001(self):
DateSystem = datetime.today()
#Parâmetros de geração do arquivo
self.oHelper.SetValue('Data Inicial: ?',DateSystem.strftime('%d/%m/%Y'))
self.oHelper.SetValue('Data Final: ?',DateSystem.strftime('%d/%m/%Y'))
self.oHelper.SetValue('Livro: ?','*')
self.oHelper.SetValue('Seleciona Filial ?','2')
self.oHelper.SetValue('Diretorio ?','')
self.oHelper.SetValue('Arquivo ?','FISA008.TXT')
self.oHelper.SetValue('Agrupa por CNPJ ?','2')
self.oHelper.SetValue('Regime PIS/COFINS ?','1')
self.oHelper.SetValue('Tipo Escrituracao ?','0')
self.oHelper.SetValue('Indicador Situacao Especial ?','')
self.oHelper.SetValue('Indicaodor Natureza PJ ?','00')
self.oHelper.SetValue('Atividade Preponderante?','0')
self.oHelper.SetValue('Numero do Recibo ?','2019120390901940149103KAKDNXL9348928W912O')
self.oHelper.SetValue('Sociedade Cooperativa ?','')
self.oHelper.SetValue('Tipo Contribuicao ?','1')
self.oHelper.SetValue('Indicador Regime Cumulativo ?','1')
self.oHelper.SetValue('Indicador Bloco I ?','04')
#self.oHelper.ClickBox('Indicador NFe/Cupom ?','1-Consolidado ')
self.oHelper.SetValue('Gera Cupom Fiscal ?','1')
self.oHelper.SetValue('Gera Bloco P ?','1')
self.oHelper.SetValue('Incidencia Tributaria (0145) ?','1')
self.oHelper.SetValue('Gera Registro 0400 ?','1')
self.oHelper.SetValue('Dispensa ECD - 1.774/2017?','1')
self.oHelper.SetButton('OK')
#Parâmetros do Contabilista
self.oHelper.SetValue('Nome ?','<NAME>')
self.oHelper.SetValue('CNPJ ?','')
self.oHelper.SetValue('CPF ?','48769306869')
self.oHelper.SetValue('CRC ?','11111111111')
self.oHelper.SetValue('CEP ?','03443000')
self.oHelper.SetValue('Cod. Municipio ?','3550308')
self.oHelper.SetValue('Endereco ?','Rua Baquia')
self.oHelper.SetValue('Numero ?','736')
self.oHelper.SetValue('Complemento ?','TERREO')
self.oHelper.SetValue('Bairro ?','Nova Manchester')
self.oHelper.SetValue('Telefone ?','1598130992')
self.oHelper.SetValue('Fax ?','1598130992')
self.oHelper.SetValue('Email ?','<EMAIL>')
self.oHelper.SetButton('OK')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Finalizar')
self.oHelper.AssertTrue()
self.oHelper.SetButton('Sair da página')
@classmethod
def tearDownClass(inst):
'''
Method that finishes the test case.
'''
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAFIS/MATA940TESTCASE.py
```python
from tir import Webapp
import unittest
from datetime import datetime
class MATA940(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
DateSystem = datetime.today()
inst.oHelper.Setup('SIGAFIS', DateSystem.strftime(
'%d/%m/%Y'), 'T1', 'X FIS16', '09')
inst.oHelper.Program('MATA940')
def test_MATA940_001(self):
'''
Test Case 001
'''
# self.oHelper.SetButton('Livros Fiscais (1)')
# self.oHelper.SetButton('Arq. Magneticos (1)')
# self.oHelper.SetButton('Sintegra')
# CLICA NO BOT�O PARAMETROS
self.oHelper.SetButton('Param.')
# SEÇÃO DE DEFINIÇÃO DE PARAMETROS
self.oHelper.SetValue('Data Inicial ?', '01/05/2016')
self.oHelper.SetValue('Data Final ?', '31/05/2016')
self.oHelper.SetValue('LayOut?', 'sintmg05')
self.oHelper.SetValue('Arquivo Destino?', 'sintmg.txt')
self.oHelper.SetValue('Finalidade?', 'Normal')
self.oHelper.SetValue('UF Origem/Destino?', '')
self.oHelper.SetValue('Processa UF?', 'Exceto a UF')
self.oHelper.SetValue('Numero do Livro?', '*')
self.oHelper.SetValue('Equipamento?', '')
self.oHelper.SetValue('Gera Inventario?', 'Nao')
self.oHelper.SetValue('Notas Fiscais?', 'Entrada')
# self.oHelper.SetValue('Gera Reg.60I e 60D ?','')
self.oHelper.SetValue('Drive Destino ?', 'C:\\')
self.oHelper.SetValue('Transportadora ?','')
self.oHelper.SetValue('Data de Fechamento ?', '31052016')
self.oHelper.SetValue('Gera Registro 60R ?', 'Nao')
self.oHelper.SetValue('Gera Registro 61R ?', 'Nao')
self.oHelper.SetValue('Gera NF Produtor ?', 'Nao')
self.oHelper.SetValue('Meio magnetico ?', 'FITA')
self.oHelper.SetValue('Fator de bloco ?', '')
self.oHelper.SetValue('Natureza Operacoes ?', 'Totalidade')
self.oHelper.SetValue('Destaca PIS/COFINS ?', 'Sim')
self.oHelper.SetValue('NF De ?', '')
self.oHelper.SetValue('NF Ate ?', 'ZZZZ')
self.oHelper.SetValue('Filial de ?', '')
self.oHelper.SetValue('Filial Ate ?', 'ZZZZZZ')
self.oHelper.SetValue('Consolidação na mesma UF ?', 'Nao')
self.oHelper.SetValue('Filtro Tipo Produto ?', '')
self.oHelper.SetValue('Produto De ?', '')
self.oHelper.SetValue('Produto Ate ?', 'ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ')
self.oHelper.SetValue('Armazem De ?', '')
self.oHelper.SetValue('Armazem Ate ?', 'ZZ')
self.oHelper.SetValue('Prods.c/Saldo Neg. ?', 'Nao')
self.oHelper.SetValue('Prods.c/Saldo Zera. ?', 'Nao')
self.oHelper.SetValue('Prods.c/Saldo Poder 3º. ?', 'Nao')
self.oHelper.SetValue('Prods.c/Custo Zera. ?', 'Nao')
self.oHelper.SetValue('Gera 88 MG ?', 'Nao')
self.oHelper.SetValue('Data 88 ?', '')
self.oHelper.SetValue('Gera Relat. Rest. MG ?', 'Nao')
self.oHelper.SetValue('Saldo Processo ?', 'Nao')
self.oHelper.SetValue('Lista MOD Processo ?', 'Nao')
self.oHelper.SetValue('Seleciona Filiais ?', 'Sim')
self.oHelper.SetValue('Gera registro 60I ?', 'Nao')
self.oHelper.SetValue('Gera reg. Tipo 88 Det. 06 ?', 'Nao')
self.oHelper.SetValue('Gera reg. 8827 e 8828 ?', 'Nao')
self.oHelper.SetValue('Gera reg. 8830 ?', 'Nao')
self.oHelper.SetValue('Simples Nacional ?', 'Nao')
self.oHelper.SetValue('Arq. Periodo Atual ?', '')
self.oHelper.SetValue('Gera reg. 53 (Entradas) ?', 'Nao')
self.oHelper.SetValue('Gera reg. 88DV ?', 'Nao')
self.oHelper.SetValue('Aglutina seleção por CNPJ+IE ?', 'Nao')
# self.oHelper.SetValue('Rest. ST Alteração Regime ?','')
# self.oHelper.SetValue('Rest.ST Estoque/Nota Fiscal ?','')
# self.oHelper.SetValue('Gera somente Reg. Rest.ST ?','')
# CLICA NO BOTÃO OK PARA CONFIRMAR OS PARAMETROS E VOLTA PARA A TELA ANTERIOR
self.oHelper.SetButton('OK')
# CLICA NO OK E INICIA O PROCESSO DE Gerar Arquivo Magn�tico Layout SINTMG05 - Registro 55 (GNRE ICMS Antecipado - Documento de Entrada)
self.oHelper.SetButton('Ok')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAFIS/SPEDFISCALTESTCASE.py
```python
from tir import Webapp
import unittest
from datetime import datetime
class SPEDFISCAL(unittest.TestCase):
@classmethod
def setUpClass(inst):
'''
SETUP
Test Case Initial Setup
'''
#Endereço do webapp e o nome do Browser
inst.oHelper = Webapp()
DateSystem = datetime.today()
#Parametros de inicializaçao
inst.oHelper.Setup("SIGAFIS",DateSystem.strftime('%d/%m/%Y'),"T1","D MG 01","09")
#Nome da rotina do Caso de Teste
inst.oHelper.Program("SPEDFISCAL")
def test_SPEDFISCAL_001(self):
DateSystem = datetime.today()
self.oHelper.SetButton('vançar >>')
#Parametros para geracao
self.oHelper.SetValue('Data de',DateSystem.strftime('%d/%m/%Y'))
self.oHelper.SetValue('Data até',DateSystem.strftime('%d/%m/%Y'))
self.oHelper.SetValue('Livro','*')
self.oHelper.SetValue('Diretório do Arquivo Destino','')
self.oHelper.SetValue('Nome do Arquivo Destino','SPEDFISCAL.TXT')
self.oHelper.SetValue('Gera Inventário','2')
self.oHelper.SetValue('Gera Registros Complementares de Frete','2')
self.oHelper.SetValue('Data de fechamento do estoque',DateSystem.strftime('%d/%m/%Y'))
self.oHelper.SetValue('Gera Registros de ECF','2')
self.oHelper.SetValue('Imprime Credito ST','2')
self.oHelper.SetValue('Seleciona Filiais ?','2')
#self.oHelper.ClickBox('Período de Apuração','0 - Mensal')
self.oHelper.SetValue('Inicio Obrigação Escrituração Fiscal CIAP','2')
#self.oHelper.SetValue('Considera Valores de Pis/Cofins?','1')
self.oHelper.SetValue('Gera Bloco K','2')
self.oHelper.SetValue('Reg. 0210 por Mov.?','2')
self.oHelper.SetValue('Gera Registros DIFAL (EC 87/15)','1')
self.oHelper.SetValue('Motivo do Inventário','01')
self.oHelper.SetValue('Gera Registro 0400 - Natureza da Oper./Prest.?','2')
self.oHelper.SetValue('Gera H020 - Motivo Inventário 01','1')
self.oHelper.SetValue('Processa histórico do Bloco K','1')
#self.oHelper.SetValue('Gera Registro C191 - FECP','1')
self.oHelper.SetValue('Gera Bloco G','1')
self.oHelper.SetValue('Gera Bloco B','1')
self.oHelper.SetButton('vançar >>')
#Identificacao do Contribuinte
self.oHelper.SetValue('Código da Finalidade do Arquivo','0')
self.oHelper.SetValue('Filial de','')
self.oHelper.SetValue('Filial ate','')
self.oHelper.SetValue('Perfil de Apresentação','B')
self.oHelper.SetValue('Tipo de Atividade','0')
self.oHelper.SetValue('Aglutina por CNPJ+IE ?','0')
self.oHelper.SetValue('E-Mail','<EMAIL>')
self.oHelper.SetButton('vançar >>')
#Dados do Contabilista
self.oHelper.SetValue('Nome','<NAME>')
self.oHelper.SetValue('CNPJ','')
self.oHelper.SetValue('CPF','48769306869')
self.oHelper.SetValue('CRC','11111111111')
self.oHelper.SetValue('CEP','03443000')
self.oHelper.SetValue('Cod. Município','3550308')
self.oHelper.SetValue('Endereço','Rua Baquia')
#self.oHelper.SetValue('Número','736')
self.oHelper.SetValue('Complemento','')
self.oHelper.SetValue('Bairro','<NAME>')
self.oHelper.SetValue('Fone','1598130992')
self.oHelper.SetValue('Fax','1598130992')
self.oHelper.SetValue('E-Mail','<EMAIL>')
self.oHelper.SetButton('vançar >>')
#Informacoes para processamento do bloco 1
self.oHelper.SetValue('Gera Registro 1100 - Exportação?','1')
self.oHelper.SetValue('Gera Registro 1200 - Créditos Fiscais?','1')
self.oHelper.SetValue('Gera Registro 1300 - Combustíveis?','1')
self.oHelper.SetValue('Gera Registro 1390 - Usina de açúcar/álcool?','1')
self.oHelper.SetValue('Gera Registro 1400 - Valores Agregados?','1')
self.oHelper.SetValue('Gera Registro 1500 - Energia Elétrica?','1')
self.oHelper.SetValue('Gera Registro 1600 - Cartão de Crédito/Débito?','1')
self.oHelper.SetValue('Gera Registro 1700 - Documentos Fiscais?','1')
self.oHelper.SetValue('Gera Registro 1800 - Transporte Aéreo?','1')
self.oHelper.SetValue('Gera Registro 1400 - Movimentação Anual?','1')
self.oHelper.SetValue('Gera Registro 1960 - GIAF 1?','1')
self.oHelper.SetValue('Gera Registros 1970 e 1975 - GIAF 3?','1')
self.oHelper.SetValue('Gera Registro 1980 - GIAF 4?','1')
self.oHelper.SetButton('Finalizar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
'''
Method that finishes the test case.
'''
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGCT/CNTA210TESTCASE.py
```python
from cawebhelper import CAWebHelper
import unittest
class CNTA210(unittest.TestCase):
@classmethod
def setUpClass(inst):
'''
SETUP
Configuração de inicialização dos Casos de Teste
'''
#Endereço do webapp e o nome do Browser
inst.oHelper = CAWebHelper("http://localhost:9096/","FIREFOX")
#Parametros de inicializaçao
inst.oHelper.SetUp("SIGAGCT","P12_CONGELADA","ADMIN","","","T1","D MG 01 ")
#Nome da rotina do Caso de Teste
inst.oHelper.UTProgram("CNTA210")
def test_CNTA210_004(self):
'''
Caso de Teste 004
'''
#Aciona os botões do TOTVS SmartClient HTML.
self.oHelper.SetButton('Incluir', 'D MG 01')
#Preenche os campos do Cabeçalho e/ou Grid do TOTVS: SmartClient HTML.
self.oHelper.UTSetValue("aCab","CNJ_SITUAC","09")
self.oHelper.UTSetValue("aItens","CNJ_TPDOC","004")
# confirma a gravação da inclusão do pedido de venda.
self.oHelper.SetButton("Salvar")
# após a gravação, o TOTVS: SmartClient HTML volta para a tela de inclusão, então eu cancelo essa tela para voltar para o mbrowse.
self.oHelper.SetButton("Cancelar")
# na tela do mbrowse, posicionado no pedido de venda desejado, seleciono o botão Alterar.
self.oHelper.SetButton("Visualizar")
#Com o pedido sendo apresentado na tela, efetuo a conferencia dos dados da interface com o resultado esperado pelo usuário.
self.oHelper.UTCheckResult("aCab","CNJ_SITUAC","09")
self.oHelper.UTCheckResult("aItens","CNJ_TPDOC","004")
self.oHelper.UTCheckResult("aItens","CNJ_TPCTO", " ")
self.oHelper.UTCheckResult("aItens","CNJ_DESCTD","GCT MATA210 002")
self.oHelper.SetButton("Cancelar")
#Define que o teste espera uma retorno verdadeiro para passar.
self.oHelper.AssertTrue()
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGFE/GFEA013TESTCASE.py
```python
from tir import Webapp
import unittest
class GFEA013(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAGFE','03/11/2020','T1','D MG 01 ','78')
inst.oHelper.Program('GFEA013')
def test_GFEA013_CT001(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetValue('Unid Feder ', 'AC')
self.oHelper.SetValue('Trib Est Ctb', '2')
self.oHelper.SetValue('Trib Est NC ', '2')
self.oHelper.SetValue('Trib Int Ctb', '2')
self.oHelper.SetValue('Trib Int NC ', '2')
self.oHelper.SetValue('Aliq Est Ctb', '4', check_value = False)
self.oHelper.SetValue('Aliq Est NC ', '4', check_value = False)
self.oHelper.SetValue('Aliq Int Ctb', '4', check_value = False)
self.oHelper.SetValue('Aliq Int NC ', '4', check_value = False)
self.oHelper.SetValue('% Cred ICMS ', '10', check_value = False)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SearchBrowse(' AC')
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('Trib Est Ctb', '1')
self.oHelper.SetValue('Trib Est NC ', '1')
self.oHelper.SetValue('Trib Int Ctb', '1')
self.oHelper.SetValue('Trib Int NC ', '1')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SearchBrowse(' AC')
self.oHelper.SetButton('Visualizar')
self.oHelper.SetButton('Fechar')
self.oHelper.SearchBrowse(' AC')
self.oHelper.SetButton('Outras Ações','Copiar')
self.oHelper.SetValue('Unid Feder ', 'GO')
self.oHelper.SetValue('Trib Est Ctb', '1')
self.oHelper.SetValue('Trib Est NC ', '1')
self.oHelper.SetValue('Trib Int Ctb', '1')
self.oHelper.SetValue('Trib Int NC ', '1')
self.oHelper.SetValue('Aliq Est Ctb', '10', check_value = False)
self.oHelper.SetValue('Aliq Est NC ', '10', check_value = False)
self.oHelper.SetValue('Aliq Int Ctb', '10', check_value = False)
self.oHelper.SetValue('Aliq Int NC ', '10', check_value = False)
self.oHelper.SetValue('% Cred ICMS ', '10', check_value = False)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SearchBrowse(' AC')
self.oHelper.SetButton('Outras Ações','Excluir')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SearchBrowse(' GO')
self.oHelper.SetButton('Outras Ações','Excluir')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGFE/GFEA029TESTCASE.py
```python
from tir import Webapp
import unittest
class GFEA029(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAGFE','05/12/2020','T1','D MG 01 ','78')
inst.oHelper.Program('GFEA029')
def test_GFEA029_CT001(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetValue('Ida e Volta ', '2')
self.oHelper.SetValue('Ini Validade', '04/12/2020')
self.oHelper.SetValue('Fim Validade', '31/12/2021')
self.oHelper.SetValue('Cid Origem ', '1100205')
self.oHelper.SetValue('Cid Dest ', '1200401')
self.oHelper.SetValue('Transp ', '101')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGFE/GFEA030TESTCASE.py
```python
from tir import Webapp
import unittest
class GFEA030(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAGFE','05/12/2020','T1','D MG 01 ','78')
inst.oHelper.Program('GFEA030')
def test_GFEA030_CT001(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetValue('Tipo ', '900001')
self.oHelper.SetValue('Descricao ', 'TIPO OCORRENCIA TESTE AUTOMACAO')
self.oHelper.SetValue('Evento ', '3')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SearchBrowse(' 900001')
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('Descricao ', 'TIPO OCORR ALTERADO TESTE AUTOMACAO')
self.oHelper.ClickGridCell('Motivo', 1)
self.oHelper.SetValue('Motivo', '000001', grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SearchBrowse(' 900001')
self.oHelper.SetButton('Visualizar')
self.oHelper.SetButton('Fechar')
self.oHelper.SearchBrowse(' 900001')
self.oHelper.SetButton('Outras Ações','Copiar')
self.oHelper.SetValue('Tipo ', '900002')
self.oHelper.SetValue('Descricao ', 'TIPO OCORR 2 TESTE AUTOMACAO')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGFE/GFEA061TESTCASE.py
```python
from tir import Webapp
import unittest
class GFEA061(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAGFE','15/12/2020','T1','D MG 01 ','78')
inst.oHelper.Program('GFEA061')
def test_GFEA061_CT001(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetValue('Emitente','500')
self.oHelper.SetValue('Tabela','151220')
self.oHelper.SetValue('Descricao','TABELA GFE - 151220')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SearchBrowse('500 151220')
self.oHelper.SetButton('Outras Ações','Anexo')
self.oHelper.SetButton('Cancelar')
self.oHelper.SetButton('Visualizar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('Descricao','TABELA GFE - ALTERACAO')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SearchBrowse('500 151220')
self.oHelper.SetButton('Outras Ações','Excluir')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGFE/GFEC020TESTCASE.py
```python
from tir import Webapp
import unittest
class GFEC020(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAGFE", "22/06/2020", "T1", "D MG 01", "78")
inst.oHelper.Program("GFEC020")
def test_GFEC020_CT001(self):
self.oHelper.SearchBrowse("1200401")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("GU7_NRCID", "1200401")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGAGFE/GFEC059TESTCASE.py
```python
from tir import Webapp
import unittest
class GFEC059(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAGFE", "30/12/2020", "T1", "D MG 01", "78")
inst.oHelper.Program("GFEC059")
def test_GFEC059_CT001(self):
self.oHelper.SetButton('X')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGAGFE/GFEC061TESTCASE.py
```python
from tir import Webapp
import unittest
class GFEC061(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAGFE", "23/06/2020", "T1", "D MG 01", "78")
inst.oHelper.Program("GFEC061")
def test_GFEC061_CT001(self):
self.oHelper.SetButton('Cancelar')
self.oHelper.ClickTree('Tabelas')
self.oHelper.SetButton('Sair')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGAGFE/GFEC070TESTCASE.py
```python
from tir import Webapp
import unittest
class GFEC070(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAGFE", "22/06/2020", "T1", "D MG 01", "78")
inst.oHelper.Program("GFEC070")
def test_GFEC070_CT001(self):
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Detalhe Conf.")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGAGFE/GFER093TESTCASE.py
```python
from tir import Webapp
import unittest
class GFER093(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAGFE", "30/12/2020", "T1", "D MG 01", "78")
inst.oHelper.Program("GFER093")
def test_GFER093_CT001(self):
self.oHelper.SetButton('Outras Ações','Parâmetros')
self.oHelper.SetValue('Dados ?','Ambos')
self.oHelper.SetValue('Filial Inicial ?','')
self.oHelper.SetValue('Filial Final ?','ZZZZZZZZ')
self.oHelper.SetValue('Data Base Filtro ?','Data de Criação')
self.oHelper.SetValue('Data Inicial ?','01/01/2018')
self.oHelper.SetValue('Data Final ?','31/12/2020')
self.oHelper.SetValue('Tipo Relatório ?','Detalhado')
self.oHelper.SetValue('Mostrar Lançamentos ?','Sim')
self.oHelper.SetValue('Filtro Lançamentos ?','Todos')
self.oHelper.SetValue('Lista Doc Carga ?','Sim')
self.oHelper.SetValue('Pré-fatura Inicial ?','')
self.oHelper.SetValue('Pré-fatura Final ?','99999999')
self.oHelper.SetValue('Fatura Inicial ?','')
self.oHelper.SetValue('Fatura Final ?','9999999999999999')
self.oHelper.SetValue('Apenas Pendentes ?','Não')
self.oHelper.SetButton('OK')
self.oHelper.SetButton('Imprimir')
self.oHelper.SetButton('Sair')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGAGFE/GFEX010TESTCASE.py
```python
from tir import Webapp
import unittest
import time
class GFEX010(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAGFE','28/06/2020','T1','D MG 01 ','78')
inst.oHelper.Program('GFEX010')
def test_GFEX010_CT001(self):
time.sleep(5)
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGTP/GTPA004TestCase.py
```python
from tir import Webapp
import unittest
import time
class GTPA004(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAGTP', '15/04/2020', 'T1', 'D MG 01 ', '88')
inst.oHelper.Program('GTPA004')
def test_GTPA004_CT001(self):
print("test_GTPA004_CT001 - Visualizar")
self.oHelper.SearchBrowse('D MG 00000000009', key=1, index=True)
self.oHelper.SetButton('Visualizar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_GTPA004_CT002(self):
print("test_GTPA004_CT002 - Alterar")
self.oHelper.SearchBrowse('D MG 00000000009', key=1, index=True)
self.oHelper.SetButton('Outras Ações', 'Alterar')
time.sleep(2)
self.oHelper.SetButton('Sim')
time.sleep(2)
self.oHelper.SetValue('Lotação', '55')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_GTPA004_CT003(self):
print("test_GTPA004_CT003 - Excluir")
self.oHelper.SearchBrowse('D MG 00000000009', key=1, index=True)
self.oHelper.SetButton('Outras Ações', 'Excluir')
self.oHelper.SetButton('Confirmar')
time.sleep(2)
self.oHelper.SetButton('Sim')
time.sleep(2)
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_GTPA004_CT004(self):
print("test_GTPA004_CT004 - Incluir")
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch('D MG')
self.oHelper.SetValue('Cód. Linha', '000001')
self.oHelper.SetValue('Sentido', '1')
self.oHelper.SetValue('Hora Inicio', '10:00')
time.sleep(2)
self.oHelper.SetValue('Vigência de', '01/05/2020')
self.oHelper.SetValue('Vigência até', '30/05/2020')
self.oHelper.SetValue('Lotação', '50')
self.oHelper.ClickCheckBox('Segunda', 1)
self.oHelper.ClickCheckBox('Terça', 1)
self.oHelper.ClickCheckBox('Quarta', 1)
self.oHelper.ClickCheckBox('Quinta', 1)
self.oHelper.ClickCheckBox('Sexta', 1)
self.oHelper.ClickCheckBox('Sábado', 1)
self.oHelper.ClickCheckBox('Domingo', 1)
self.oHelper.SetButton('Outras Ações', 'Seleção de Localidade')
self.oHelper.SetButton('Confirmar')
time.sleep(2)
self.oHelper.SetButton('Fechar')
self.oHelper.ClickGridCell("Hora destino", row=1, grid_number=1)
self.oHelper.SetValue("Hora destino","12:00",grid=True, grid_number=1)
self.oHelper.ClickGridCell("Tempo Exec.", row=1, grid_number=1)
self.oHelper.SetValue("Tempo Exec.","01:00",grid=True, grid_number=1)
self.oHelper.LoadGrid()
time.sleep(2)
self.oHelper.SetButton('Confirmar')
time.sleep(2)
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGTP/GTPA008XTestCase.py
```python
from tir import Webapp
import unittest
class GTPA008X(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAGTP", "10/04/2020", "T1", "D MG 01 ")
inst.oHelper.Program('GTPA008')
def test_GTPA008X_CT001(self):
self.oHelper.SetButton("Outras Ações", "Imp. Funcionarios")
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Sim")
self.oHelper.SetValue('Cargo de ?', '00001')
self.oHelper.SetValue('Cargo até ?', '00001')
self.oHelper.SetValue('Função de ?', '00001')
self.oHelper.SetValue('Função até ?', '00001')
self.oHelper.SetValue('Filtrar Matriculas sem Colab ?', 'Não')
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGTP/GTPA036ETestCase.py
```python
from tir import Webapp
import unittest
class GTPA036E(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAGTP", "05/08/2020", "T1", "D MG 01 ")
inst.oHelper.Program('GTPA036')
def test_GTPA036E_CT001(self):
self.oHelper.SetButton('Avançar')
self.oHelper.ClickLabel("Arquivo não formatado")
self.oHelper.SetButton('Avançar')
self.oHelper.SetValue('XXX_DATADE', '02/08/2020')
self.oHelper.SetValue('XXX_DATATE', '07/08/2020')
self.oHelper.ScrollGrid(column='Agência', match_value='000048', grid_number=1)
'''self.oHelper.ClickGridCell("", row=2, grid_number=1)'''
self.oHelper.ClickBox("", contents_list='', select_all=False, grid_number=1)
self.oHelper.SetButton('Concluir')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGTP/GTPA041TestCase.py
```python
from tir import Webapp
import unittest
class GTPA041(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAGTP", "20/11/2020", "T1", "D MG 01 ")
inst.oHelper.Program('GTPA041')
def test_GTPA041_CT001(self):
self.oHelper.SetButton("Incluir")
self.oHelper.SetValue('Grup. Cod.', 'GTP001')
self.oHelper.SetValue('Grup. Desc', 'TESTE')
self.oHelper.ClickGridCell("Código Dest.", row=1)
self.oHelper.SetValue('Código Dest.', '000001', grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse("GTP001", "Grup. Cod.")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue('Grup. Desc', 'TESTE 2')
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse("GTP001", "Grup. Cod.")
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse("GTP001", "Grup. Cod.")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGTP/GTPA042TestCase.py
```python
from tir import Webapp
import unittest
class GTPA042(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAGTP', '14/08/2020', 'T1', 'D MG 01 ')
inst.oHelper.Program('GTPA042')
# Efetua o cadastro de evento para envio de e-mail
print('CT001 - inclui evento para Envio de e-mails')
def test_GTPA042_CT001(self):
self.oHelper.SetButton('Sim')
self.oHelper.SetButton('Incluir')
self.oHelper.SetValue('GZ8_DESEVE', 'AUTOMACAO ENVIO DE EMAIL')
self.oHelper.SetValue('GZ8_TEXTO', 'AUTOMACAO ENVIO DE EMAIL TEXTO E-MAIL')
self.oHelper.SetValue('GZ8_STATUS', '1')
self.oHelper.SetValue('GZ8_TITULO', 'AUTOMACAO ENVIO DE EMAIL TITULO')
self.oHelper.SetValue('GZ8_RECOR', '2')
self.oHelper.SetValue('GZ6_CODIGO', '000002')
self.oHelper.SetButton('Outras Ações','Automação')
self.oHelper.SetValue('GY5_ENTIDA', 'G57')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetValue('GY6_CAMPO1', 'G57_AGENCI')
self.oHelper.SetValue('GY6_CONTEU', '000050')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Visualizar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Outras Ações','Excluir')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGTP/GTPA060TestCase.py
```python
from tir import Webapp
import unittest
class GTPA060(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAGTP", "07/10/2020", "T1", "D MG 01 ")
inst.oHelper.Program('GTPA060')
def test_GTPA060_CT001(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch('D MG')
self.oHelper.SetValue('GZR_UF', 'MG')
self.oHelper.SetValue('GZR_FILREF', 'X FIS16')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGTP/GTPA115BTestCase.py
```python
from tir import Webapp
from datetime import datetime
DataSystem = datetime.today().strftime('%d/%m/%Y')
import unittest
import time
class GTPA115B(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
#Parametros de inicializaçao
inst.oHelper.Setup("SIGAGTP", DataSystem,"T1","D MG 01 ","88")
#Nome da rotina do Caso de Teste
inst.oHelper.Program("GTPA421")
def test_GTPA115B_CT001(self):
self.oHelper.SearchBrowse("D MG AG950020200327", "Filial+agência + Número Ficha")
self.oHelper.SetButton("Outras Ações", "Conferência de Bilhetes")
time.sleep(6)
self.oHelper.SetValue("Origem", "1")
self.oHelper.SetValue("Tipo", "E")
self.oHelper.SetValue("Status", "V")
self.oHelper.SetButton("Pesquisar")
self.oHelper.SetButton("Outras Ações", "Conferir Todos")
time.sleep(5)
self.oHelper.SetButton("Todos")
time.sleep(3)
self.oHelper.SetButton("Outras Ações", "Conferir Todos")
time.sleep(3)
self.oHelper.SetButton("Outras Ações", "Altera Contr. Docto.")
self.oHelper.SetValue("Tipo de Documento ?", "TP9500")
self.oHelper.SetValue("Série ?", "CDD")
self.oHelper.SetValue("Sub Série ?", "500")
self.oHelper.SetValue("Complemento ?", "9")
self.oHelper.SetValue("Número Documento ?", "000011")
self.oHelper.SetButton("OK")
time.sleep(2)
self.oHelper.SetKey("ENTER", grid=False)
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.ClickGridCell("CCF", 1)
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetButton("Confirmar")
self.oHelper.SetKey("ENTER")
self.oHelper.SetButton("Fechar")
time.sleep(5)
self.oHelper.AssertTrue()
#self.oHelper.RestoreParameters()
#
def test_GTPA115B_CT002(self):
print("test_GTPA115B_CT002")
self.oHelper.SearchBrowse("D MG AG950020200327", "Filial+agência + Número Ficha")
self.oHelper.SetButton("Outras Ações", "Conferência de Bilhetes")
time.sleep(6)
self.oHelper.SetButton("Todos")
time.sleep(3)
self.oHelper.SetButton("Outras Ações", "Conferir Todos")
time.sleep(2)
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.ClickGridCell("CCF", 1)
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetButton("Confirmar")
self.oHelper.SetKey("ENTER")
self.oHelper.SetButton("Fechar")
time.sleep(5)
self.oHelper.AssertTrue()
#self.oHelper.RestoreParameters()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGTP/GTPA422TestCase.py
```python
from tir import Webapp
import unittest
import time
class GTPA422(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAGTP', '27/08/2020', 'T1', 'D MG 01 ', '88')
inst.oHelper.Program('GTPA422')
def test_GTPA422_CT001(self):
print("test_GTPA422_CT001 - Visualizar")
self.oHelper.SearchBrowse('D MG 000003', key=1, index=True)
self.oHelper.SetButton('Visualizar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_GTPA422_CT002(self):
print("test_GTPA422_CT002 - Alterar")
self.oHelper.SearchBrowse('D MG 000003', key=1, index=True)
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('Motivo', 'Alteração Tir')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_GTPA422_CT003(self):
print("test_GTPA422_CT003 - Excluir")
self.oHelper.SearchBrowse('D MG 000003', key=1, index=True)
self.oHelper.SetButton('Outras Ações', 'Excluir')
self.oHelper.SetButton('Confirmar')
time.sleep(2)
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_GTPA422_CT004(self):
print("test_GTPA422_CT004 - Incluir")
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch('D MG')
self.oHelper.SetValue('Tipo', '000001')
self.oHelper.SetValue('Agência', 'GTPVAM')
self.oHelper.F3(field='Serie')
self.oHelper.SearchBrowse('000046', key=1, index=True)
self.oHelper.SetButton('OK')
self.oHelper.SetValue('Seq. Lote', '000012')
self.oHelper.SetValue('Dt. Entrega', '31/08/2020')
self.oHelper.SetValue('Emitente' , '000001')
self.oHelper.SetValue('Cod.Acertado' , '000009')
self.oHelper.SetButton('Outras Ações', 'Carrega Bilhete')
self.oHelper.SetValue('Dt. Emissão de: ?' , '27/08/2020')
self.oHelper.SetValue('Dt Emissão até: ?' , '31/08/2020')
self.oHelper.SetValue('Tipo de Documento: ?' , '000001')
self.oHelper.SetValue('Série: ?' , '422')
self.oHelper.SetValue('Sub Série: ?' , '111')
self.oHelper.SetValue('Num. Complemento: ?' , '111')
self.oHelper.SetValue('Numero Inicial: ?' , '000001')
self.oHelper.SetValue('Numero Final: ?' , '000100')
self.oHelper.SetButton('OK')
time.sleep(3)
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGTP/GTPA702TestCase.py
```python
from tir import Webapp
import unittest
class GTPA702(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAGTP", "29/05/2020", "T1", "D MG 01 ")
inst.oHelper.Program('GTPA702')
def test_GTPA702_CT001(self):
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAGTP/GTPR019TestCase.py
```python
from tir import Webapp
import unittest
import time
class GTPR019(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAGTP', '19/11/2020', 'T1', 'D MG 01 ', '88')
inst.oHelper.Program('GTPA422')
def test_GTPR019_CT001(self):
print("test_GTPR019_CT001 - Visualizar")
self.oHelper.SetButton('Visualizar')
self.oHelper.SetButton("Outras Ações", "Imprimir DAPE")
self.oHelper.SetButton('Imprimir')
self.oHelper.SetButton('Sair')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAJURI/JURA020TestCase.py
```python
from tir import Webapp
import unittest
class JURA020(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAJURI','12/11/2018','T1','D MG 01 ','76')
inst.oHelper.Program('JURA020')
inst.oHelper.AddParameter("MV_JTPIMP", "", "2", "", "")
inst.oHelper.AddParameter("MV_JPUBTOT", "", "1", "", "")
inst.oHelper.AddParameter("MV_JNT4CLI", "", "1", "", "")
inst.oHelper.SetParameters()
def test_JURA020_CT001(self):
print('CT001 - Efetua vinculo e conciliação manual de Publicação')
self.oHelper.SetButton("Perguntas")
self.oHelper.SetValue("MV_PAR01","01/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR02","30/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR03","",name_attr=True)
self.oHelper.SetValue("MV_PAR04","",name_attr=True)
self.oHelper.SetValue("MV_PAR05","",name_attr=True)
self.oHelper.SetValue("MV_PAR06","",name_attr=True)
self.oHelper.SetButton("Informações")
self.oHelper.SetButton("Executar")
self.oHelper.SetButton("Outras Ações","Filtrar por Palavra-chave")
self.oHelper.ClickBox("Palavra-Chave","GENILSON")
self.oHelper.SetButton("Filtrar")
self.oHelper.ClickFolder("Publicações não Localizadas")
self.oHelper.ClickBox("Num.Proc.","3001565-81.2013.8.26.0554")
self.oHelper.SetButton("Outras Ações","Vincular Processo")
self.oHelper.SetButton("Sim")
self.oHelper.SetValue("cProces","777777777777777777",name_attr=True)
self.oHelper.SetButton("Pesquisar")
self.oHelper.SetValue("cAutor","01",name_attr=True)
self.oHelper.ClickGridCell("Cód.Interno",row=1)
self.oHelper.ClickBox("Cód.Interno","0000000081")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Sair da Página")
self.oHelper.SetLateralMenu("Atualizações > Assuntos Jurídicos > Pesquisas")
self.oHelper.SetValue("cValor","Contencioso",name_attr=True)
self.oHelper.WaitFieldValue("NSZ_COD","")
self.oHelper.SetValue("NSZ_COD","0000000081")
self.oHelper.ClickLabel("Pesquisar")
self.oHelper.ClickGridCell("Código do cliente",row=1)
self.oHelper.ClickLabel("Visualizar")
self.oHelper.CheckResult("NSZ_NUMPRO","3001565-81.2013.8.26.0554")
self.oHelper.CheckResult("NSZ_COD","0000000081")
self.oHelper.SetButton("Fechar")
self.oHelper.ClickLabel("Sair")
self.oHelper.SetLateralMenu("Importação de Publicações")
self.oHelper.SetButton("Executar")
self.oHelper.SetButton("Outras Ações","Filtrar por Palavra-chave")
self.oHelper.ClickBox("Palavra-Chave","MENEGHINI")
self.oHelper.SetButton("Filtrar")
self.oHelper.ClickFolder("Publicações Localizadas")
self.oHelper.ClickBox("Num.Proc","1001264-51.2016.8.26.0268")
self.oHelper.SetButton("Outras Ações","Conciliar Manual")
self.oHelper.SetButton("Sim")
self.oHelper.SetValue("cCodAto","008",name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Sair da Página")
self.oHelper.SetLateralMenu("Pesquisas")
self.oHelper.SetValue("cValor","Contencioso",name_attr=True)
self.oHelper.WaitFieldValue("NSZ_COD","")
self.oHelper.SetValue("NSZ_COD","0000000004")
self.oHelper.ClickLabel("Pesquisar")
self.oHelper.ClickGridCell("Código do cliente",row=1)
self.oHelper.ClickLabel("Visualizar")
self.oHelper.CheckResult("NSZ_COD","0000000004")
self.oHelper.SetButton("Andamentos")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("NT4_CAJURI","0000000004")
self.oHelper.CheckResult("NT4_CATO","008")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("X")
self.oHelper.SetButton("Fechar")
self.oHelper.ClickLabel('Sair')
self.oHelper.AssertTrue()
def test_JURA020_CT002(self):
print('CT002 - Efetua conciliação automática de Publicação')
self.oHelper.Program('JURA020')
self.oHelper.SetButton("Perguntas")
self.oHelper.SetValue("MV_PAR01","01/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR02","30/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR03","",name_attr=True)
self.oHelper.SetValue("MV_PAR04","",name_attr=True)
self.oHelper.SetValue("MV_PAR05","",name_attr=True)
self.oHelper.SetValue("MV_PAR06","",name_attr=True)
self.oHelper.SetButton("Informações")
self.oHelper.SetButton("Executar")
self.oHelper.ClickFolder("Publicações Localizadas")
self.oHelper.ClickBox("Num.Proc","1001012-34.2014.8.26.0554")
self.oHelper.SetButton("Outras Ações","Conciliar Automático")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Sair da Página")
self.oHelper.Program('JURA162')
self.oHelper.SetValue("cValor","Contencioso",name_attr=True)
self.oHelper.WaitFieldValue("NSZ_COD","")
self.oHelper.SetValue("NSZ_COD","0000000170")
self.oHelper.ClickLabel("Pesquisar")
self.oHelper.ClickGridCell("Código do cliente",row=1)
self.oHelper.ClickLabel("Visualizar")
self.oHelper.CheckResult("NSZ_COD","0000000170")
self.oHelper.SetButton("Andamentos")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("NT4_CAJURI","0000000170")
self.oHelper.CheckResult("NT4_CATO","014")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("X")
self.oHelper.SetButton("Fechar")
self.oHelper.ClickLabel('Sair')
self.oHelper.AssertTrue()
def test_JURA020_CT003(self):
print('CT003 - Efetua marcação Publicação')
self.oHelper.Program('JURA020')
self.oHelper.SetButton("Perguntas")
self.oHelper.SetValue("MV_PAR01","01/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR02","30/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR03","",name_attr=True)
self.oHelper.SetValue("MV_PAR04","",name_attr=True)
self.oHelper.SetValue("MV_PAR05","",name_attr=True)
self.oHelper.SetValue("MV_PAR06","",name_attr=True)
self.oHelper.SetButton("Informações")
self.oHelper.SetButton("Executar")
self.oHelper.ClickFolder("Publicações não Localizadas")
self.oHelper.ClickBox("Num.Proc","1500091-34.2015.8.26.0505")
self.oHelper.SetButton("Outras Ações","Marcar Todos")
self.oHelper.ClickMenuPopUpItem('Inverter Seleção')
self.oHelper.SetButton("Outras Ações","Marcar Todos")
self.oHelper.ClickMenuPopUpItem('Marcar Todos')
self.oHelper.SetButton("Outras Ações","Marcar Todos")
self.oHelper.ClickMenuPopUpItem('Desmarcar Todos')
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_JURA020_CT004(self):
print('CT004 - Efetua validação dos perguntes de período de datas')
self.oHelper.Program('JURA020')
self.oHelper.SetButton("Perguntas")
self.oHelper.SetValue("MV_PAR01","",name_attr=True)
self.oHelper.SetValue("MV_PAR02","",name_attr=True)
self.oHelper.SetValue("MV_PAR03","",name_attr=True)
self.oHelper.SetValue("MV_PAR04","",name_attr=True)
self.oHelper.SetValue("MV_PAR05","",name_attr=True)
self.oHelper.SetValue("MV_PAR06","",name_attr=True)
self.oHelper.SetButton("Informações")
self.oHelper.SetButton("Executar")
self.oHelper.WaitShow("Preencha as datas")
self.oHelper.SetButton("Fechar")
self.oHelper.Program('JURA020')
self.oHelper.SetButton("Perguntas")
self.oHelper.SetValue("MV_PAR01","01/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR02","30/05/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR03","",name_attr=True)
self.oHelper.SetValue("MV_PAR04","",name_attr=True)
self.oHelper.SetValue("MV_PAR05","",name_attr=True)
self.oHelper.SetValue("MV_PAR06","",name_attr=True)
self.oHelper.SetButton("Informações")
self.oHelper.SetButton("Executar")
self.oHelper.WaitShow("Periodo máximo para filtro é de 30 dias. Verifique")
self.oHelper.SetButton("Fechar")
self.oHelper.Program('JURA020')
self.oHelper.SetButton("Perguntas")
self.oHelper.SetValue("MV_PAR01","01/07/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR02","30/05/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR03","",name_attr=True)
self.oHelper.SetValue("MV_PAR04","",name_attr=True)
self.oHelper.SetValue("MV_PAR05","",name_attr=True)
self.oHelper.SetValue("MV_PAR06","",name_attr=True)
self.oHelper.SetButton("Informações")
self.oHelper.SetButton("Executar")
self.oHelper.WaitShow("Filtro incorreto. Data inicial está maior que data final")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_JURA020_CT005(self):
print('CT005 - Efetua validação dos perguntes de Cliente e Loja')
self.oHelper.Program('JURA020')
self.oHelper.SetButton("Perguntas")
self.oHelper.SetValue("MV_PAR01","01/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR02","30/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR03","",name_attr=True)
self.oHelper.SetValue("MV_PAR04","JLT999",name_attr=True)
self.oHelper.SetValue("MV_PAR05","99",name_attr=True)
self.oHelper.SetValue("MV_PAR06","",name_attr=True)
self.oHelper.SetButton("Informações")
self.oHelper.SetButton("Executar")
self.oHelper.WaitShow("Cliente não localizado, verifique a digitação do codigo do Cliente e loja")
self.oHelper.SetButton("Fechar")
self.oHelper.Program('JURA020')
self.oHelper.SetButton("Perguntas")
self.oHelper.SetValue("MV_PAR01","01/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR02","30/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR03","",name_attr=True)
self.oHelper.SetValue("MV_PAR04","JLT999",name_attr=True)
self.oHelper.SetValue("MV_PAR05","",name_attr=True)
self.oHelper.SetValue("MV_PAR06","",name_attr=True)
self.oHelper.SetButton("Informações")
self.oHelper.SetButton("Executar")
self.oHelper.WaitShow("Preencha também o campo de loja para realizar esse filtro")
self.oHelper.SetButton("Fechar")
self.oHelper.Program('JURA020')
self.oHelper.SetButton("Perguntas")
self.oHelper.SetValue("MV_PAR01","01/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR02","30/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR03","",name_attr=True)
self.oHelper.SetValue("MV_PAR04","",name_attr=True)
self.oHelper.SetValue("MV_PAR05","99",name_attr=True)
self.oHelper.SetValue("MV_PAR06","",name_attr=True)
self.oHelper.SetButton("Informações")
self.oHelper.SetButton("Executar")
self.oHelper.WaitShow("Preencha também o campo de cliente para realizar esse filtro")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_JURA020_CT006(self):
print('CT006 - Efetua validação dos perguntes de Palavra Chave e Área Jurídica')
self.oHelper.Program('JURA020')
self.oHelper.SetButton("Perguntas")
self.oHelper.SetValue("MV_PAR01","01/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR02","30/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR03","999999",name_attr=True)
self.oHelper.SetValue("MV_PAR04","",name_attr=True)
self.oHelper.SetValue("MV_PAR05","",name_attr=True)
self.oHelper.SetValue("MV_PAR06","",name_attr=True)
self.oHelper.SetButton("Informações")
self.oHelper.SetButton("Executar")
self.oHelper.WaitShow("Código de Palavra-Chave inválido")
self.oHelper.SetButton("Fechar")
self.oHelper.Program('JURA020')
self.oHelper.SetButton("Perguntas")
self.oHelper.SetValue("MV_PAR01","01/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR02","30/04/2016",name_attr=True)
self.oHelper.SetValue("MV_PAR03","",name_attr=True)
self.oHelper.SetValue("MV_PAR04","",name_attr=True)
self.oHelper.SetValue("MV_PAR05","",name_attr=True)
self.oHelper.SetValue("MV_PAR06","99999",name_attr=True)
self.oHelper.SetButton("Informações")
self.oHelper.SetButton("Executar")
self.oHelper.WaitShow("Não foi localizado nenhum assunto jurídico com os parâmetros solicitados")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
self.oHelper.RestoreParameters()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAJURI/JURA106_2TestCase.py
```python
from tir import Webapp
import unittest
class JURA106_2(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAJURI','20/02/2019','T1','D MG 01 ','05')
inst.oHelper.Program('JURA106')
inst.oHelper.AddParameter("MV_JHBPESF", "", "2", "", "")
inst.oHelper.AddParameter("MV_JTRFWDR", "", "2", "", "")
inst.oHelper.AddParameter("MV_JFLXCOR", "", "2", "", "")
inst.oHelper.SetParameters()
def test_JURA106_2_CT001(self):
assjur = "0000000133"
print('CT001 - Inclusão de follow-ups que geram outro follow-up de forma manual e automática')
self.oHelper.SetButton("Incluir")
self.oHelper.SetValue("NTA_CAJURI",assjur)
self.oHelper.SetValue("NTA_CTIPO","00013")
self.oHelper.SetValue("NTA_DTFLWP","05/12/2019")
self.oHelper.F3(field="NTA_CADVCR",name_attr=True)
self.oHelper.ScrollGrid(column="Contato",match_value="JUR001")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetValue("NTA_CATO","009")
self.oHelper.ClickGridCell("Sigla part",row=1)
self.oHelper.SetValue("NTE_SIGLA","JUR",grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
# Inclusão de andamento
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetValue("cTipoData","1",name_attr=True)
self.oHelper.SetValue("nQtdeDias","1",name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse(assjur, key=2, index=True)
self.oHelper.ClickGridCell("Desc Tipo",row=2)
self.oHelper.SetButton("Visualizar")
self.oHelper.SetValue("NTA_CAJURI",assjur)
self.oHelper.CheckResult("NTA_CTIPO","00014")
self.oHelper.CheckResult("NTA_DTFLWP","04/12/2019")
self.oHelper.CheckResult("NTA_DESC","TIR JURA106_2 - MODELO FOLLOW-UP - Inclusão de follow-ups que geram outro follow-up de forma manual e automatica.")
self.oHelper.SetButton("Fechar")
# Follow-up gerado automaticamente
self.oHelper.SearchBrowse(assjur, key=2, index=True)
self.oHelper.ClickGridCell("Desc Tipo",row=3)
self.oHelper.SetButton("Visualizar")
self.oHelper.SetValue("NTA_CAJURI",assjur)
self.oHelper.CheckResult("NTA_CTIPO","00014")
self.oHelper.CheckResult("NTA_DTFLWP","06/12/2019")
self.oHelper.CheckResult("NTA_DESC","TIR JURA106_2 - MODELO AUTOMATICO FOLLOW-UP - Inclusão de follow-ups que geram outro follow-up de forma manual e automatica.")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_JURA106_2_CT002(self):
assjur = "0000000133"
print('CT002 - Exclusão de um follow-up que possui follow-ups filhos e andamentos gerados.')
self.oHelper.SearchBrowse(assjur, key=2, index=True)
self.oHelper.SetButton("Outras Ações","Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.ClickGridCell("Código",row=4)
self.oHelper.SetButton("Excluír")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("X")
self.oHelper.Program('JURA162')
self.oHelper.SetValue('cValor', 'Contencioso', name_attr=True)
self.oHelper.SetValue('NSZ_COD', assjur)
self.oHelper.ClickLabel('Pesquisar')
self.oHelper.ClickGridCell('Situacao', 1)
self.oHelper.ClickLabel('Alterar')
self.oHelper.SetButton("Follow-ups")
self.oHelper.SearchBrowse(assjur, key=2, index=True)
self.oHelper.CheckHelp(text_problem="Problema: Não foi possivel encontrar registro com esta chave de pesquisa.", button="Fechar")
self.oHelper.SetButton("X")
self.oHelper.SetButton("Fechar")
self.oHelper.ClickLabel('Sair')
self.oHelper.AssertTrue()
def test_JURA106_2_CT003(self):
assjur = "0000000133"
print('CT003 - Geração de follow-up automático a partir da alteração de correspondente.')
self.oHelper.Program('JURA162')
self.oHelper.SetValue('cValor', 'Contencioso', name_attr=True)
self.oHelper.SetValue('NSZ_COD', assjur)
self.oHelper.ClickLabel('Pesquisar')
self.oHelper.SetValue("NSZ_CAREAJ","JUR01")
self.oHelper.ClickLabel('Alterar')
self.oHelper.ClickGridCell('Cód Corresp',row=1, grid_number=2)
self.oHelper.SetValue("NUQ_CCORRE","JTIR01",grid=True,grid_number=2)
self.oHelper.LoadGrid()
self.oHelper.SetValue("NUQ_LCORRE","01",grid=True,grid_number=2)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Follow-ups")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("NTA_DESC","TIR JURA106_2 - MODELO AUTOMATICO FOLLOW-UP - Inclusão de follow-ups que geram outro follow-up de forma manual e automatica.")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
self.oHelper.RestoreParameters()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAJURI/JURA163TestCase.py
```python
from tir import Webapp
import unittest
import time
class JURA163(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAJURI', '16/07/2019', 'T1', 'D MG 01 ', '76')
inst.oHelper.Program('JURA163')
def test_JURA163_CT001(self):
self.oHelper.ClickFolder("Grupos")
self.oHelper.ClickFolder("Principal")
self.oHelper.ClickGridCell("Descrição", row=1)
self.oHelper.SetButton("Alterar")
self.oHelper.ClickFolder("Campos")
self.oHelper.ScrollGrid(column="Campo", match_value="NSZ_CFCORR")
self.oHelper.SetValue('Obrigatório', True, grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_JURA163_CT002(self):
print('CT002 - Inclusão/ Alteração/ Exclusão de Configuração de campos')
# Inclui configuração de campos
self.oHelper.ClickFolder('Configura Campo')
self.oHelper.ClickIcon('Incluir')
self.oHelper.SetValue('NVH_DESC', 'AAAAA_TIR_J163', name_attr=True)
self.oHelper.SetValue('NVH_TABELA', 'NSZT10', name_attr=True)
self.oHelper.SetValue('NVH_CAMPO', 'NSZ_MODPRO', name_attr=True)
self.oHelper.ClickIcon('Salvar')
# Altera configuração de campos
self.oHelper.ClickGridHeader(column_name='Descricao', grid_number=1)
self.oHelper.ClickGridCell('Descricao', 1)
self.oHelper.ClickIcon('Alterar')
self.oHelper.CheckResult('NVH_DESC', 'AAAAA_TIR_J163')
self.oHelper.SetValue('NVH_DESC', 'AAAAA_TIR_J163', name_attr=True)
self.oHelper.SetValue('NVH_TPPESQ', '1 - Processo', name_attr=True)
self.oHelper.ClickIcon('Salvar')
# Cria configuração de pesquisa com a configuração de campos cadastrada
self.oHelper.ClickFolder('Configura Pesquisa')
self.oHelper.SetButton('Nova')
self.oHelper.SetValue('cDescConf', 'TIR_J163', name_attr=True)
self.oHelper.SetButton('Adiciona todos Campos')
self.oHelper.SetValue('NSZ_MODPRO', '1', name_attr=True)
self.oHelper.SetButton('Salvar')
self.oHelper.WaitHide("Atualizando...")
self.oHelper.SetButton('Nova')
self.oHelper.SetButton('Adiciona Campo')
self.oHelper.SetButton('Deleta todos Campos')
self.oHelper.SetButton('Cancelar')
# Exclui configuração de campo
self.oHelper.ClickFolder('Configura Campo')
self.oHelper.ClickGridCell('Descricao', 1)
self.oHelper.ClickIcon('Excluir')
self.oHelper.SetButton('Sim')
self.oHelper.AssertTrue()
def test_JURA163_CT003(self):
print('CT003 - Inclusão de Usuario X Pesquisa utilizando o "Criar como..."')
# Inclui configuração de campo
self.oHelper.ClickFolder('Grupos')
self.oHelper.SetButton("Incluir")
self.oHelper.SetValue('NZX_DESC', 'TIR_J163')
self.oHelper.SetValue('NZX_TIPOA', '1')
self.oHelper.ClickGridCell("Cód Usuário", row=1)
self.oHelper.SetValue("NZY_CUSER", "000483", grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
# Cria Usuario X Pesquisa utilizando o "Criar como..."
self.oHelper.ClickFolder('Relaciona Pesquisa')
self.oHelper.ClickGridCell('Código', 1)
self.oHelper.SetButton("Outras Ações", "Criar Como...")
time.sleep(3)
self.oHelper.SetButton("Outras Ações", "Criar Como...")
self.oHelper.F3(field="NVK_CGRUP", name_attr=True)
self.oHelper.ScrollGrid(column="Descrição", match_value="TIR_J163")
self.oHelper.SetButton("OK")
self.oHelper.SetValue('NVK_CPESQ', '078')
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
# Exclui o relacionamento Usuario X Pesquisa criado
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.CheckResult('NVK_CPESQ', '078')
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("X")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAJURI/JURXFUNTestCase.py
```python
from tir import Webapp
import unittest
class JURXFUN(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAJURI','10/12/2020','T1','D MG 01 ','76')
def test_JURXFUN_CT001(self):
print("CT001 - Execução da automação do JurF3Qry")
self.oHelper.SetLateralMenu("Atualizações > Administrativo > Clientes")
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton('OK')
self.oHelper.F3(field='NUH_CRELAT',name_attr=True)
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("X")
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAJURI/TJurPesqDesTestCase.py
```python
from tir import Webapp
import unittest
import time
class TJurPesqDes(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAJURI', '15/10/2018', 'T1', 'D MG 01 ', '05')
inst.oHelper.Program('JURA099')
inst.oHelper.AddParameter("MV_JHBPESD", "", "1", "", "")
inst.oHelper.AddParameter("MV_JINTVAL", "", "2", "", "")
inst.oHelper.SetParameters()
def test_TJurPesqDes_CT001(self):
print('INICIO - CT001 - Pesquisa de despesas')
self.oHelper.SetValue("cValor", "Contencioso - Desp", name_attr=True)
self.oHelper.SetValue("NT3_CAJURI", "0000000140")
self.oHelper.SetValue("NT3_CTPDES", "001")
self.oHelper.ClickLabel("Pesquisar")
self.oHelper.SetValue("NT3_CAJURI", "0000000140")
self.oHelper.ClickGridCell("Código do cliente",row=1)
self.oHelper.ClickLabel("Visualizar")
self.oHelper.CheckResult("NT3_CAJURI", "0000000140")
self.oHelper.CheckResult("NT3_CTPDES", "001")
self.oHelper.SetButton("Fechar")
self.oHelper.ClickLabel("Sair")
self.oHelper.AssertTrue()
print('FIM - CT001')
def test_TJurPesqDes_CT002(self):
print('INICIO - CT002 - Inclusão de despesa')
self.oHelper.Program('JURA099')
self.oHelper.SetValue("cValor", "Contencioso - Desp", name_attr=True)
self.oHelper.ClickLabel("Incluir")
self.oHelper.SetValue("NT3_CAJURI", "0000000140")
self.oHelper.SetValue("NT3_CTPDES", "005")
self.oHelper.SetValue("NT3_DATA", "21/10/2020")
self.oHelper.SetValue("NT3_CMOEDA", "01")
self.oHelper.SetValue("NT3_VALOR", "140,02")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
print('Pesquisa despesa incluída')
self.oHelper.SetValue("NT3_DATA", "21/10/2020")
self.oHelper.SetValue("NT3_CTPDES", "005")
self.oHelper.SetValue("NT3_CAJURI", "0000000140")
self.oHelper.SetValue("NT3_VALOR", "140,02")
self.oHelper.SetValue("NT3_VALOR", "140,02", position=2)
self.oHelper.ClickLabel("Pesquisar")
self.oHelper.WaitHide("Pesquisando...")
print('Valida despesa incluída')
self.oHelper.ClickLabel("Visualizar")
self.oHelper.CheckResult("NT3_CAJURI", "0000000140")
self.oHelper.CheckResult("NT3_DATA", "21/10/2020")
self.oHelper.CheckResult("NT3_CTPDES", "005")
self.oHelper.CheckResult("NT3_CAJURI", "0000000140")
self.oHelper.CheckResult("NT3_VALOR", "140,02")
self.oHelper.SetButton("Fechar")
self.oHelper.ClickLabel("Sair")
self.oHelper.AssertTrue()
print('FIM - CT002')
def test_TJurPesqDes_CT003(self):
print('INICIO - CT003 - Alteração de despesa')
self.oHelper.Program('JURA099')
self.oHelper.SetValue("cValor", "Contencioso - Desp", name_attr=True)
self.oHelper.SetValue("NT3_CAJURI", "0000000140")
self.oHelper.SetValue("NT3_CTPDES", "001")
self.oHelper.ClickLabel("Pesquisar")
self.oHelper.WaitHide("Pesquisando...")
self.oHelper.ClickLabel("Alterar")
self.oHelper.WaitHide("Carregando...")
self.oHelper.SetValue("NT3_DATA", "21/10/2020")
self.oHelper.SetValue("NT3_CTPDES", "005")
self.oHelper.SetValue("NT3_CAJURI", "0000000140")
self.oHelper.SetValue("NT3_VALOR", "140,03")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
print('Pesquisa despesa alterada')
self.oHelper.SetValue("NT3_DATA", "21/10/2020")
self.oHelper.SetValue("NT3_CTPDES", "005")
self.oHelper.SetValue("NT3_CAJURI", "0000000140")
self.oHelper.SetValue("NT3_VALOR", "140,03")
self.oHelper.SetValue("NT3_VALOR", "140,03", position=2)
self.oHelper.ClickLabel("Pesquisar")
self.oHelper.WaitHide("Pesquisando...")
print('Valida despesa alterada')
self.oHelper.ClickLabel("Visualizar")
self.oHelper.CheckResult("NT3_CAJURI", "0000000140")
self.oHelper.CheckResult("NT3_DATA", "21/10/2020")
self.oHelper.CheckResult("NT3_CTPDES", "005")
self.oHelper.CheckResult("NT3_VALOR", "140,03")
self.oHelper.SetButton("Fechar")
self.oHelper.ClickLabel("Sair")
self.oHelper.AssertTrue()
print('FIM - CT003')
def test_TJurPesqDes_CT004(self):
print('INICIO - CT004 - Alteração em lote')
self.oHelper.Program('JURA099')
self.oHelper.SetValue("cValor", "Contencioso - Desp", name_attr=True)
self.oHelper.SetValue("NT3_CTPDES", "005")
self.oHelper.SetValue("NT3_CAJURI", "0000000140")
self.oHelper.SetValue("NT3_VALOR", "140,02")
self.oHelper.ClickLabel("Pesquisar")
self.oHelper.WaitHide("Pesquisando...")
self.oHelper.ClickLabel("Alteração em Lote")
self.oHelper.SetValue("NT3_CTPDES", "001")
self.oHelper.SetButton("Ok")
self.oHelper.WaitHide("Processando...")
self.oHelper.SetButton("Fechar")
print('Valida - Alteração em lote')
self.oHelper.SetButton("Fechar")
self.oHelper.SetValue("NT3_CAJURI", "0000000140")
self.oHelper.SetValue("NT3_CTPDES", "001")
self.oHelper.SetValue("NT3_VALOR", "140,02")
self.oHelper.SetValue("NT3_VALOR", "140,04", position=2)
self.oHelper.ClickLabel("Pesquisar")
self.oHelper.ClickLabel("Visualizar")
self.oHelper.CheckResult("NT3_CAJURI", "0000000140")
self.oHelper.CheckResult("NT3_CTPDES", "001")
self.oHelper.SetButton("Fechar")
self.oHelper.ClickLabel("Sair")
self.oHelper.AssertTrue()
print('FIM - CT004')
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAJURI/TJurPesquisaTestCase.py
```python
from tir import Webapp
import unittest
import time
class TJurPesquisa(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAJURI','','T1','D MG 01 ','05')
inst.oHelper.Program('JURA162')
def test_TJurPesquisa_CT001(self):
print('CT001 - Visualizar tela de escolha de assunto jurídico')
# Abre a tela de pesquisas e valida se o novo assunto esta disponivel na Inclusão de um processo
self.oHelper.SetValue("cValor","Criminal",name_attr=True)
self.oHelper.WaitFieldValue("NSZ_LCLIEN","")
# Inclui um processo com o novo assunto juridico
self.oHelper.ClickLabel('Incluir')
self.oHelper.ClickGridCell("Descrição",row=2)
self.oHelper.SetButton('Cancelar')
self.oHelper.ClickLabel('Sair')
self.oHelper.AssertTrue()
def test_TJurPesquisa_CT002(self):
print('CT002 - Visualizar as opções de legenda de processos')
self.oHelper.Program('JURA162')
self.oHelper.SetValue("cValor","Contencioso",name_attr=True)
self.oHelper.WaitFieldValue("NSZ_COD","")
self.oHelper.SetValue("NSZ_COD","0000000154")
self.oHelper.ClickLabel('Pesquisar')
self.oHelper.ClickGridCell("",row=1)
time.sleep(3)
self.oHelper.SetKey("Enter",grid=True)
time.sleep(2)
self.oHelper.SetButton('Ok')
self.oHelper.ClickLabel('Sair')
self.oHelper.AssertTrue()
def test_TJurPesquisa_CT003(self):
print('CT003 - Aplicar correção monetária em um processo')
self.oHelper.Program('JURA162')
# Pesquisa o assunto juridico
self.oHelper.SetValue("cValor","Contencioso",name_attr=True)
self.oHelper.WaitFieldValue("NSZ_COD","")
self.oHelper.SetValue("NSZ_COD","0000000154")
self.oHelper.ClickLabel('Pesquisar')
self.oHelper.SetValue("NSZ_COD","0000000154")
self.oHelper.ClickGridCell("Código Assunto Jurídico",row=1)
# Clica no botão de correção monetaria
self.oHelper.ClickLabel('Correção Monetária')
self.oHelper.SetButton("Fechar")
self.oHelper.ClickLabel('Sair')
self.oHelper.AssertTrue()
def test_TJurPesquisa_CT004(self):
print('CT004 - Alterar layout de pesquisa')
self.oHelper.Program('JURA162')
self.oHelper.ClickLabel('Configurar')
self.oHelper.SetButton('Avançar >>')
self.oHelper.SetValue("Indique a quantidade de seções","1")
self.oHelper.SetButton('Avançar >>')
self.oHelper.SetValue("Self:cCmbOpc1","Campos",name_attr=True)
self.oHelper.SetValue("Self:cCmbOpc2","Grid",name_attr=True)
self.oHelper.SetButton('Avançar >>')
self.oHelper.SetButton('Finalizar')
self.oHelper.SetButton('Fechar')
self.oHelper.ClickLabel('Sair')
self.oHelper.Program('JURA162')
self.oHelper.ClickLabel('Configurar')
self.oHelper.SetButton('Avançar >>')
self.oHelper.SetValue("Indique a quantidade de seções","2")
self.oHelper.SetButton('Avançar >>')
self.oHelper.SetValue("Self:cCmbPerc","35",name_attr=True)
self.oHelper.SetValue("Self:cCmbOpc1","Campos",name_attr=True)
self.oHelper.SetValue("Self:cCmbOpc2","",name_attr=True)
self.oHelper.SetButton('Avançar >>')
self.oHelper.SetValue("Self:cCmbPerc","65",name_attr=True,position=2)
self.oHelper.SetValue("Self:cCmbOpc1","Grid",name_attr=True,position=2)
self.oHelper.SetButton('Avançar >>')
self.oHelper.SetButton('Finalizar')
self.oHelper.SetButton('Fechar')
self.oHelper.ClickLabel('Sair')
self.oHelper.Program('JURA162')
self.oHelper.ClickLabel('Configurar')
self.oHelper.SetButton('Avançar >>')
self.oHelper.SetButton('Restaurar Padrão')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Finalizar')
self.oHelper.ClickLabel('Sair')
self.oHelper.Program('JURA162')
self.oHelper.ClickLabel('Sair')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAOMS/OMSA200TESTCASE.py
```python
from tir import Webapp
import unittest
import datetime
class OMSA200(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
# set the date
dataAtual = str(datetime.datetime.now().strftime("%d/%m/%Y"))
inst.oHelper.Setup('SIGAOMS',dataAtual,'T1','D MG 01 ','39')
inst.oHelper.Program("OMSA200")
#Inclusão de Montagem de Carga
def test_OMSA200_CT001(self):
self.oHelper.SetValue("Carga de ?", "")
self.oHelper.SetValue("Carga ate ?", "ZZZZZZ")
self.oHelper.SetValue("Data geracao de ?", "01/01/2020")
self.oHelper.SetValue("Data geracao ate ?", "15/12/2020")
self.oHelper.SetValue("Filtra por ?", "Todas")
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Carregamento","Montagem de Carga")
self.oHelper.SetBranch("D MG 01")
self.oHelper.ClickBox("Codigo","000001",grid_number = 1)
self.oHelper.SetButton("Parâmetros")
self.oHelper.SetValue("Pedido de ?", "")
self.oHelper.SetValue("Pedido ate ?", "ZZZZZZ")
self.oHelper.SetValue("Cliente de ?", "")
self.oHelper.SetValue("Cliente ate ?", "ZZZZZZ")
self.oHelper.SetValue("Aglutina por ?", "Pedido")
self.oHelper.SetValue("Filial de ?", "")
self.oHelper.SetValue("Filial ate ?", "ZZZZZZZZ")
self.oHelper.SetValue("Data Liberacao de ?", "")
self.oHelper.SetValue("Data Liberacao ate ?", "31/12/2020")
self.oHelper.SetValue("Loja de ?", "")
self.oHelper.SetValue("Loja ate ?", "ZZ")
self.oHelper.SetValue("Data Entrega de ?", "")
self.oHelper.SetValue("Data Entrega ate ?", "31/12/2020")
self.oHelper.SetValue("Armazem de ?", "")
self.oHelper.SetValue("Armazem até ?", "ZZ")
self.oHelper.SetValue("Grupo Cliente De ?", "")
self.oHelper.SetValue("Grupo Cliente Ate ?", "ZZZZZZ")
self.oHelper.SetValue("Rota De ?", "")
self.oHelper.SetValue("Rota Ate ?", "ZZZZZZ")
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Ok")
self.oHelper.ClickBox("Pedido","OMS002",grid_number = 5)
self.oHelper.ClickBox("Pedido","OMS003",grid_number = 5)
self.oHelper.SetButton("Outras Ações","Seq. Ent.")
self.oHelper.SetButton("Outras Ações","Sequencia anterior")
self.oHelper.SetButton("Outras Ações","Sequencia posterior")
self.oHelper.SetButton("Outras Ações","Hora inicial")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Veiculo")
self.oHelper.SetValue("cVeiculo", "OMS-A120", name_attr=True)
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Pedido")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Outras Ações","Graficos")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Outras Ações","Transp.")
self.oHelper.SetValue("cDakTransp", "TSSTR1", name_attr=True)
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Outras Ações","Tipo Oper/ Class. Frete")
self.oHelper.SetValue("cDAKTpOp", "3", name_attr=True)
self.oHelper.SetValue("cDAKClFr", "1", name_attr=True)
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Nova")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#Manutenção
def test_OMSA200_CT002(self):
dataAtual = str(datetime.datetime.now().strftime("%d/%m/%Y"))
self.oHelper.SearchBrowse("D MG 01 " + dataAtual, 'Filial+data + Hora + Cod. Carga + Seq. Carga ')
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Carregamento","Manutencao")
self.oHelper.SetButton("Outras Ações","Est.Ped")
self.oHelper.ClickBox("Item","01", grid_number = 1)
self.oHelper.SetButton("Editar")
self.oHelper.SetValue("nQtdNew", "2,00", name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#Agrupmamento
def test_OMSA200_CT003(self):
dataAtual = str(datetime.datetime.now().strftime("%d/%m/%Y"))
self.oHelper.SearchBrowse("D MG 01 " + dataAtual, 'Filial+data + Hora + Cod. Carga + Seq. Carga ')
self.oHelper.SetButton("Carregamento","Agrupa")
self.oHelper.SetValue("cCodCarDes", "000017", name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.AssertTrue()
#Operaçãoes Gerais
def test_OMSA200_CT004(self):
self.oHelper.SetButton("Outras Ações","Legenda")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Outras Ações","Entregas")
self.oHelper.SetButton("Sair")
self.oHelper.SetButton("Carregamento","Montagem de Carga")
self.oHelper.SetBranch("D MG 01")
self.oHelper.ClickBox("Codigo","000001",grid_number = 1)
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Outras Ações","Refresh")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Outras Ações","Legenda")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Outras Ações","Pesquisa")
self.oHelper.SetValue("xPesq", "000005", name_attr=True)
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
#Associa Motorista
def test_OMSA200_CT005(self):
self.oHelper.SearchBrowse("D MG 01 000017", 'Filial+cod. Carga + Seq. Carga')
self.oHelper.SetButton("Carregamento","Associar Veiculo")
self.oHelper.SetValue("cVeiculo", "OMS0001", name_attr=True)
self.oHelper.SetValue("cVeiculo2", "OMS0002", name_attr=True)
self.oHelper.SetValue("cMotorista", "OMS001", name_attr=True)
self.oHelper.SetValue("cAjuda1", "OMS001", name_attr=True)
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#Bloqueio
def test_OMSA200_CT006(self):
self.oHelper.SearchBrowse("D MG 01 000017", 'Filial+cod. Carga + Seq. Carga')
self.oHelper.SetButton("Carregamento","Bloqueio")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Carregamento","Bloqueio")
self.oHelper.SetButton("Sim")
self.oHelper.AssertTrue()
#Estorno
def test_OMSA200_CT007(self):
self.oHelper.SearchBrowse("D MG 01 000017", 'Filial+cod. Carga + Seq. Carga')
self.oHelper.SetButton("Carregamento","Estorno")
self.oHelper.SetButton("Sim")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGAOMS/OMSA320TESTCASE.py
```python
from tir import Webapp
import unittest
import datetime
class OMSA320(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
# set the date
dataAtual = str(datetime.datetime.now().strftime("%d/%m/%Y"))
inst.oHelper.Setup('SIGAOMS',dataAtual,'T1','D MG 01 ','39')
inst.oHelper.Program("OMSA320")
#Efetuar Retorno
def test_OMSA320_CT001(self):
self.oHelper.SearchBrowse("D MG 01 000020")
self.oHelper.SetButton("Efetua Retorno")
self.oHelper.SetButton("Outras Ações", "Apont.")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
#Estornar Retorno
def test_OMSA320_CT002(self):
self.oHelper.SearchBrowse("D MG 01 000020")
self.oHelper.SetButton("Visualiza")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Outras Ações", "Estorna Retorno")
self.oHelper.SetButton("Sim")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGAPCO/PCOA160TESTCASE.py
```python
from tir import Webapp
import unittest
class PCOA160(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAPCO", "06/04/2020", "T1", "D MG 01 ")
inst.oHelper.Program("PCOA160")
def test_PCOA160_001(self):
#protege os testes para serem rodados apens no release 12.1.30
if self.oHelper.GetRelease() > '12.1.027':
self.oHelper.SearchBrowse("D MG 01 001") #filtra o processo de sistema
self.oHelper.SetButton("Alterar")
self.oHelper.CheckHelp(text='Registro de Configuracao de Sistema Nao deve ser alterado ou excluido', button='Fechar')
self.oHelper.AssertTrue()
def test_PCOA160_002(self):
#protege os testes para serem rodados apens no release 12.1.30
if self.oHelper.GetRelease() > '12.1.027':
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton("Ok")
self.oHelper.SetValue("Configuracao","099")
self.oHelper.SetValue("Descricao","FILTRO POR CUBO")
self.oHelper.SetValue("Codigo Cubo","02")
self.oHelper.SetValue("AKL_UTILIZ","3 - Visoes por Cubo",name_attr=True)
self.oHelper.SetButton("Outras Ações", "Cpo/Cubo")
self.oHelper.SetFocus("Campo Ref.",grid_cell=True,row_number=1)
self.oHelper.SetKey("F3",grid=True)
self.oHelper.SetButton("Cancelar")
self.oHelper.SetFocus("Campo Filtro",grid_cell=True,row_number=1)
self.oHelper.SetKey("F3",grid=True)
self.oHelper.SetButton("Cancelar")
self.oHelper.ClickGridCell("Tipo", 1)
self.oHelper.SetButton("Outras Ações", "Cons.Padrao")
self.oHelper.CheckHelp(text='NO_CONPAD', button='Fechar')
self.oHelper.ClickGridCell("Valor Inicio", 1)
self.oHelper.SetButton("Outras Ações", "Cons.Padrao")
self.oHelper.SearchBrowse("01")
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Ok")
self.oHelper.ClickGridCell("Valor Final", 1)
self.oHelper.SetButton("Outras Ações", "Cons.Padrao")
self.oHelper.SearchBrowse("01")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Salvar")
self.oHelper.WaitShow("Cadastro de Configuracoes de Visao Gerencial - PCO - INCLUIR")
self.oHelper.SetButton("Cancelar")
self.oHelper.SearchBrowse("D MG 01 099")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult('AKL_CONFIG','099',name_attr=True)
self.oHelper.CheckResult('AKL_DESCRI','FILTRO POR CUBO',name_attr=True)
self.oHelper.CheckResult('AKL_CUBE', '02',name_attr=True)
self.oHelper.CheckResult('Titulo','CO',grid=True,line=1,grid_number=1,name_attr=False)
self.oHelper.CheckResult('Titulo','Centro de Custo',grid=True,line=2,grid_number=1,name_attr=False)
self.oHelper.CheckResult('Titulo','TP.SALDO',grid=True,line=3,grid_number=1,name_attr=False)
self.oHelper.LoadGrid() #para verificação de valor de grid se faz necessario usar função LoadGrid
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_PCOA160_003(self):
#protege os testes para serem rodados apens no release 12.1.30
if self.oHelper.GetRelease() > '12.1.027':
self.oHelper.SearchBrowse("D MG 01 098")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.SearchBrowse("D MG 01 098")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult('AKL_CONFIG','098',name_attr=True)
self.oHelper.CheckResult('AKL_DESCRI','FILTRO POR CUBO',name_attr=True)
self.oHelper.CheckResult('AKL_CUBE', '02',name_attr=True)
self.oHelper.CheckResult('Titulo','CO',grid=True,line=1,grid_number=1,name_attr=False)
self.oHelper.CheckResult('Titulo','Centro de Custo',grid=True,line=2,grid_number=1,name_attr=False)
self.oHelper.CheckResult('Titulo','TP.SALDO',grid=True,line=3,grid_number=1,name_attr=False)
self.oHelper.LoadGrid() #para verificação de valor de grid se faz necessario usar função LoadGrid
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertFalse()
else:
self.oHelper.AssertTrue()
def test_PCOA160_004(self):
#protege os testes para serem rodados apens no release 12.1.30
if self.oHelper.GetRelease() > '12.1.027':
self.oHelper.SearchBrowse("D MG 01 097")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue("Descricao","FILTRO POR CUBO ALTERADO")
self.oHelper.SetValue("Codigo Cubo","50")
self.oHelper.CheckHelp(text='REGNOIS',text_problem='Não existe registro relacionado a este código.', button='Fechar')
self.oHelper.SetValue("Codigo Cubo","C1")
self.oHelper.SetButton("Salvar")
self.oHelper.SearchBrowse("D MG 01 097")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult('AKL_CONFIG','097',name_attr=True)
self.oHelper.CheckResult('AKL_DESCRI','FILTRO POR CUBO ALTERADO',name_attr=True)
self.oHelper.CheckResult('AKL_CUBE', 'C1',name_attr=True)
self.oHelper.CheckResult('Titulo','CO',grid=True,line=1,grid_number=1,name_attr=False)
self.oHelper.CheckResult('Titulo','Centro de Custo',grid=True,line=2,grid_number=1,name_attr=False)
self.oHelper.CheckResult('Titulo','TP.SALDO',grid=True,line=3,grid_number=1,name_attr=False)
self.oHelper.LoadGrid() #para verificação de valor de grid se faz necessario usar função LoadGrid
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
def test_PCOA160_005(self):
#protege os testes para serem rodados apens no release 12.1.30
if self.oHelper.GetRelease() > '12.1.027':
self.oHelper.SearchBrowse("D MG 01 001") #filtra o processo de sistema
self.oHelper.SetButton("Outras Ações","Copiar")
self.oHelper.SetValue("MV_PAR01","")
self.oHelper.SetButton("Ok")
self.oHelper.CheckHelp(text='OBRIGAT',text_problem='Um ou mais campos obrigatórios não foram preenchidos. xxxxxxxxxxxxxxxxxx -> xxxxxxxxxx Campo : Copiar Cfg.: 001 >> Nova Config.Parametros Visão', button='Fechar')
self.oHelper.SetValue("MV_PAR01","096")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Fechar")
self.oHelper.SearchBrowse("D MG 01 096")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult('AKL_CONFIG','096',name_attr=True)
self.oHelper.CheckResult('AKL_DESCRI','VISAO ORCAMENTARIA',name_attr=True)
self.oHelper.CheckResult('AKL_CUBE', '',name_attr=True)
self.oHelper.CheckResult('Titulo','Planilha Orct.',grid=True,line=1,grid_number=1,name_attr=False)
self.oHelper.CheckResult('Titulo','Versao',grid=True,line=2,grid_number=1,name_attr=False)
self.oHelper.CheckResult('Titulo','Conta Orcamentaria',grid=True,line=3,grid_number=1,name_attr=False)
self.oHelper.CheckResult('Titulo','Classe Orcamentaria',grid=True,line=4,grid_number=1,name_attr=False)
self.oHelper.LoadGrid() #para verificação de valor de grid se faz necessario usar função LoadGrid
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAPCO/PCOA170TESTCASE.py
```python
from tir import Webapp
import unittest
from datetime import datetime
import string
import random
class PCOA170(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAPCO', '08/04/2020', 'T1', 'D MG 02 ')
inst.oHelper.Program('PCOA170')
# Inclusao
def test_PCOA170_CT001(self):
codigoAKN01 = 'TIR'
memoAKN01 = 'TESTE TIR - INCLUSAO'
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch('D MG 02 ')
self.oHelper.SetValue('AKN_CODIGO', codigoAKN01)
self.oHelper.SetValue('AKN_DESCRI', memoAKN01)
self.oHelper.SetValue('AKN_NMAX', '1' )
self.oHelper.SetValue('AKN_CONFIG', '001' )
self.oHelper.SetValue('AKN_MEMO', memoAKN01 )
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Cancelar')
self.oHelper.SearchBrowse(f'D MG 02 {codigoAKN01}')
self.oHelper.AssertTrue()
# Alteracao
def test_PCOA170_CT002(self):
codigoAKN01 = '001'
contaOrc = '01'
descricItem = 'VISAO GERENCIAL ORCAMENTARIA 001'
self.oHelper.SearchBrowse(f'D MG 02 {codigoAKN01}')
self.oHelper.SetButton('Alterar')
# Abertura de Arvore e posicionando no segundo item
self.oHelper.ClickGridCell('Descricao', 2)
# Clicar no Botao 'outras acoes'
self.oHelper.SetButton('Outras ações', 'Estrut.')
# MENU FLUTUANTE(menupopup)
self.oHelper.ClickMenuPopUpItem("Incluir C.O.G.")
self.oHelper.SetValue('AKO_CO', contaOrc )
self.oHelper.SetValue('AKO_DESCRI', descricItem )
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Confirmar')
self.oHelper.SearchBrowse(f'D MG 02 {codigoAKN01}')
self.oHelper.AssertTrue()
# Alteracao com edicao de item de configuracao
def test_PCOA170_CT003(self):
codigoAKN01 = '002'
memoAKN01 = 'VISAO GERENCIAL 002'
codigoPlan = 'PCO000001'
versao = '0001'
contaOrcDe = '01001'
contaOrcAte = '01002'
operacaoDe = '0000000001'
operacaoAte = '0000000002'
self.oHelper.SearchBrowse(f'D MG 02 {codigoAKN01}')
self.oHelper.SetButton('Alterar')
# Abertura de Arvore e posicionando no segundo item
self.oHelper.WaitShow('Visao Gerencial Orcamentaria - ALTERAR')
self.oHelper.ClickGridCell("Descricao", 2)
# Expande Arvore
self.oHelper.SetFocus('Descricao',grid_cell=True,row_number=2)
# Abertura de Arvore e posicionando no terceiro item
self.oHelper.ClickGridCell('Descricao', 3)
# Clicar na aba "itens"
self.oHelper.ClickFolder('Itens')
self.oHelper.SetButton('Editar')
self.oHelper.SetValue('Planilha Orct.', codigoPlan, grid=True, grid_number=2)
self.oHelper.SetValue('Versao', versao, grid=True, grid_number=2)
self.oHelper.SetValue('Conta Orcamentaria De', contaOrcDe, grid=True, grid_number=2)
self.oHelper.SetValue('Conta Orcamentaria Ate', contaOrcAte, grid=True, grid_number=2)
self.oHelper.SetValue('Operacao De', operacaoDe, grid=True, grid_number=2)
self.oHelper.SetValue('Operacao Ate', operacaoAte, grid=True, grid_number=2)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Gravar')
self.oHelper.CheckResult('Planilha Orct.', codigoPlan, grid=True, grid_number=2)
self.oHelper.CheckResult('Versao', versao, grid=True, grid_number=2)
self.oHelper.CheckResult('Conta Orcamentaria De', contaOrcDe, grid=True, grid_number=2)
self.oHelper.CheckResult('Conta Orcamentaria Ate', contaOrcAte, grid=True, grid_number=2)
self.oHelper.CheckResult('Operacao De', operacaoDe, grid=True, grid_number=2)
self.oHelper.CheckResult('Operacao Ate', operacaoAte, grid=True, grid_number=2)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Confirmar')
self.oHelper.SearchBrowse(f'D MG 02 {codigoAKN01}')
self.oHelper.AssertTrue()
# Exclusao
def test_PCOA170_CT004(self):
codigoAKN01 = '003'
self.oHelper.SearchBrowse(f'D MG 02 {codigoAKN01}')
self.oHelper.SetButton('Outras ações', 'Excluir')
self.oHelper.SetButton('Confirmar')
self.oHelper.SearchBrowse(f'D MG 02 {codigoAKN01}')
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult('AKN_CODIGO', codigoAKN01)
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertFalse()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAPCP/MATA730TESTCASE.py
```python
from tir import Webapp
import unittest
class MATA730(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAPCP','29/04/2019','T1','D MG 01 ','10')
inst.oHelper.Program('MATA730')
def test_MATA730_001(self):
self.oHelper.SetValue('Periodo Inicial ?','29/04/2019')
self.oHelper.SetValue('Periodo Final ?','29/04/2019')
self.oHelper.SetValue('Dt.Entrega De ?','29/04/2019')
self.oHelper.SetValue('Dt.Entrega Ate ?','29/04/2019')
self.oHelper.SetValue('Ordem de Prod. De ?','PCP13301001')
self.oHelper.SetValue('Ordem de Prod. Ate ?','PCP13301001')
self.oHelper.SetValue('Saldo a Considerar ?','Ordem de Prod.')
self.oHelper.SetValue('Considera informacoes ?','Roteiro operaco')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Ok')
self.oHelper.ClickBox('Numero da OP','PCP133')
self.oHelper.SetButton('Calculo')
self.oHelper.Program('MATA730')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAPLS/PLSA090ODTESTCASE.py
```python
import unittest
from tir import Webapp
from tir.technologies.apw_internal import ApwInternal
import datetime
import time
DateSystem = datetime.datetime.today().strftime('%d/%m/%Y')
DateVal = datetime.datetime(2120, 5, 17)
# -------------------------------------------------------------------
# /*/{Protheus.doc} PLSA090ODTestCase
# TIR - Casos de testes da rotina Odontologica
# @author r.soares
# @since 27/05/2020
# @version 12
# -------------------------------------------------------------------
class PLSA090OD(unittest.TestCase):
#-------------------------------------------
# Inicialiação setUpClass para TIR - PLSA090OD
#-------------------------------------------
@classmethod
def setUpClass(self):
# inst.oHelper = ApwInternal("config.json")
# inst.oHelper.Setup()
self.oHelper = Webapp()
self.oHelper.SetTIRConfig(config_name="User", value="admin")
self.oHelper.SetTIRConfig(config_name="Password", value="<PASSWORD>")
self.oHelper.Start()
self.oHelper.Setup("SIGAPLS", DateSystem, "T1", "M SP 01 ", "33")
self.oHelper.Program('PLSA094D')
self.oHelper.AddParameter("MV_PLCALPG", "", "2", "2", "2")
self.oHelper.SetParameters()
#-------------------------------------------
# Inicio dos casos de testes TIR - PLSA090OD
#-------------------------------------------
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL001
# TIR - Casos de testes da rotina Odontologica
# Incluindo guia
# @author r.soares
# @since 27/05/2020
# @version 12
# # # -------------------------------------------------------------------
def test_PLSA090OD_PL001(self):
self.oHelper.WaitShow("Liberação Odontológica")
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch("M SP 01")
time.sleep(3)
self.oHelper.SetValue('B01_USUARI', '00010020000001014')
# self.oHelper.SetButton('Ok')
# self.oHelper.SetButton('Gerar Protoc.')
# self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Outras Ações',sub_item='Limpa')
self.oHelper.SetButton('Sim')
self.oHelper.SetValue('B01_USUARI', '00010020000001014')
self.oHelper.SetValue('B01_CODRDA', '000004')
self.oHelper.SetButton('Outras Ações',sub_item='Financ')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Outras Ações',sub_item='Cliente')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Outras Ações',sub_item='Cobranca')
self.oHelper.SetValue('Ano Base ?', '2020')
self.oHelper.SetValue('Mes Base ?', '06')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Salvar')
self.oHelper.SetValue('B01_CID', 'F12')
self.oHelper.SetValue('B01_REGSOL', '1234')
self.oHelper.ClickGridCell("Cd. Proc.")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetValue("BE2_CODPAD", "03", name_attr=True)
self.oHelper.SetValue("BE2_CODPRO", "0001", name_attr=True)
self.oHelper.SetValue("BE2_DENREG", "11", name_attr=True)
self.oHelper.SetValue("BE2_FADENT", "D", name_attr=True)
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
time.sleep(10)
self.oHelper.SetButton('Ok')
time.sleep(5)
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL002
# TIR - Casos de testes da rotina Odontologica
# Incluindo interacao na guia
# @author r.soares
# @since 27/05/2020
# @version 12
# # -------------------------------------------------------------------
def test_PLSA090OD_PL002(self):
chaveTit = "M SP 00010020000001"
self.oHelper.SearchBrowse(f'{chaveTit}', key=2, index=True)
self.oHelper.SetButton('Outras Ações',sub_item='Excluir')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL003
# TIR - Casos de testes da rotina Odontologica
# Excluindo uma guia PLSA090OD
# @author r.soares
# @since 27/05/2020
# @version 12
# # -------------------------------------------------------------------
def test_PLSA090OD_PL003(self):
chaveTit = "M SP 00010020000001"
self.oHelper.SearchBrowse(f'{chaveTit}', key=2, index=True)
self.oHelper.SetButton('Outras Ações',sub_item='Interação')
self.oHelper.SetBranch('M SP 01')
self.oHelper.ClickGridCell("Cod. Tab. Pd")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetValue('Motivo Padrão', '001')
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL004
# TIR - Casos de testes da rotina Odontologica
# Visualizando uma guia PLSA090OD
# @author r.soares
# @since 27/05/2020
# @version 12
# -------------------------------------------------------------------
def test_PLSA090OD_PL004(self):
chaveTit = "M SP 00010020000001"
self.oHelper.SearchBrowse(f'{chaveTit}', key=2, index=True)
self.oHelper.SetButton('Visualizar')
self.oHelper.CheckResult('B01_USUARI', '00010020000001014')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL005
# TIR - Casos de testes da rotina Odontologica
# Imprimindo guia da rotina PLSA090OD
# @author r.soares
# @since 27/05/2020
# @version 12
# -------------------------------------------------------------------
def test_PLSA090OD_PL005(self):
chaveTit = "M SP 00010020000001"
self.oHelper.SearchBrowse(f'{chaveTit}', key=2, index=True)
self.oHelper.SetButton('Outras Ações',sub_item='Imp.Guia')
self.oHelper.SetButton('Ok')
time.sleep(3)
self.oHelper.SetButton('Ok')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL006
# TIR - Casos de testes da rotina Odontologica
# Imprimindo varias guias da rotina PLSA090OD
# @author r.soares
# @since 27/05/2020
# @version 12
# -------------------------------------------------------------------
def test_PLSA090OD_PL006(self):
chaveTit = "M SP 00010020000001"
self.oHelper.SearchBrowse(f'{chaveTit}', key=2, index=True)
self.oHelper.SetButton('Outras Ações',sub_item='Imp.Varias Guias')
self.oHelper.SetButton('Ok')
time.sleep(3)
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL007
# TIR - Casos de testes da rotina Odontologica
# Adicionando valor no campo de conhecimento
# @author r.soares
# @since 27/05/2020
# @version 12
# -------------------------------------------------------------------
def test_PLSA090OD_PL007(self):
chaveTit = "M SP 00010020000001"
self.oHelper.SearchBrowse(f'{chaveTit}', key=2, index=True)
self.oHelper.SetButton('Outras Ações',sub_item='Conhecimento, Guia')
time.sleep(3)
self.oHelper.ClickGridCell("Objeto")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetKey("F3", grid=True)
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Outras Ações',sub_item='Conhecimento, Item')
time.sleep(3)
self.oHelper.SetButton('Pesquisar')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Conhecimento')
self.oHelper.ClickGridCell("Objeto")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetKey("F3", grid=True)
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Sair')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL008
# TIR - Casos de testes da rotina Odontologica
# Copia
# @author r.soares
# @since 27/05/2020
# @version 12
# -------------------------------------------------------------------
def test_PLSA090OD_PL008(self):
chaveTit = "M SP 00010020000001"
self.oHelper.SearchBrowse(f'{chaveTit}', key=2, index=True)
self.oHelper.SetButton('Outras Ações',sub_item='Copiar')
self.oHelper.SetBranch("M SP 01")
self.oHelper.SetValue('B01_USUARI', '00010020000001014')
self.oHelper.SetValue('B01_CID', 'F12')
self.oHelper.SetValue('B01_REGSOL', '1234')
self.oHelper.ClickGridCell("Cd. Proc.")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetValue("BE2_QTDPRO", "1,0000", name_attr=True)
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
time.sleep(10)
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL009
# TIR - Casos de testes da rotina Odontologica
# Cancelando guia do plsa090od
# @author r.soares
# @since 27/05/2020
# @version 12
# -------------------------------------------------------------------
def test_PLSA090OD_PL009(self):
chaveTit = "M SP 00010020000001"
self.oHelper.WaitShow("Liberação Odontológica")
self.oHelper.SearchBrowse(f'{chaveTit}', key=2, index=True)
self.oHelper.SetButton('Outras Ações',sub_item='Cancelar Guia')
time.sleep(3)
self.oHelper.SetKey("F3")
self.oHelper.SetButton('OK')
self.oHelper.SetButton('Confirma')
self.oHelper.SetButton('Sim')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
# # -------------------------------------------------------------------
# # /*/{Protheus.doc} TEST_PLSA090OD_PL010
# # TIR - Casos de testes da rotina Odontologica
# # Incluindo guia com pagamento na fatura sem a guia comprada
# # @author r.soares
# # @since 27/05/2020
# # @version 12
# # # # -------------------------------------------------------------------
def test_PLSA090OD_PL010(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch("M SP 01")
time.sleep(3)
self.oHelper.SetValue('B01_USUARI', '00010020000001014')
self.oHelper.SetValue('B01_CID', 'F12')
self.oHelper.SetValue('B01_SIGLA', 'CRM')
self.oHelper.SetValue('B01_ESTSOL', 'SP')
self.oHelper.SetValue('B01_REGSOL', '1234')
self.oHelper.SetValue('B01_QUACOB', '2')
self.oHelper.SetKey('Enter')
self.oHelper.ClickGridCell("Cd. Proc.")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetValue("BE2_CODPAD", "03", name_attr=True)
self.oHelper.SetValue("BE2_CODPRO", "81000030", name_attr=True)
self.oHelper.SetValue("BE2_GUIACO", "0", name_attr=True)
self.oHelper.SetValue("BE2_QUACOB", "2", name_attr=True)
self.oHelper.SetValue("BE2_DENREG", "11", name_attr=True)
self.oHelper.SetValue("BE2_FADENT", "D", name_attr=True)
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
time.sleep(10)
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL011
# TIR - Casos de testes da rotina Odontologica
# Incluindo guia com pagamento na fatura com a guia comprada
# @author r.soares
# @since 27/05/2020
# @version 12
# # # -------------------------------------------------------------------
def test_PLSA090OD_PL011(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch("M SP 01")
time.sleep(3)
self.oHelper.SetValue('B01_USUARI', '00010020000001014')
self.oHelper.SetValue('B01_CID', 'F12')
self.oHelper.SetValue('B01_SIGLA', 'CRM')
self.oHelper.SetValue('B01_ESTSOL', 'SP')
self.oHelper.SetValue('B01_REGSOL', '1234')
self.oHelper.SetValue('B01_QUACOB', '2')
self.oHelper.SetKey('Enter')
self.oHelper.ClickGridCell("Cd. Proc.")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetValue("BE2_CODPAD", "03", name_attr=True)
self.oHelper.SetValue("BE2_CODPRO", "82000026", name_attr=True)
self.oHelper.SetValue("BE2_GUIACO", "1", name_attr=True)
self.oHelper.SetValue("BE2_QUACOB", "2", name_attr=True)
self.oHelper.SetValue("BE2_DENREG", "11", name_attr=True)
self.oHelper.SetValue("BE2_FADENT", "D", name_attr=True)
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Outras Ações',sub_item='Comprar')
self.oHelper.SetButton('Fechar', check_error= False)
self.oHelper.SetButton('Outras Ações',sub_item='Co-Part.')
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
time.sleep(10)
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL012
# TIR - Casos de testes da rotina Odontologica
# Incluindo guia com pagamento no ato sem a guia estar comprada
# @author r.soares
# @since 27/05/2020
# @version 12
# # # -------------------------------------------------------------------
def test_PLSA090OD_PL012(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch("M SP 01")
time.sleep(3)
self.oHelper.SetValue('B01_USUARI', '00010020000001014')
self.oHelper.SetValue('B01_CID', 'F12')
self.oHelper.SetValue('B01_SIGLA', 'CRM')
self.oHelper.SetValue('B01_ESTSOL', 'SP')
self.oHelper.SetValue('B01_REGSOL', '1234')
self.oHelper.SetValue('B01_QUACOB', '1')
self.oHelper.SetKey('Enter')
self.oHelper.ClickGridCell("Cd. Proc.")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetValue("BE2_CODPAD", "03", name_attr=True)
self.oHelper.SetValue("BE2_CODPRO", "82000026", name_attr=True)
self.oHelper.SetValue("BE2_GUIACO", "0", name_attr=True)
self.oHelper.SetValue("BE2_QUACOB", "2", name_attr=True)
self.oHelper.SetValue("BE2_DENREG", "11", name_attr=True)
self.oHelper.SetValue("BE2_FADENT", "D", name_attr=True)
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
time.sleep(10)
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL013
# TIR - Casos de testes da rotina Odontologica
# Incluindo guia com pagamento no ato com a guia comprada
# @author r.soares
# @since 27/05/2020
# @version 12
# -------------------------------------------------------------------
def test_PLSA090OD_PL013(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch("M SP 01")
time.sleep(3)
self.oHelper.SetValue('B01_USUARI', '00010020000001014')
self.oHelper.SetValue('B01_CODRDA', '000001')
self.oHelper.SetValue('B01_CID', 'F12')
self.oHelper.SetValue('B01_SIGLA', 'CRM')
self.oHelper.SetValue('B01_ESTSOL', 'SP')
self.oHelper.SetValue('B01_REGSOL', '1234')
self.oHelper.SetValue('B01_QUACOB', '1')
self.oHelper.SetKey('Enter')
self.oHelper.ClickGridCell("Cd. Proc.")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetValue("BE2_CODPAD", "03", name_attr=True)
self.oHelper.SetValue("BE2_CODPRO", "0001", name_attr=True)
self.oHelper.SetValue("BE2_GUIACO", "1", name_attr=True)
self.oHelper.SetValue("BE2_QUACOB", "1", name_attr=True)
self.oHelper.SetValue("BE2_DENREG", "11", name_attr=True)
self.oHelper.SetValue("BE2_FADENT", "D", name_attr=True)
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
time.sleep(10)
self.oHelper.SetButton('Ok')
time.sleep(2)
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL014
# TIR - Casos de testes da rotina Odontologica
# Inclusao da rotina de autorizacao Odontologica com refer�ncia na libera��o odonto
# @author r.soares
# @since 27/05/2020
# @version 12
# -------------------------------------------------------------------
def test_PLSA090OD_PL014(self):
self.oHelper.Start()
self.oHelper.Setup("SIGAPLS", DateSystem, "T1", "M SP 01 ", "33")
self.oHelper.Program('PLSA094C')
self.oHelper.WaitShow("Autorização Odontológica")
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch("M SP 01")
time.sleep(3)
self.oHelper.SetValue('B01_NUMLIB', '000120200900000006', grid=False, grid_number=1, ignore_case=True,row=None, name_attr=False, check_value=False)
self.oHelper.SetValue('B01_CODRDA', '000001')
self.oHelper.SetValue('B01_CID', 'F12')
self.oHelper.SetValue('B01_REGSOL', '1234')
self.oHelper.ClickGridCell("Cd. Proc.")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetValue("BE2_CODPAD", "03", name_attr=True)
self.oHelper.SetValue("BE2_CODPRO", "82000026", name_attr=True)
self.oHelper.SetValue("BE2_DENREG", "11", name_attr=True)
self.oHelper.SetValue("BE2_FADENT", "D", name_attr=True)
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
time.sleep(10)
self.oHelper.SetButton('Ok')
time.sleep(5)
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
# -------------------------------------------------------------------
# /*/{Protheus.doc} TEST_PLSA090OD_PL015
# TIR - Casos de testes da rotina Odontologica
# Copia da rotina de autorizacao Odontologica
# @author r.soares
# @since 27/05/2020
# @version 12
# -------------------------------------------------------------------
def test_PLSA090OD_PL015(self):
# self.oHelper.WaitShow("Autorização Odontológica")
chaveTit = "M SP 00010020000001"
self.oHelper.SearchBrowse(f'{chaveTit}', key=2, index=True)
self.oHelper.SetButton('Outras Ações',sub_item='Copiar')
self.oHelper.SetBranch("M SP 01")
self.oHelper.SetValue('B01_USUARI', '00010020000001014')
self.oHelper.SetValue('B01_CODRDA', '000001')
self.oHelper.SetValue('B01_CID', 'F12')
self.oHelper.SetValue('B01_REGSOL', '1234')
self.oHelper.ClickGridCell("Cd. Proc.")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
time.sleep(10)
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
#-------------------------------------------
# Fim dos casos de testes TIR - PLSA090OD
#-------------------------------------------
#-------------------------------------------
# Encerramento class para TIR - PLSA090OD
#-------------------------------------------
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAPLS/PLSA092TESTCASE.py
```python
import unittest
import time
from tir import Webapp
from datetime import datetime
DateSystem = datetime.today().strftime('%d/%m/%Y')
class PLSA092(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAPLS", DateSystem, "T1", "M SP 01 ", "33")
inst.oHelper.Program("PLSA092")
inst.oHelper.AddParameter("MV_PLSSOOL", "", "1", "1", "1") # Habilita Prorroga��o de Interna��o
inst.oHelper.AddParameter("MV_PLCALPG", "", "2", "2", "2") # Novo Calendario de Pagamento
inst.oHelper.SetParameters()
#//-------------------------------------------------------------------
# {Protheus.doc} test_PLSA092_PL001
# Teste 01 - Consulta Autorizada
# @author r.soares
# @since 05/11/2020
# @version 12
# @see
#//-------------------------------------------------------------------
def test_PLSA092_PL001(self):
# Dados para o teste
matricula = '00010022000004010'
rda = '000004'
solicitante = '013500'
grpIntern = '1'
indClinica = 'teste'
regInter = '1'
cid = 'F12'
procedimento = '10101012'
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch("M SP 01")
time.sleep(3)
self.oHelper.SetValue('BE4_USUARI', matricula, name_attr=True)
self.oHelper.SetValue('BE4_CODRDA', rda)
self.oHelper.F3(field='BE4_CODLOC')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('BE4_GRPINT', grpIntern)
self.oHelper.F3(field='BE4_TIPINT')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.F3(field='BE4_INTSIP')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('BE4_CID', cid)
self.oHelper.SetValue('BE4_REGSOL', solicitante)
self.oHelper.F3(field='BE4_CIDSEC')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.F3(field='BE4_PADINT')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.F3(field='BE4_PADCON')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('BE4_REGEXE', solicitante)
self.oHelper.SetValue('BE4_INDCLI', indClinica)
self.oHelper.SetValue('BE4_REGINT', regInter)
self.oHelper.ClickGridCell("Cod. Proc.")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetValue('BEJ_CODPRO', procedimento)
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
#//-------------------------------------------------------------------
# {Protheus.doc} test_PLSA092_PL002
# Teste 02 - Interna��o Autorizada
# @author r.soares
# @since 05/11/2020
# @version 12
# @see
#//-------------------------------------------------------------------
def test_PLSA092_PL002(self):
# Dados para o teste
matricula = '00010022000004010'
rda = '000004'
solicitante = '013500'
grpIntern = '1'
indClinica = 'teste'
regInter = '1'
cid = 'F12'
procedimento = '40304361'
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch("M SP 01")
time.sleep(3)
self.oHelper.SetValue('BE4_USUARI', matricula, name_attr=True)
self.oHelper.SetValue('BE4_CODRDA', rda)
self.oHelper.F3(field='BE4_CODLOC')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('BE4_GRPINT', grpIntern)
self.oHelper.F3(field='BE4_TIPINT')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.F3(field='BE4_INTSIP')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('BE4_CID', cid)
self.oHelper.SetValue('BE4_REGSOL', solicitante)
self.oHelper.F3(field='BE4_CIDSEC')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.F3(field='BE4_PADINT')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.F3(field='BE4_PADCON')
time.sleep(3)
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('BE4_REGEXE', solicitante)
self.oHelper.SetValue('BE4_INDCLI', indClinica)
self.oHelper.SetValue('BE4_REGINT', regInter)
self.oHelper.ClickGridCell("Cod. Proc.")
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetValue('BEJ_CODPRO', procedimento)
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
#//-------------------------------------------------------------------
# {Protheus.doc} test_PLSA092_PL003
# Teste 03 - Exclusão - Consulta
# @author r.soares
# @since 05/11/2020
# @version 12
# @see
#//-------------------------------------------------------------------
def test_PLSA092_PL003(self):
# Dados para o teste
chave = "M SP 00010022000004010"
self.oHelper.SearchBrowse(f'{chave}', key=4, index=True)
self.oHelper.SetButton('Visualizar')
self.oHelper.CheckResult('BE4_USUARI', '00010022000004010')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Outras Ações',sub_item='Excluir')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
#//-------------------------------------------------------------------
# {Protheus.doc} test_PLSA092_PL004
# Teste 04 - Internação e Alta do Beneficiário - Autorizada
# @author r.soares
# @since 05/11/2020
# @version 12
# @see
#//-------------------------------------------------------------------
def test_PLSA092_PL004(self):
# Dados para o teste
TpAlta = "1"
chave = "M SP 00010022000004010"
self.oHelper.SearchBrowse(f'{chave}', key=4, index=True)
self.oHelper.SetButton('Outras Ações',sub_item='Data Internação.')
self.oHelper.SetBranch("M SP 01 ")
self.oHelper.SetButton('Incluir')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Outras Ações',sub_item='Data Alta')
self.oHelper.SetBranch("M SP 01 ")
horas = datetime.now()
hora = horas.hour
minuto = horas.minute
HrAlta = str(hora) + str(minuto)
self.oHelper.SetValue('Hora da Alta', HrAlta, check_value=False)
time.sleep(3)
self.oHelper.SetButton('Fechar', check_error=False)
self.oHelper.SetValue('Tipo de Alta', TpAlta, check_value=False)
self.oHelper.SetButton('Incluir')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
#//-------------------------------------------------------------------
# {Protheus.doc} test_PLSA092_PL005
# Teste 05 - Inserindo Visita Profissional
# @author r.soares
# @since 05/11/2020
# @version 12
# @see
#//-------------------------------------------------------------------
def test_PLSA092_PL005(self):
# Dados para o teste
medVisi = "013500"
dataPrev = DateSystem
chave = "M SP 00010022000006012"
self.oHelper.SearchBrowse(f'{chave}', key=4, index=True)
self.oHelper.SetButton('Outras Ações',sub_item='Inserir Visita Profissional')
self.oHelper.SetBranch("M SP 01 ")
self.oHelper.ClickGridCell("med. visi.", row=1)
self.oHelper.SetKey("ENTER", grid=True)
self.oHelper.SetValue("BOZ_CODM", medVisi, name_attr=True)
self.oHelper.SetValue("BOZ_DATPRE", dataPrev, name_attr=True)
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGAPLS/PLSA728TESTCASE.py
```python
from tir import Webapp
import unittest
"""-------------------------------------------------------------------
/*/{Protheus.doc} PLSA728TestCase
TIR - Casos de testes da rotina Agente X Cidade
@author <NAME>
@since 09/2020
@version 12
-------------------------------------------------------------------"""
class PLSA728(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAPLS","10/09/2020","T1","M SP 01","33")
inst.oHelper.Program("PLSA728")
def test_PLSA728_001(self):
# Inclusao
self.oHelper.SetButton("Incluir")
#self.oHelper.SetBranch('M SP 01')
self.oHelper.SetButton("OK")
self.oHelper.SetValue("B9H_NOME","PLS DSAUPC TIR INCLUSAO")
self.oHelper.SetValue("B9H_EMAIL","<EMAIL>")
self.oHelper.SetValue("B9H_TEL","11332221234",check_value = False)
## Grid
#self.oHelper.SetValue("B9K_CODCID","3550308", grid=True, line=1, grid_number=1)
self.oHelper.ClickGridCell("Cod Cidade")
self.oHelper.SetKey("Enter", grid=True, grid_number=1, )
self.oHelper.SetValue("B9K_CODCID","3550308")
self.oHelper.ClickGridCell("Cidade")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
# Alteracao
self.oHelper.SearchBrowse(f'{"M SP 0001000001"}', key=1, index=True)
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue("B9H_NOME","PLS DSAUPC TIR ALTERACAO")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
# Visualizacao
self.oHelper.SearchBrowse(f'{"M SP 0001000001"}', key=1, index=True)
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("B9H_NOME","PLS DSAUPC TIR ALTERACAO")
self.oHelper.SetButton("Fechar")
# Exclusao
self.oHelper.SearchBrowse(f'{"M SP 0001000001"}', key=1, index=True)
self.oHelper.SetButton("Outras Ações",sub_item='Excluir')
self.oHelper.SetValue("B9H_NOME","PLS DSAUPC TIR ALTERACAO")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAPLS/PLSA809TESTCASE.py
```python
from tir import Webapp
import unittest
from tir.technologies.apw_internal import ApwInternal
import datetime
import time
DateSystem = datetime.datetime.today().strftime('%d/%m/%Y')
DateVal = datetime.datetime(2120, 5, 17)
"""-------------------------------------------------------------------
/*/{Protheus.doc} PLSA809TestCase
TIR - Casos de testes da rotina Indicacao de Prestador via CallCenter
@author <NAME>
@since 10/2020
@version 12
-------------------------------------------------------------------"""
class PLSA809(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAPLS","13/10/2020","T1","M SP 01","33")
inst.oHelper.Program("PLSA809")
inst.oHelper.AddParameter("MV_PLCALPG","" , "2")
inst.oHelper.AddParameter("MV_PL809VL","" , ".F.")
inst.oHelper.SetParameters()
def test_PLSA809_001(self):
# INCLUIR
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("M SP 01 ")
self.oHelper.SetValue("B9Y_CARTEI","00010100000001024", check_value = False)
self.oHelper.SetValue("B9Y_CRMCGC","41226834671", check_value = False)
time.sleep(10)
self.oHelper.SetValue("B9Y_NOME","PLS DSAUPC TIR INCLUSAO")
self.oHelper.SetValue("B9Y_EMAIL","<EMAIL>")
self.oHelper.SetValue("B9Y_TEL","11332220000", check_value = False)
self.oHelper.SetValue("B9Y_TIPOAT", "3 - Ambos")
self.oHelper.SetValue("B9Y_OBS", "TESTE 2 TIR INCLUSAO")
# Grid Enderecos
self.oHelper.ClickGridCell("Cód Logr",row=1, grid_number=1)
self.oHelper.SetKey("Enter", grid=True, grid_number=1)
self.oHelper.SetValue("B9V_CODLOG","008")
self.oHelper.ClickGridCell("Endereço",row=1, grid_number=1)
self.oHelper.SetKey("Enter", grid=True, grid_number=1)
time.sleep(10)
self.oHelper.SetValue("B9V_ENDER","ALBERT BARTHOLOME")
self.oHelper.ClickGridCell("Nº",row=1, grid_number=1)
self.oHelper.SetKey("Enter", grid=True, grid_number=1)
time.sleep(10)
self.oHelper.SetValue("B9V_NUMERO","434")
#self.oHelper.ClickGridCell("Complemento",row=1, grid_number=1)
#self.oHelper.SetKey("Enter", grid=True, grid_number=1)
time.sleep(30)
#self.oHelper.SetValue("B9V_COMEND","SALA 10")
#self.oHelper.ClickGridCell("Bairro",row=1, grid_number=1)
#self.oHelper.SetKey("Enter", grid=True, grid_number=1)
time.sleep(30)
#self.oHelper.SetValue("B9V_BAIRRO","BUTANTA")
#self.oHelper.ClickGridCell("Cód Cidade",row=1, grid_number=1)
#self.oHelper.SetKey("Enter", grid=True, grid_number=1)
time.sleep(30)
#self.oHelper.SetValue("B9V_CODCID","3550308")
#self.oHelper.ClickGridCell("CEP",row=1, grid_number=1)
#self.oHelper.SetKey("Enter", grid=True, grid_number=1)
time.sleep(30)
#self.oHelper.SetValue("B9V_CEP","05541000", check_value = False)
# Grid Especialidades
self.oHelper.ClickGridCell("Cod Espec",row=1, grid_number=2)
self.oHelper.SetKey("Enter", grid=True, grid_number=2)
time.sleep(10)
self.oHelper.SetValue("B9Q_CODESP","002")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar") # "O beneficiário não possui email cadastrado na base de dados, favor informar o protocolo a ele para que seja possível acompanhar a indicação feita"
self.oHelper.SetButton("Fechar") # "Registro inserido com sucesso."
# VISUALIZAR
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("B9Y_CRMCGC","41226834671")
self.oHelper.SetButton("Fechar")
# INCLUSÃO COM MESMO CRM/CNPJ
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("M SP 01 ")
self.oHelper.SetValue("B9Y_CARTEI","00010100000001024", check_value = False)
self.oHelper.SetValue("B9Y_CRMCGC","41226834671", check_value = False)
time.sleep(10)
self.oHelper.SetValue("B9Y_NOME","PLS DSAUPC TIR INCLUSAO 2")
self.oHelper.SetValue("B9Y_EMAIL","<EMAIL>")
self.oHelper.SetValue("B9Y_TEL","11333331234", check_value = False)
self.oHelper.SetValue("B9Y_TIPOAT", "2 - Assistencial")
self.oHelper.SetValue("B9Y_OBS", "TESTE 2 TIR INCLUSAO COM MESMO CRM/CNPJ")
# Grid Especialidades
self.oHelper.ClickGridCell("Indicar",row=1, grid_number=2)
self.oHelper.SetKey("Enter", grid=True, grid_number=2)
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar") # "O beneficiário não possui email cadastrado na base de dados, favor informar o protocolo a ele para que seja possível acompanhar a indicação feita"
self.oHelper.SetButton("Fechar") # "Registro inserido com sucesso."
self.oHelper.SetButton('x')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAPLS/PLSA813TESTCASE.py
```python
from tir import Webapp
import unittest
"""-------------------------------------------------------------------
/*/{Protheus.doc} PLSA813TestCase
TIR - Casos de testes da rotina Credenciamento
@author <NAME>
@since 09/2020
@version 12
-------------------------------------------------------------------"""
class PLSA813(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAPLS","23/09/2020","T1","M SP 01","33")
inst.oHelper.Program("PLSA813")
inst.oHelper.AddParameter("MV_PLCALPG","" , "2")
inst.oHelper.SetParameters()
def test_PLSA813_001(self):
# Inclusao
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton("OK")
self.oHelper.SetValue("B9Y_NOME","PLS DSAUPC TIR INCLUSAO")
self.oHelper.SetValue("B9Y_CPFCGC","51831698536",check_value = False)
self.oHelper.SetValue("B9Y_EMAIL","<EMAIL>",check_value = False)
self.oHelper.SetValue("B9Y_TEL","11333331234",check_value = False)
self.oHelper.SetValue("B9Y_CRMNUM","123456")
self.oHelper.SetValue("B9Y_CRMEST","SP")
self.oHelper.SetValue("B9Y_TIPOAT","3 - Ambos")
self.oHelper.SetValue("B9Y_SEXO","2 - Masculino")
self.oHelper.SetValue("B9Y_NASCTO","01/01/1985",check_value = False)
self.oHelper.SetValue("B9Y_NATU","3550308")
self.oHelper.SetValue("B9Y_ECIVIL","S")
self.oHelper.SetValue("B9Y_FCAPTA","1 - Prestador Portal")
self.oHelper.SetValue("B9Y_STCRED","1 - Pendente com a Operadora")
# Pasta Endereco
self.oHelper.ClickFolder('Endereço')
self.oHelper.ClickGridCell("CEP",row=1, grid_number=1)
self.oHelper.SetKey("Enter", grid=True, grid_number=1)
self.oHelper.SetValue("B9V_CEP","05541000",check_value = False)
self.oHelper.ClickGridCell("Nº",row=1, grid_number=1)
self.oHelper.SetKey("Enter", grid=True, grid_number=1)
self.oHelper.SetValue("B9V_NUMERO","100",check_value = False)
# Pasta Especialidade
self.oHelper.ClickFolder('Especialidade')
self.oHelper.ClickGridCell("Cod Espec",row=1, grid_number=1)
self.oHelper.SetKey("Enter", grid=True, grid_number=1)
self.oHelper.SetValue("B9Q_CODESP","002")
self.oHelper.ClickGridCell("Tempo Formac",row=1, grid_number=1)
self.oHelper.SetKey("Enter", grid=True, grid_number=1)
self.oHelper.SetValue("B9Q_TEMFOR","01/01/2015",check_value = False)
# Pasta Passos do Credenciamento
self.oHelper.ClickFolder('Passos do Credenciamento')
self.oHelper.ClickGridCell("Passo",row=1, grid_number=1)
self.oHelper.SetKey("Enter", grid=True, grid_number=1)
self.oHelper.SetValue("B2E_CODPAS","0001")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar") # O arquivo informado no cadastro de sinalizadores n�o existe
self.oHelper.SetButton("Fechar") # O arquivo informado no cadastro de sinalizadores n�o existe
self.oHelper.SetButton("Fechar") # O e-mail referente ao Passo 0001 Foi enviado com Sucesso!
self.oHelper.SetButton("Fechar") # Registro inserido com sucesso
#self.oHelper.SearchBrowse(f'{"M SP PLS DSAUPC TIR INCLUSAO"}', key=2, index=True)
self.oHelper.SetButton("Analisar")
self.oHelper.SetValue("B9Y_STCRED","2 - Pendente com o Prestador")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Analisar")
self.oHelper.SetValue("B9Y_STCRED","4 - Indeferido")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Analisar")
self.oHelper.SetValue("B9Y_STCRED","3 - Credenciado")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Analisar")
self.oHelper.ClickFolder('Endereço')
self.oHelper.ClickGridCell("Deferido?",row=1, grid_number=1)
self.oHelper.SetKey("Enter", grid=True, grid_number=1)
self.oHelper.ClickFolder('Especialidade')
self.oHelper.ClickGridCell("Deferido?",row=1, grid_number=1)
self.oHelper.SetKey("Enter", grid=True, grid_number=1)
self.oHelper.ClickFolder('Passos do Credenciamento')
self.oHelper.ClickGridCell("Finalizado?",row=1, grid_number=1)
self.oHelper.SetKey("Enter", grid=True, grid_number=1)
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("B9Y_NOME","PLS DSAUPC TIR INCLUSAO")
self.oHelper.CheckResult("B9Y_STCRED","3 - Credenciado")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("x")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATAF/TAFA236TESTCASE.py
```python
from cawebhelper import CAWebHelper
import unittest
class TAFA236(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = CAWebHelper()
#inst.oHelper.Setup('SIGATAF','10/08/2017','99','01','05')
inst.oHelper.Setup('SIGATAF','10/08/2017','T1','D MG 01 ','05')
inst.oHelper.UTProgram('TAFA236')
def test_TAFA236_CT001(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetFilial('D MG 01')
self.oHelper.UTSetValue('aCab','C8X_DTINI','012018')
self.oHelper.UTSetValue('aCab','C8X_CODIGO','DMG01FUNC001')
self.oHelper.UTSetValue('aCab','C8X_DESCRI','FUNC 142510 GERENTE DESENV SISTEMAS')
self.oHelper.UTSetValue('aCab','C8X_CODCBO','000143')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Visualizar')
self.oHelper.UTCheckResult('aCab','C8X_DTINI','012018')
self.oHelper.UTCheckResult('aCab','C8X_CODIGO','DMG01FUNC001')
self.oHelper.UTCheckResult('aCab','C8X_DESCRI','FUNC 142510 GERENTE DESENV SISTEMAS')
self.oHelper.UTCheckResult('aCab','C8X_CODCBO','000143')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_TAFA236_CT002(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetFilial('D MG 01')
self.oHelper.UTSetValue('aCab','C8X_DTINI','012018')
self.oHelper.UTSetValue('aCab','C8X_CODIGO','DMG01FUNC002')
self.oHelper.UTSetValue('aCab','C8X_DESCRI','FUNC 142510 GERENTE DESENV SISTEMAS')
self.oHelper.UTSetValue('aCab','C8X_CODCBO','000143')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Visualizar')
self.oHelper.UTCheckResult('aCab','C8X_DTINI','012018')
self.oHelper.UTCheckResult('aCab','C8X_CODIGO','DMG01FUNC002')
self.oHelper.UTCheckResult('aCab','C8X_DESCRI','FUNC 142510 GERENTE DESENV SISTEMAS')
self.oHelper.UTCheckResult('aCab','C8X_CODCBO','000143')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATAF/TAFA261TESTCASE.py
```python
from tir import Webapp
import unittest
class TAFA261(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGATAF','29/04/2019','T1','D MG 01 ','84')
#inst.oHelper.Program('TAFA261') chama a rotina pelo campo de pesquisa
inst.oHelper.SetLateralMenu('Atualizações > Eventos Esocial > Não-periódicos > Afastamento Temp.') #navega pelos menus laterais
def test_TAFA261_CT001(self):
#-------------------------Incluir-----------------------------------------------------------------
# Grid Informações do Afastamento
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch('D MG 01')
self.oHelper.ClickFolder('Informações do Afastamento')
self.oHelper.SetValue('CM6_FUNC', '000001')
self.oHelper.SetValue('CM6_DTAFAS','20032019')
self.oHelper.SetValue('CM6_MOTVAF','000001')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
#--------------------------Alterar-----------------------------------------------------------
self.oHelper.SearchBrowse('D MG 01 000001', key='Filial+id.func. + Reg. Ativo?')
self.oHelper.SetButton('Alterar', 'Retificar / Alterar Evento')
self.oHelper.ClickFolder('Informações do Afastamento')
self.oHelper.SetValue('CM6_OBSERV', 'Teste alteracao')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
#--------------------------Visualizar-----------------------------------------------------------
self.oHelper.SearchBrowse('D MG 01 000001', key='Filial+id.func. + Reg. Ativo?')
self.oHelper.SetButton('Visualizar')
self.oHelper.SetButton('Fechar')
#--------------------------Termino Afastamento---------------------------------------------------
self.oHelper.SearchBrowse('D MG 01 000001', key='Filial+id.func. + Reg. Ativo?')
self.oHelper.SetButton('Alterar', 'Término do Afastamento')
self.oHelper.SetValue('CM6_DTFAFA', '05042019')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
#--------------------------Filtro CPF / Pesquisa por CPF------------------------------------------
self.oHelper.SearchBrowse('D MG 01 000001', key='Filial+id.func. + Reg. Ativo?')
self.oHelper.SetButton('Filtro CPF/Nome')
self.oHelper.SetValue('CPF', '07185885094')
self.oHelper.SetButton('Ok')
#--------------------------Filtro CPF / Pesquisa por Nome------------------------------------------
self.oHelper.SearchBrowse('D MG 01 000001', key='Filial+id.func. + Reg. Ativo?')
self.oHelper.SetButton('Filtro CPF/Nome')
self.oHelper.SetValue('Nome', '<NAME>')
self.oHelper.SetButton('Ok')
#--------------------------Filtro CPF / Pesquisa por Data Inicio e Data Termino---------------------
self.oHelper.SearchBrowse('D MG 01 000001', key='Filial+id.func. + Reg. Ativo?')
self.oHelper.SetButton('Filtro CPF/Nome')
self.oHelper.SetValue('Data Início', '20032019')
self.oHelper.SetValue('Data Término', '05042019')
self.oHelper.SetButton('Ok')
#--------------------------Gerar XML em Lote-------------------------------------------------------
self.oHelper.SetButton('Gerar XML em Lote')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Sim')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('Fechar')
#--------------------------Exclusão-----------------------------------------------------------------
self.oHelper.SearchBrowse('D MG 01 000001', key='Filial+id.func. + Reg. Ativo?')
self.oHelper.SetButton('Excluir Registro')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATAF/TAFMONTESTESTCASE.py
```python
from cawebhelper import CAWebHelper
import unittest
class TAFMONTES(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = CAWebHelper()
#inst.oHelper.Setup('SIGATAF','10/08/2017','99','01','05')
inst.oHelper.Setup('SIGATAF','10/08/2017','T1','D MG 01 ','05')
#inst.oHelper.UTProgram('TAFMONTES')
inst.oHelper.SetLateralMenu("Atualizações > Eventos Esocial > Monitoramento")
def test_TAFMONTES_CT001(self):
self.oHelper.UTSetValue('aCab','Data Inicial','01/01/2000')
self.oHelper.UTSetValue('aCab','Data Fim','31/12/2019')
self.oHelper.SetButton('Selecionar Filiais')
self.oHelper.ClickBox('Filial','D MG 01')
self.oHelper.SetButton('Ok')
self.oHelper.SetButton('Aplicar Filtro')
self.oHelper.ClickBox('Evento','S-1000 - INFORMACOES DO EMPREGADOR/CONTRIBUINTE/ÓRGÃO PÚBLIC')
self.oHelper.SetButton('Exportar XMLs')
self.oHelper.UTSetValue('aCab','Todos',True)
self.oHelper.SetButton('Confirmar')
self.oHelper.SetFilePath("SERVIDOR\\xml\\")
self.oHelper.MessageBoxClick('Ok')
self.oHelper.SetButton('Sair')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATEC/TECA640TESTCASE.py
```python
from tir import Webapp
import unittest
class TECA640(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGATEC","11/12/2020","T1","D MG 01","28")
inst.oHelper.Program("TECA640")
def test_TECA640_001(self):
self.oHelper.SetValue("Cliente de ?","")
self.oHelper.SetValue("Cliente ate ?","zzzzzz")
self.oHelper.SetValue("Produto de ?","")
self.oHelper.SetValue("Produto ate ?","ZZZZZZ")
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Cancelar")
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATEC/TECA700TESTCASE.py
```python
from tir import Webapp
import unittest
class TECA700(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGATEC","11/12/2020","T1","D MG 01","28")
inst.oHelper.Program("TECA700")
def test_TECA700_001(self):
self.oHelper.SetButton("Incluir")
self.oHelper.SetButton("OK")
self.oHelper.SetValue("ABH_CODCLI","000001")
self.oHelper.SetValue("ABH_LOJA","01")
self.oHelper.SetValue("ABH_DESCRI","PROJETO TESTE")
self.oHelper.SetValue("ABH_REFER","01/01/2020")
self.oHelper.SetValue("ABH_ENTREG","30/12/2020")
self.oHelper.SetValue("ABH_CODPRO","COM000000000000000000000000110")
self.oHelper.SetValue("ABH_CPAGPV","001")
self.oHelper.SetValue("ABI_ETAPA","00", grid=True)
self.oHelper.SetValue("ABI_DESCRI","ETAPA 01",grid=True)
self.oHelper.SetValue("ABI_VALOR","100,00",grid=True)
self.oHelper.SetValue("ABI_CODPRO"," COM00000000000000000000000011",grid=True)
self.oHelper.SetValue("ABI_CODPRB","OC01 ",grid=True)
self.oHelper.SetValue("ABI_INIPRV","01/01/2020",grid=True)
self.oHelper.SetValue("ABI_FIMPRV","05/01/2020",grid=True)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue("ABH_DESCRI","PROJETO TESTE2")
self.oHelper.SetKey("F4")
self.oHelper.SetValue("ABJ_TAREFA","T1",grid=True)
self.oHelper.SetValue("ABJ_DESCRI","TAREFA 001",grid=True)
self.oHelper.SetValue("ABJ_TPREVI","0000:59",grid=True)
self.oHelper.SetValue("ABJ_TORCAD","0000:59",grid=True)
self.oHelper.LoadGrid()
self.oHelper.CheckResult("ABJ_TAREFA","T1",grid=True, line=1)
self.oHelper.CheckResult("ABJ_DESCRI","TAREFA 001",grid=True,line=1)
self.oHelper.CheckResult("ABJ_TPREVI","0000:59",grid=True, line=1)
self.oHelper.CheckResult("ABJ_TORCAD","0000:59",grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult("ABH_CODCLI","000001")
self.oHelper.CheckResult("ABH_LOJA","01")
self.oHelper.CheckResult("ABH_DESCRI","PROJETO TESTE2")
self.oHelper.CheckResult("ABH_REFER","01/01/2020")
self.oHelper.CheckResult("ABH_ENTREG","30/12/2020")
self.oHelper.CheckResult("ABH_CODPRO","COM000000000000000000000000110")
self.oHelper.CheckResult("ABH_CPAGPV","001")
self.oHelper.CheckResult("ABI_ETAPA","00", grid=True, line=1)
self.oHelper.CheckResult("ABI_DESCRI","ETAPA 01",grid=True, line=1)
self.oHelper.CheckResult("ABI_VALOR","100,00",grid=True, line=1)
self.oHelper.CheckResult("ABI_CODPRO"," COM00000000000000000000000011",grid=True, line=1)
self.oHelper.CheckResult("ABI_CODPRB","OC01 ",grid=True, line=1)
self.oHelper.CheckResult("ABI_INIPRV","01/01/2020",grid=True, line=1)
self.oHelper.CheckResult("ABI_FIMPRV","05/01/2020",grid=True, line=1)
self.oHelper.LoadGrid()
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATMK/TMK380TESTCASE.py
```python
from tir import Webapp
from datetime import datetime, timedelta
import time
import unittest
class TMKA380(unittest.TestCase):
@classmethod
def setUpClass(self):
self.oHelper = Webapp(autostart=False)
self.oHelper.SetTIRConfig(config_name="User", value="televendas")
self.oHelper.SetTIRConfig(config_name="Password", value="1")
def test_TMKA380_CT005(self):
# Inicia o novo Webapp para logar com o User no Módulo
self.oHelper.Start()
self.oHelper.Setup("SIGATMK","01/04/2020","T1","D MG 01 ","13")
self.oHelper.Program("TMKA380")
# Posiciona o Atendimento: 000024
self.oHelper.ClickGridCell("Nome", row=2)
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Sim")
self.oHelper.SetValue("UA_OPER","1 - Faturamento")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Cancela")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Sim")
self.oHelper.AssertTrue()
def test_TMKA380_CT006(self):
# Posiciona o Atendimento: 000025
self.oHelper.ClickGridCell("Nome", row=1)
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.SetButton("Sim")
self.oHelper.SetValue("UA_OBS","Teste")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Ok")
self.oHelper.ClickGridCell("Tipo", row=4)
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Cancela")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Sim")
self.oHelper.SetButton("Cancelar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(self):
'''self.oHelper.TearDown()
self.oHelper2.TearDown()
self.oHelper3.TearDown()'''
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATMS/TMSA010TESTCASE.py
```python
from tir import Webapp
import unittest
class TMSA010(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGATMS','15/10/2020','T1','M SP 03 ','43')
inst.oHelper.Program('TMSA010')
inst.oHelper.AddParameter("MV_TMSTFO","",".T.",".T.",".T.")
inst.oHelper.SetParameters()
#Inclusão de registro
def test_TMA010_CT001(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch('M SP 03')
self.oHelper.ClickBox("Descricao", "TABELA DE FRETE A RECEBER TMS", grid_number=1)
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('DT0_CDRORI','Q57204')
self.oHelper.SetValue('DT0_CDRDES','Q57204')
self.oHelper.SetValue('DT0_TABTAR','0001')
self.oHelper.SetValue('DT0_CODPRO','TMS-001-PERIGOSO')
self.oHelper.ClickFolder("TDA a Receber ")
self.oHelper.SetValue('Ate (Dificuldade de acesso com base no total do frete sem imposto.)','999.999.999,9999',grid=True)
self.oHelper.SetValue('Valor','17,00',grid=True, grid_number=1, row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Outras Ações', 'Base TDA')
self.oHelper.WaitShow('Tabela de Frete - INCLUIR')
self.oHelper.SetKey("DELETE", grid=True)
self.oHelper.SetValue('DVY_VLBASE','140,00',grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Outras Ações', 'Comp.Tab.')
self.oHelper.WaitShow('Tabela de Frete - INCLUIR')
self.oHelper.SetKey("DELETE", grid=True)
self.oHelper.SetValue('DTK_EXCMIN','10,0000',grid=True,grid_number=1,row=1)
self.oHelper.SetValue('DTK_VALMIN','101,33',grid=True,grid_number=1,row=1)
self.oHelper.SetValue('DTK_VALMAX','200,19',grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
#Copia de registro
def test_TMA010_CT002(self):
self.oHelper.SearchBrowse("M SP R00101Q57204")
self.oHelper.SetButton("Outras Ações", "Copiar")
self.oHelper.ClickLabel('Para o Destino')
self.oHelper.SetButton("Ok")
self.oHelper.SetValue('Para o Destino','Q57154')
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Confirma")
self.oHelper.SearchBrowse("M SP R00101Q57204Q57154")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
#Exclusão de registro
def test_TMA010_CT003(self):
self.oHelper.SearchBrowse("M SP R00101Q57204")
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATMS/TMSA070TESTCASE.py
```python
from tir import Webapp
import unittest
class TMSA070(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGATMS','11/06/2020','T1','M SP 03 ','43')
inst.oHelper.Program('TMSA070')
def test_TMSA070_CT005(self): #Inclusão
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch('M SP 01')
self.oHelper.SetValue('DG_CODDES','100100',grid=True,grid_number=1,row=1)
self.oHelper.SetValue('DG_CODVEI','TMS001',grid=True,grid_number=1,row=1)
self.oHelper.SetValue('DG_FILORI','M SP 01',grid=True,grid_number=1,row=1)
self.oHelper.SetValue('DG_VIAGEM','000001',grid=True,grid_number=1,row=1)
self.oHelper.SetValue('DG_CONTA','1010101001',grid=True,grid_number=1,row=1)
self.oHelper.SetValue('DG_COND','001',grid=True,grid_number=1,row=1)
self.oHelper.SetValue('DG_VALCOB','1000,21',grid=True,grid_number=1,row=1)
self.oHelper.SetValue('DG_SEQMOV','001',grid=True,grid_number=1,row=1)
self.oHelper.SetValue('DG_CODCAR','000001',grid=True,grid_number=1,row=1)
self.oHelper.SetValue('DG_SEQCAR','01',grid=True,grid_number=1,row=1)
self.oHelper.SetValue('DG_TIPUSO','1',grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.AssertTrue()
def test_TMSA070_CT006(self): #Visualizar
self.oHelper.SearchBrowse("M SP 01 000000003100100")
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_TMSA070_CT007(self): #Estornar Baixa
self.oHelper.SearchBrowse("M SP 01 000000003100100")
self.oHelper.SetButton("Outras Ações", "Estorna Baixa")
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_TMSA070_CT008(self): #Excluir
self.oHelper.SearchBrowse("M SP 01 000000003100100")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_TMSA070_CT009(self): #Legenda
self.oHelper.SetButton("Outras Ações", "Legenda")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATMS/TMSA080TESTCASE.py
```python
from tir import Webapp
import unittest
class TMSA080(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGATMS','10/11/2020','T1','M SP 03 ','43')
inst.oHelper.Program('TMSA080')
#Inclusão de registro
def test_TMSA080_CT001(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch('M SP 03')
self.oHelper.ClickBox("Descricao", "TABELA DE FRETE A RECEBER TMS", grid_number=1)
self.oHelper.SetButton('Ok')
self.oHelper.SetValue('DTF_TABTAR','FLP')
self.oHelper.SetValue('DTF_KMDE','100,0')
self.oHelper.SetValue('DTF_KMATE','200,0')
self.oHelper.SetValue('Ate (Peso Mercadoria)','100.000,0000',grid=True)
self.oHelper.SetValue('Valor','117,00',grid=True, grid_number=1, row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
#Exclusao
def test_TMSA080_CT002(self):
self.oHelper.SearchBrowse("M SP R00101FLP")
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
#Copia de registro
def test_TMSA080_CT003(self):
self.oHelper.SetButton("Outras Ações", "Copiar")
self.oHelper.SetValue('Para Tabela','FLP')
self.oHelper.SetValue('Km De','51.000,0')
self.oHelper.SetValue('Km Ate','52.000,0')
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Confirma")
self.oHelper.SearchBrowse("M SP R00101FLP")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATMS/TMSA140TESTCASE.py
```python
from tir import Webapp
import unittest
import datetime
class TMSA140(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
# set the date
dataAtual = str(datetime.datetime.now().strftime("%d/%m/%Y"))
inst.oHelper.Setup('SIGATMS',dataAtual,'T1','M SP 03 ','43')
inst.oHelper.Program("TMSA140A")
inst.oHelper.AddParameter("MV_CONTVEI", "", ".F.")
inst.oHelper.AddParameter("MV_TMSALOC", "", ".F.")
inst.oHelper.AddParameter("MV_ENVIAG", "", ".F.")
inst.oHelper.AddParameter("MV_TMSRRE", "", "")
inst.oHelper.SetParameters()
def test_TMS140A_CT001(self):
self.oHelper.SearchBrowse("M SP 000058")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue("Carregamento ?", "Manual")
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Outras Ações","Comp.Via")
self.oHelper.SetValue("DTR_CODVEI", "TMS0042",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DTR_VALFRE", "1.100,00",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DTR_CREADI", "TMS001",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DTR_LOJCRE", "01",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DTR_QTEIXV", "2",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DTR_CIOT", "12345678901234567",grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Outras Ações","Mot.Viag.")
self.oHelper.SetValue("DUP_CODMOT", "TMS047",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DUP_VALSEG", "100.000,00",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DUP_CONDUT", "1",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DUP_PAGDIA", "1",grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Aju.Viag.")
self.oHelper.SetValue("DUQ_CODAJU", "000002",grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Lac.Veic.")
self.oHelper.SetValue("DVB_LACRE", "0000000002",grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Adiantam./Desp.")
self.oHelper.SetValue("DG_CODDES", "100100",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DG_TOTAL", "12,00",grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Val. Inf.")
self.oHelper.SetValue("DVW_VALOR", "1.100,0000",grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.ClickFolder("Operadoras de Frota")
self.oHelper.SetValue("DTR_CODOPE", "01")
self.oHelper.SetValue("DTR_TPSPDG","3")
self.oHelper.ClickFolder("Outros")
self.oHelper.SetValue("DTR_TIPCRG", "1")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Limite")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
def test_TMS140A_CT002(self):
self.oHelper.SearchBrowse("M SP 000058")
self.oHelper.SetButton("Outras Ações","Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_TMS140A_CT004(self):
self.oHelper.SearchBrowse("M SP 000020")
self.oHelper.SetButton("Visualizar")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Outras Ações","Legenda")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGATMS/TMSA141TESTCASE.py
```python
from tir import Webapp
import unittest
import datetime
class TMSA141(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
# set the date
dataAtual = str(datetime.datetime.now().strftime("%d/%m/%Y"))
inst.oHelper.Setup('SIGATMS',dataAtual,'T1','M SP 03 ','43')
inst.oHelper.Program("TMSA141A")
def test_TMSA141_CT003(self):
self.oHelper.SearchBrowse("M SP 000056")
self.oHelper.SetButton('Alterar')
self.oHelper.SetButton("OK")
self.oHelper.SetButton("Outras Ações","Comp.Via")
self.oHelper.SetValue("DTR_CODVEI", "TMS0047",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DTR_VALFRE", "1.100,00",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DTR_CREADI", "TMS001",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DTR_LOJCRE", "01",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DTR_QTEIXV", "2",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DTR_CIOT", "12345678901234567",grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Outras Ações","Mot.Viag.")
self.oHelper.SetValue("DUP_CODMOT", "TMS047",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DUP_LIBSEG", "123456789012345",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DUP_VALSEG", "100.000,00",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DUP_CONDUT", "1",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DUP_PAGDIA", "1",grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Aju.Viag.")
self.oHelper.SetValue("DUQ_CODAJU", "000002",grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Lac.Veic.")
self.oHelper.SetValue("DVB_LACRE", "0000000002",grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Adiantam./Desp.")
self.oHelper.SetValue("DG_CODDES", "100100",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DG_TOTAL", "12,00",grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Val. Inf.")
#self.oHelper.SetValue("DVW_CODPAS", "61",grid=True,grid_number=1,row=1)
self.oHelper.SetValue("DVW_VALOR", "1.100,0000",grid=True,grid_number=1,row=1)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Salvar")
self.oHelper.ClickFolder("Operadoras de Frota")
self.oHelper.SetValue("DTR_CODOPE", "01")
self.oHelper.SetValue("DTR_TPSPDG","3")
self.oHelper.ClickFolder("Outros")
self.oHelper.SetValue("DTR_TIPCRG", "1")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Outras Ações","Limite")
self.oHelper.SetButton("Salvar")
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
def test_TMSA141_CT004(self):
self.oHelper.SearchBrowse("M SP 000056")
self.oHelper.SetButton("Outras Ações","Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Modules/SIGATMS/TMSA145TESTCASE.py
```python
from tir import Webapp
import unittest
class TMSA145(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGATMS', '06/10/2020', 'T1', 'M SP 04 ', '43')
inst.oHelper.Program('TMSA145')
# Operações basicas no gestão de viagens.
def test_TMA145_CT001(self):
self.oHelper.SetValue("Exibição ?", "Por Veículo")
self.oHelper.SetValue("Veículo ?", "")
self.oHelper.SetValue("Refresh ?", "Manual")
self.oHelper.SetValue("Parâmentros abaixo ?", "Considerar")
self.oHelper.SetValue("Tipo de Frota ?", "Todos")
self.oHelper.SetValue("Status do Veículo ?", "Todos")
self.oHelper.SetValue("Filial Base De ?", "")
self.oHelper.SetValue("Filial Base Ate ?", "ZZZZZZZZ")
self.oHelper.SetValue("Serviço de Transporte ?", "3")
self.oHelper.SetValue("Tipo de Transporte ?", "1")
self.oHelper.SetValue("Região Origem ?", "")
self.oHelper.SetValue("Região Destino ?", "ZZZZZZ")
self.oHelper.SetValue("Status da Viagem ?", "Todos")
self.oHelper.SetValue("Data Viagem De ?", "01/01/2020")
self.oHelper.SetValue("Data Viagem Ate ?", "20/01/2021")
self.oHelper.SetValue("Veiculos sem Alocação ?", "Considerar")
self.oHelper.SetButton('OK') # Confirmação da janela dos Parâmetros
self.oHelper.ClickLabel("Qtde. Viagens:")
self.oHelper.SetKey('F4') #Legenda
self.oHelper.SetButton('Cancelar')
self.oHelper.SetKey('F6') #Legenda
self.oHelper.SetButton('Fechar')
self.oHelper.SetKey('F5') #Refresh
self.oHelper.SetValue("Exibição ?", "Por Documento")
self.oHelper.SetButton('OK')
self.oHelper.ClickLabel("Qtde. Viagens:")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATMS/TMSA260TESTCASE.py
```python
from tir import Webapp
from datetime import datetime
DateSystem = datetime.today().strftime('%d/%m/%Y')
import unittest
import time
class TMSA260(unittest.TestCase):
@classmethod
def setUpClass(inst):
'''
SETUP
Test Case Initial Setup
'''
#Endereço do webapp e o nome do Browser
inst.oHelper = Webapp()
#Parametros de inicializaçao
inst.oHelper.Setup("SIGATMS",DateSystem,"T1","M SP 03 ","43")
#Nome da rotina do Caso de Teste
inst.oHelper.Program("TMSA260")
def test_TMSA260_001(self):
'''
Test Case 001
'''
self.oHelper.SetButton("Incluir")
self.oHelper.SetBranch("M SP 03 ")
self.oHelper.SetValue("DTZ_CODROD","TMS001")
self.oHelper.SetValue("DTZ_NOMROD","CASTELO BRANCO")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_TMSA260_002(self):
order = 'TMS001'
self.oHelper.SearchBrowse(f"M SP {order}", "Filial+cod. Rodovia")
self.oHelper.SetButton("Alterar")
self.oHelper.SetValue("DTZ_NOMROD","RAPOSO TAVARES")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_TMSA260_003(self):
order = 'TMS001'
self.oHelper.SearchBrowse(f"M SP {order}", "Filial+cod. Rodovia")
self.oHelper.SetButton("Outras Ações", "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
'''
Method that finishes the test case.
'''
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATMS/TMSA290TESTCASE.py
```python
from tir import Webapp
import unittest
class TMSA290(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGATMS','19/06/2019','T1','M SP 03 ','43')
inst.oHelper.Program('TMSA290')
def test_TMSA290_CT001(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch('M SP 03')
self.oHelper.SetValue('DU3_COMSEG','AA')
self.oHelper.SetValue('DU3_DESCRI','TESTE AA')
self.oHelper.SetValue('DU3_PRETPG','AAA')
self.oHelper.SetValue('DU3_TIPTPG','PA')
self.oHelper.SetValue('DU3_NATTPG','OUTROS')
self.oHelper.SetValue('DU3_PREIND','001')
self.oHelper.SetValue('DU3_TIPIND','01')
self.oHelper.SetValue('DU3_NATIND','001')
self.oHelper.SetValue('DU3_ATALHO','X')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SearchBrowse("M SP AA")
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult('DU3_COMSEG','AA')
self.oHelper.CheckResult('DU3_DESCRI','TESTE AA')
self.oHelper.CheckResult('DU3_PRETPG','AAA')
self.oHelper.CheckResult('DU3_TIPTPG','PA')
self.oHelper.CheckResult('DU3_NATTPG','OUTROS')
self.oHelper.CheckResult('DU3_PREIND','001')
self.oHelper.CheckResult('DU3_TIPIND','01')
self.oHelper.CheckResult('DU3_NATIND','001')
self.oHelper.CheckResult('DU3_ATALHO','X')
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_TMSA290_CT002(self):
self.oHelper.SearchBrowse("M SP AA")
self.oHelper.SetButton('Alterar')
self.oHelper.SetValue('DU3_DESCRI', 'TESTE ABC123')
self.oHelper.SetButton('Confirmar')
self.oHelper.SetButton('Fechar')
self.oHelper.SetButton("Visualizar")
self.oHelper.CheckResult('DU3_DESCRI', 'TESTE ABC123')
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_TMSA290_CT003(self):
self.oHelper.SearchBrowse("M SP AA")
self.oHelper.SetButton('Outras Ações', "Excluir")
self.oHelper.SetButton("Confirmar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATMS/TMSA320TESTCASE.py
```python
from tir import Webapp
import unittest
class TMSA320(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGATMS','19/06/2019','T1','M SP 03 ','43')
inst.oHelper.Program('TMSA320')
inst.oHelper.AddParameter("MV_DESAWB", "", "DESPAWB")
inst.oHelper.AddParameter("MV_TESAWB", "", "038")
inst.oHelper.SetParameters()
def test_TMSA320_CT001(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch('M SP 03')
self.oHelper.SetValue('DTV_NUMAWB','000987654')
self.oHelper.SetValue('DTV_DIGAWB','8')
self.oHelper.SetValue('DTV_DATEMI','10/11/2020')
self.oHelper.SetValue('DTV_VIAGEM','000069')
self.oHelper.WaitShow('Geracao de AWB - INCLUIR')
self.oHelper.ClickBox('No.Manifesto', '999100003')
self.oHelper.SetButton('Salvar')
self.oHelper.SetValue('DTV_CDRDES', 'Q48708')
self.oHelper.SetValue('DTV_CODPRO', 'TMS-DIVERSOS000000000000000000')
self.oHelper.SetValue('DTV_AERORI', 'GRU')
self.oHelper.SetValue('DTV_AERDES', 'CGH')
self.oHelper.SetValue('DTV_CODCIA', 'TMSLAT')
self.oHelper.SetValue('DTV_LOJCIA', 'AM')
self.oHelper.SetValue('DTV_TABFRE', 'P001')
self.oHelper.SetValue('DTV_CODEMB', 'CX')
self.oHelper.SetButton('Outras Ações', "Digitação do Componen.")
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Outras Ações', "Atualiza Compos.")
self.oHelper.SetButton('Outras Ações', "Cotação")
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Salvar')
self.oHelper.WaitProcessing('Gerando AWB ...')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
def test_TMSA320_CT002(self):
self.oHelper.SearchBrowse("M SP 03 0009876548")
self.oHelper.SetButton('Outras Ações', "Estornar")
self.oHelper.SetButton("Confirmar")
self.oHelper.WaitProcessing('Estornando AWB ...')
self.oHelper.AssertTrue()
def test_TMSA320_CT003(self):
self.oHelper.SearchBrowse("M SP 03 P00000001") #balcao
self.oHelper.SetButton('Outras Ações', "Efetivar")
self.oHelper.SetValue("cNroOfic","123456789",name_attr = True)
self.oHelper.SetValue('Dígito', '1')
self.oHelper.SetButton("Ok")
self.oHelper.WaitHide('AWB Oficial')
self.oHelper.AssertTrue()
def test_TMSA320_CT004(self):
self.oHelper.SearchBrowse("M SP 03 123456789")
self.oHelper.SetButton('Outras Ações', "Altera Efetivação?")
self.oHelper.SetButton("Sim")
self.oHelper.SetValue("cNroOfic","987654321",name_attr = True)
self.oHelper.SetValue('Dígito', '9')
self.oHelper.SetButton("Ok")
self.oHelper.SetButton("Fechar")
self.oHelper.AssertTrue()
def test_TMSA320_CT005(self):
self.oHelper.SearchBrowse("M SP 03 0009876548")
self.oHelper.SetButton('Outras Ações', "Conf. Embarque > Confirmar")
self.oHelper.WaitShow('Registro de Ocorrencias ')
self.oHelper.SetButton("Sim")
self.oHelper.SetValue("Nr. Voo ","123456")
self.oHelper.SetValue('Data Partida', '12/11/2020')
self.oHelper.SetValue('Hora Partida', '12:00')
self.oHelper.SetValue('Data Chegada', '12/11/2020')
self.oHelper.SetValue('Hora Chegada', '15:00')
self.oHelper.SetButton("Salvar")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATMS/TMSA500TESTCASE.py
```python
from tir import Webapp
import unittest
class TMSA500(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGATMS','30/05/2019','T1','M SP 01 ','43')
inst.oHelper.Program('TMSA500')
inst.oHelper.AddParameter("MV_FATPREF", "", "TMS")
inst.oHelper.AddParameter("MV_CLIGEN", "", "TMSCLIGE")
inst.oHelper.AddParameter("MV_NATFAT", "", "001")
inst.oHelper.AddParameter("MV_TIPFAT", "", "01")
inst.oHelper.AddParameter("MV_TMSMFAT", "", "2")
inst.oHelper.AddParameter("MV_CODCOMP", "", "10")
inst.oHelper.AddParameter("MV_COMPENT", "", "05")
inst.oHelper.AddParameter("MV_TESDR", "", "482")
inst.oHelper.AddParameter("MV_CDRORI", "", "Q50308")
inst.oHelper.AddParameter("MV_ESTADO", "", "SP")
inst.oHelper.AddParameter("MV_PRCPROD", "", ".T.")
inst.oHelper.AddParameter("MV_TMSCTE", "", ".T.")
inst.oHelper.AddParameter("MV_TPNRNFS", "", "1")
inst.oHelper.AddParameter("MV_DOCREE", "", ".T.")
inst.oHelper.AddParameter("MV_OCORREE", "", "E005")
inst.oHelper.AddParameter("MV_TMSUNFS", "", ".F.")
inst.oHelper.AddParameter("MV_TPDCREE", "", "2,5")
inst.oHelper.AddParameter("MV_TMSCFIS", "", ".T.")
inst.oHelper.AddParameter("MV_ESPECIE", "", "A01=NF;117=CTR")
inst.oHelper.SetParameters()
def test_TMSA500_CT018(self):
self.oHelper.SearchBrowse('M SP M SP 01 000000133117')
self.oHelper.SetButton('Visualizar')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
def test_TMSA500_CT019(self):
self.oHelper.AddParameter("MV_TMSCFIS", "", ".F.")
self.oHelper.SetParameters()
self.oHelper.SearchBrowse('M SP M SP 01 000000133117')
self.oHelper.SetButton('Visualizar')
self.oHelper.SetButton('Confirmar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGATSS/TSSMANAGERMONITORTESTCASE.py
```python
import unittest
from tir import Webapp
class TSSMANAGERMONITOR(unittest.TestCase):
@classmethod
def setUpClass(inst):
# Endereco do webapp e o nome do Browser
inst.oHelper = Webapp()
# Utilizando usuário de teste
inst.oHelper.SetTIRConfig("User", "teste")
inst.oHelper.SetTIRConfig("Password", "<PASSWORD>")
# Parametros de inicializacao
inst.oHelper.SetupTSS("TSSMONITOR", "SPED")
def test_TSSMANAGERMONITOR01_CT001(self):
self.oHelper.SetButton("Eventos")
self.oHelper.SetButton("NF-e")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Fiscal")
self.oHelper.SetButton("NFS-e")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("NF-e")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("CT-e")
self.oHelper.SetButton("Cancelar")
self.oHelper.SetButton("Documentos")
self.oHelper.SetButton("EDI")
self.oHelper.SetButton("Sair")
self.oHelper.SetButton("Sim")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Modules/SIGAWMS/WMSA225TESTCASE.py
```python
from tir import Webapp
import unittest
import time
class WMSA225(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGAWMS", "10/12/2020", "T1", "M SP 01", "42")
inst.oHelper.Program("WMSA225")
def test_WMSA225_CT001(self):
self.oHelper.SetButton('Incluir')
self.oHelper.SetBranch('M SP 01')
self.oHelper.SetValue('Armazém De ?','')
self.oHelper.SetValue('Armazém Até ?','ZZ')
self.oHelper.SetValue('Produto De ?','')
self.oHelper.SetValue('Produto Até ?','ZZZZZZZZZZZZZZZ')
self.oHelper.SetValue('Endereço De ?','')
self.oHelper.SetValue('Endereço Até ?','ZZZZZZZZZZZZZZZ')
self.oHelper.SetValue('Unitizador De ?','')
self.oHelper.SetValue('Unitizador Até ?','ZZZZZZ')
self.oHelper.SetValue('Tipo Transf. ?','Produto')
self.oHelper.SetButton('Ok')
self.oHelper.ClickBox('Produto','WMS00000G010')
self.oHelper.SetValue('Quantidade', '1,00', grid=True, grid_number=2)
self.oHelper.SetValue('Ender Des', 'A010001', grid=True, grid_number=2)
self.oHelper.LoadGrid()
self.oHelper.SetButton("Confirmar")
self.oHelper.SetButton('Fechar')
#self.oHelper.SearchBrowse('M SP 01 005WMS000000047 ')
#self.oHelper.SetButton('Outras Ações','Visualizar')
#self.oHelper.SetButton('Fechar')
#self.oHelper.SearchBrowse(key=2, index=True)
#self.oHelper.SearchBrowse('M SP 01 005WMS000025')
#self.oHelper.SetButton('Excluir')
#elf.oHelper.SetButton('Confirmar')
#self.oHelper.SetButton('Fechar')
self.oHelper.SetButton('X')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == "__main__":
unittest.main()
```
#### File: Protheus_WebApp/PROCESSO_MODELO05/MATA010TESTCASE.py
```python
from tir import Webapp
import unittest
from datetime import datetime
class MATA010(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.grupo = "T1"
inst.oHelper = Webapp() # INSTANCIAR A CLASSE
inst.oHelper.Setup('SIGAFAT', '09/06/2020', inst.grupo, 'D MG 01 ', '05')
inst.oHelper.SetLateralMenu("Atualizações > Cadastros > Produtos")
def test_MATA010_CT001(self, oHelper=None):
"""
teste 1
:return:
"""
if oHelper:
self.oHelper = oHelper
cod = 'ESTSE0000000000000000000000001'
self.oHelper.SearchBrowse(f"D MG 01 {cod}", "Filial+codigo")
self.oHelper.SetButton("X")
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Protheus_WebApp/PROCESSO_MODELO05/MATA030TESTCASE.py
```python
from tir import Webapp
import unittest
from datetime import datetime
class MATA030(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.grupo = "T1"
inst.oHelper = Webapp() # INSTANCIAR A CLASSE
inst.oHelper.Setup('SIGAFAT', '09/06/2020', inst.grupo, 'D MG 01 ', '05')
inst.oHelper.SetLateralMenu("Atualizações > Cadastros > Clientes")
def test_MATA030_CT001(self, oHelper=None):
"""
teste 1
:return:
"""
if oHelper:
self.oHelper = oHelper
today = datetime.today()
#
cod = (f"{str(today.hour)[-1:]}{str(today.minute)}{str(today.second)}{str(today.microsecond)[-1:]}")
self.oHelper.SetButton('Incluirr')
self.oHelper.SetBranch('D MG 01 ')
self.oHelper.SetValue('A1_COD', cod)
self.oHelper.SetValue('A1_LOJA','01')
self.oHelper.SetValue('A1_PESSOA','F - Fisica')
self.oHelper.SetValue('A1_NOME','PESSOA FISICA')
self.oHelper.SetValue('A1_NREDUZ','TIR')
self.oHelper.SetValue('A1_END','Rua Salete, 154')
self.oHelper.SetValue('A1_TIPO','F')
self.oHelper.SetValue('A1_EST','SP')
self.oHelper.SetValue('A1_COD_MUN','50308')
self.oHelper.SetValue('A1_BAIRRO','Santana')
self.oHelper.SetValue('A1_CEP','02403010')
self.oHelper.SetButton('Salvar')
self.oHelper.SetButton('Não')
self.oHelper.SetButton('Cancelar')
self.oHelper.SearchBrowse(f'D MG {cod}')
# self.oHelper.SearchBrowse(f'01 {cod}', 'Codigo + Loja')
self.oHelper.SetButton('Visualizar')
self.oHelper.ClickFolder('Cadastrais')
self.oHelper.CheckResult('A1_COD', cod)
self.oHelper.CheckResult('A1_LOJA','01')
self.oHelper.CheckResult('A1_PESSOA','F - Fisica')
self.oHelper.CheckResult('A1_NOME','PESSOA FISICA')
self.oHelper.CheckResult('A1_NREDUZ','TIR')
self.oHelper.CheckResult('A1_END','RUA SALETE, 154')
self.oHelper.CheckResult('A1_TIPO','F - Cons.Final')
self.oHelper.CheckResult('A1_EST','SP')
self.oHelper.CheckResult('A1_COD_MUN','50308')
self.oHelper.SetButton('Cancelar')
self.oHelper.AssertTrue()
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
```
#### File: Protheus_WebApp/PROCESSO_MODELO05/PROCESSOVENDATESTCASE.py
```python
from tir import Webapp
from MATA030TESTCASE import MATA030
from MATA010TESTCASE import MATA010
import unittest
class PROCESSOVENDA(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.grupo = "T1"
inst.oHelper = Webapp()
inst.oHelper.Setup('SIGAFAT','09/06/2020', inst.grupo, 'D MG 01 ', '05')
def test_MATA010_CT001(self):
# self.oHelper.SetLateralMenu("Atualizações > Cadastros > Produtos")
self.oHelper.Program("MATA010")
MATA010().test_MATA010_CT001(self.oHelper)
def test_MATA030_CT001(self):
# self.oHelper.SetLateralMenu("Atualizações > Cadastros > Clientes")
self.oHelper.Program("MATA030")
MATA030().test_MATA030_CT001(self.oHelper)
@classmethod
def tearDownClass(inst):
inst.oHelper.TearDown()
if __name__ == '__main__':
unittest.main()
``` |
{
"source": "98llm/tir",
"score": 2
} |
#### File: technologies/core/log.py
```python
import time
import os
import sys
from pathlib import Path
import numpy as nump
import pandas as panda
import uuid
import csv
import inspect
import re
import platform
import requests
import json
from datetime import datetime
from tir.technologies.core.config import ConfigLoader
from tir.technologies.core.logging_config import logger
class Log:
"""
This class is instantiated to create the log file and to append the results and failures to it.
Usage:
>>> # Instanted inside base.py:
>>> self.log = Log()
"""
def __init__(self, suite_datetime="", user="", station="", program="", program_date=("19800101"), version="", release="", database="", issue="", execution_id="", country="", folder="", test_type="TIR", config_path=""):
self.timestamp = time.strftime("%Y%m%d%H%M%S")
today = datetime.today()
self.config = ConfigLoader(config_path)
self.user = user
self.station = station
self.program = program
self.program_date = program_date
self.version = version
self.release = release
self.database = database
self.initial_time = datetime.today()
self.testcase_initial_time = datetime.today()
self.seconds = 0
self.testcase_seconds = 0
self.suite_datetime = suite_datetime
self.table_rows = []
self.test_case_log = []
self.csv_log = []
self.invalid_fields = []
self.table_rows.append(self.generate_header())
self.folder = folder
self.test_type = test_type
self.issue = self.config.issue
self.execution_id = self.config.execution_id
self.country = country
self.start_time = None
self.end_time = None
self.ct_method = ""
self.ct_number = ""
self.so_type = platform.system()
self.so_version = f"{self.so_type} {platform.release()}"
self.build_version = ""
self.lib_version = ""
self.webapp_version = ""
self.date = today.strftime('%Y%m%d')
self.hour = today.strftime('%H:%M:%S')
self.last_exec = today.strftime('%Y%m%d%H%M%S%f')[:-3]
self.hash_exec = ""
self.test_case = self.list_of_testcases()
self.finish_testcase = []
def generate_header(self):
"""
Generates the header line on the log file.
Usage:
>>> # Calling the method:
>>> self.log.generate_header()
"""
return ['Data','Usuário','Estação','Programa','Data Programa','Total CTs','Passou','Falhou', 'Segundos','Versão','Release', 'CTs Falhou', 'Banco de dados','Chamado','ID Execução','Pais', "Tipo de Teste"]
def new_line(self, result, message):
"""
Appends a new line with data on log file.
:param result: The result of the case.
:type result: bool
:param message: The message to be logged..
:type message: str
Usage:
>>> # Calling the method:
>>> self.log.new_line(True, "Success")
"""
line = []
total_cts = 1
passed = 1 if result else 0
failed = 0 if result else 1
printable_message = self.printable_message(message)
if not self.suite_datetime:
self.suite_datetime = time.strftime("%d/%m/%Y %X")
if self.get_testcase_stack() not in self.test_case_log:
line.extend([self.suite_datetime, self.user, self.station, self.program, self.program_date, total_cts, passed, failed, self.seconds, self.version, self.release, printable_message, self.database, self.issue, self.execution_id, self.country, self.test_type])
self.table_rows.append(line)
self.test_case_log.append(self.get_testcase_stack())
def save_file(self):
"""
Writes the log file to the file system.
Usage:
>>> # Calling the method:
>>> self.log.save_file()
"""
log_file = f"{self.user}_{uuid.uuid4().hex}_auto.csv"
if len(self.table_rows) > 0:
try:
if self.folder:
path = Path(self.folder, self.station+"_v6")
os.makedirs(path)
else:
path = Path("Log", self.station)
os.makedirs(path)
except OSError:
pass
if self.config.smart_test:
open("log_exec_file.txt", "w")
if ((len(self.table_rows[1:]) == len(self.test_case) and self.get_testcase_stack() not in self.csv_log) or (self.get_testcase_stack() == "setUpClass") and self.checks_empty_line()) :
with open( Path(path, log_file), mode="w", newline="", encoding="windows-1252") as csv_file:
csv_writer_header = csv.writer(csv_file, delimiter=';', quoting=csv.QUOTE_NONE)
csv_writer_header.writerow(self.table_rows[0])
csv_writer = csv.writer(csv_file, delimiter=';', quotechar='"', quoting=csv.QUOTE_NONNUMERIC)
for line in self.table_rows[1:]:
csv_writer.writerow(line)
logger().debug(f"Log file created successfully: {os.path.join(path, log_file)}")
self.csv_log.append(self.get_testcase_stack())
def set_seconds(self, initial_time):
"""
Sets the seconds variable through a calculation of current time minus the execution start time.
Usage:
>>> # Calling the method:
>>> self.log.set_seconds()
"""
delta = datetime.today() - initial_time
return round(delta.total_seconds(), 2)
def list_of_testcases(self):
"""
Returns a list of test cases from suite
"""
runner = next(iter(list(filter(lambda x: "runner.py" in x.filename, inspect.stack()))), None)
if runner:
try:
return list(filter(lambda x: x is not None, list(runner.frame.f_locals['test']._tests)))
except KeyError:
return []
else:
return []
def get_testcase_stack(self):
"""
Returns a string with the current testcase name
[Internal]
"""
return next(iter(list(map(lambda x: x.function, filter(lambda x: re.search('setUpClass', x.function) or re.search('test_', x.function), inspect.stack())))), None)
def checks_empty_line(self):
"""
Checks if the log file is not empty.
03 - 'Programa' 10 - 'Release' 14 - 'ID Execução' 15 - 'Pais'
[Internal]
"""
table_rows_has_line = False
if self.table_rows[1][3] == '':
self.table_rows[1][3] = 'NO PROGRAM'
if self.table_rows[1][10] == '':
self.table_rows[1][10] = '12.1.27'
if self.table_rows[1][15] == '':
self.table_rows[1][15] = 'BRA'
if self.table_rows[1][11] == '':
self.table_rows[1][11] = 'TIMEOUT'
if len(self.table_rows) > 1:
for x in [ 3, 10, 15 ]:
if (self.table_rows[1][x]):
table_rows_has_line = True
else:
table_rows_has_line = False
break
if self.config.smart_test and self.table_rows[1][14] and table_rows_has_line:
table_rows_has_line = True
elif self.config.smart_test:
table_rows_has_line = False
return table_rows_has_line
def generate_result(self, result, message):
"""
Generate a result of testcase and export to a json.
:param result: The result of the case.
:type result: bool
:param message: The message to be logged..
:type message: str
Usage:
>>> # Calling the method:
>>> self.log.generate_result(True, "Success")
"""
printable_message = self.printable_message(message)
if not self.suite_datetime:
self.suite_datetime = time.strftime("%d/%m/%Y %X")
self.generate_json(self.generate_dict(result, printable_message))
def get_file_name(self, file_name):
"""
Returns a Testsuite name
"""
testsuite_stack = next(iter(list(filter(lambda x: file_name in x.filename.lower(), inspect.stack()))), None)
if testsuite_stack:
if '/' in testsuite_stack.filename:
split_character = '/'
else:
split_character = '\\'
return testsuite_stack.filename.split(split_character)[-1].split(".")[0]
else:
return ""
def generate_dict(self, result, message):
"""
Returns a dictionary with the log information
"""
log_version = "20200814"
dict_key = {
"APPVERSION": self.build_version,
"CLIVERSION": self.webapp_version,
"COUNTRY": self.country,
"CTMETHOD": self.ct_method,
"CTNUMBER": self.ct_number,
"DBACCESS": "",
"DBTYPE": self.database,
"DBVERSION": "",
"EXECDATE": self.date,
"EXECTIME": self.hour,
"FAIL": 0 if result else 1,
"FAILMSG": message,
"IDENTI": self.issue,
"IDEXEC": self.config.execution_id,
"LASTEXEC": self.last_exec,
"LIBVERSION": self.lib_version,
"OBSERV": "",
"PASS": 1 if result else 0,
"PROGDATE": self.program_date,
"PROGRAM": self.program,
"PROGTIME": "00:00:00",
"RELEASE": self.release,
"SECONDSCT": self.testcase_seconds,
"SOTYPE": self.so_type,
"SOVERSION": self.so_version,
"STATION": self.station,
"STATUS": "", # ???
"TESTCASE": self.get_file_name('testcase'),
"TESTSUITE": self.get_file_name('testsuite'),
"TESTTYPE": "1",
"TOKEN": "TI<PASSWORD>", # ???
"TOOL": self.test_type,
"USRNAME": self.user,
"VERSION": self.version
}
return dict_key
def generate_json(self, dictionary):
"""
"""
server_address1 = self.config.logurl1
server_address2 = self.config.logurl2
success = False
data = dictionary
json_data = json.dumps(data)
endtime = time.time() + 120
while (time.time() < endtime and not success):
success = self.send_request(server_address1, json_data)
if not success:
success = self.send_request(server_address2, json_data)
time.sleep(10)
if not success:
self.save_json_file(json_data)
def send_request(self, server_address, json_data):
"""
Send a post request to server
"""
success = False
response = None
headers = {'content-type': 'application/json'}
try:
response = requests.post(server_address.strip(), data=json_data, headers=headers)
except:
pass
if response is not None:
if response.status_code == 200:
logger().debug("Log de execucao enviado com sucesso!")
success = True
elif response.status_code == 201 or response.status_code == 204:
logger().debug("Log de execucao enviado com sucesso!")
success = True
else:
self.save_response_log(response, server_address, json_data)
return False
else:
return False
return success
def save_response_log(self, response, server_address, json_data):
"""
"""
today = datetime.today()
try:
path = Path(self.folder, "new_log", self.station)
os.makedirs(path)
except OSError:
pass
try:
with open( Path(path, "response_log.csv"), mode="a", encoding="utf-8", newline='') as response_log:
csv_write = csv.writer(response_log, delimiter=';', quotechar='"', quoting=csv.QUOTE_MINIMAL)
csv_write.writerow([f"Time: {today.strftime('%Y%m%d%H%M%S%f')[:-3]}", f"URL: {server_address}", f"CT: {json.loads(json_data)['CTMETHOD']}",
{f"Status Code: {response.status_code}"}, f"Message: {response.text}"])
except:
pass
def save_json_file(self, json_data):
"""
Writes the log file to the file system.
Usage:
>>> # Calling the method:
>>> self.log.save_json_file()
"""
try:
if self.folder:
path = Path(self.folder, "new_log", self.station)
os.makedirs(path)
else:
path = Path("Log", self.station)
os.makedirs(path)
except OSError:
pass
log_file = f"{self.user}_{uuid.uuid4().hex}.json"
if self.config.smart_test:
open("log_exec_file.txt", "w")
with open( Path(path, log_file), mode="w", encoding="utf-8") as json_file:
json_file.write(json_data)
logger().debug(f"Log file created successfully: {Path(path, log_file)}")
def ident_test(self):
"""
:return:
"""
ct_method = self.get_testcase_stack()
ct_number = ''.join(list(filter(str.isdigit, f"{ct_method.split('_')[-1]}"))) if ct_method else ""
return (ct_method, ct_number)
def take_screenshot_log(self, driver, stack_item="", test_number=""):
"""
[Internal]
Takes a screenshot and saves on the log screenshot folder defined in config.
:param driver: The selenium driver.
:type: Selenium Driver
:param stack_item: test case stack
:type: str
:param test_number: test case number
:type: str
Usage:
>>> # Calling the method:
>>> self.log.take_screenshot_log()
"""
if not stack_item:
stack_item = self.get_testcase_stack()
if stack_item == "setUpClass":
stack_item = self.get_file_name("testsuite")
if not test_number:
test_number = f"{stack_item.split('_')[-1]} -" if stack_item else ""
if not self.release:
self.release = self.config.release
testsuite = self.get_file_name("testsuite")
today = datetime.today()
if self.search_stack("log_error"):
screenshot_file = self.screenshot_file_name("error", stack_item)
elif self.search_stack("CheckResult"):
screenshot_file = self.screenshot_file_name("CheckResult_result_divergence", stack_item)
else:
screenshot_file = self.screenshot_file_name(stack_item)
if self.config.debug_log:
logger().debug(f"take_screenshot_log in:{datetime.now()}\n")
try:
if self.config.log_http:
folder_path = Path(self.config.log_http, self.config.country, self.release, self.config.issue, self.config.execution_id, testsuite)
path = Path(folder_path, screenshot_file)
os.makedirs(Path(folder_path))
else:
path = Path("Log", self.station, screenshot_file)
os.makedirs(Path("Log", self.station))
except OSError:
pass
try:
driver.save_screenshot(str(path))
logger().debug(f"Screenshot file created successfully: {path}")
except Exception as e:
logger().exception(f"Warning Log Error save_screenshot exception {str(e)}")
def screenshot_file_name(self, description="", stack_item=""):
"""
:param name:
:return:
"""
today = datetime.today()
if description:
return f"{self.user}_{today.strftime('%Y%m%d%H%M%S%f')[:-3]}_{stack_item}_{description}.png"
else:
return f"{self.user}_{today.strftime('%Y%m%d%H%M%S%f')[:-3]}_{stack_item}.png"
def printable_message(self, string):
"""
:param string:
:return:
"""
return re.sub(';', ',', ''.join(filter(lambda x: x.isprintable(), string))[:600])
def search_stack(self, function):
"""
Returns True if passed function is present in the call stack.
:param function: Name of the function
:type function: str
:return: Boolean if passed function is present or not in the call stack.
:rtype: bool
Usage:
>>> # Calling the method:
>>> is_present = self.search_stack("MATA020")
"""
return len(list(filter(lambda x: x.function == function, inspect.stack()))) > 0
``` |
{
"source": "98miranil/DeepLearning_Solver",
"score": 3
} |
#### File: DeepLearning_Solver/lib/create_model.py
```python
from keras.models import Sequential
from keras.layers import Dense
def define_manual_model(attributes): #ATTRIBUTES IS THE LENGHT OF COLUMNS-1, WE DONT WANT THE OUTPUT
model = Sequential()
num_layers = input("How many layers do you want (INCLUDING ENTRANCE LAYER)? \n")
for i in range(int(num_layers)-1):
if i == 0:
nodes = int(input(f"How many nodes do you want on the layer {i+1} (FIRST HIDDEN LAYER)? \n"))
activation_func = input(f"Which activation function do you want on layer {i+1} (relu, sigmoid, tanh)? \n")
model.add(Dense(nodes, activation = activation_func, input_dim=attributes))
elif i == (int(num_layers)-2):
nodes = int(input(f"How many nodes do you want on the output layer? \n"))
activation_func = input(f"Which activation function do you want on the output (linear, sigmoid, softmax)? \n")
model.add(Dense(nodes, activation = activation_func))
else:
nodes = int(input(f"How many nodes do you want on the layer {i+1}? \n"))
activation_func = input(f"Which activation function do you want on layer {i+1} (relu, sigmoid, tanh)? \n")
model.add(Dense(nodes, activation = activation_func))
return model
def read_model(model):
print("\n\n")
model.summary()
print("\n\n")
def compile_manual_model(model):
print("Which loss function do you want to use: \n 1. Mean Squared Error \n 2. Mean Squared Logarithmic Error \n 3. Mean Absolute Error \n-------------------------------------\n 4. Binary Cross-Entropy \n 5. Hinge \n 6. Squared Hinge \n-------------------------------------\n 7. Categorical Cross-Entropy \n 8. Sparse Categorical Cross-Entropy \n 9. Kullback Leibler Divergence")
lf = int(input())
if lf == 1:
lf = "mean_squared_error"
elif lf == 2:
lf = "mean_squared_logarithmic_error"
elif lf == 3:
lf = "mean_absolute_error"
elif lf == 4:
lf = "binary_crossentropy"
elif lf == 5:
lf = "hinge"
elif lf == 6:
lf = "squared_hinge"
elif lf == 7:
lf = "categorical_crossentropy"
elif lf == 8:
lf = "sparse_categorical_crossentropy"
else:
lf = "kullback_leibler_divergence"
opt = input("Which optimizer do you want to use (SGD, adam)? \n")
model.compile(loss=lf,
optimizer=opt,
metrics=['accuracy'])
def fit_model(model, X_train, y_train):
epochs = int(input("How many epochs do you want? \n"))
batch = int(input("Which batch size do you want? \n"))
model.fit(X_train, y_train,epochs=epochs, batch_size=batch, verbose=0)
#Saves the model inside the folder models
def save_model(model):
name_model = input("Name of the model saved: ")
model.save("./models/"+name_model+".h5")
print("Model saved to disk")
#Loads the model from the models folder
def load_model():
from keras.models import load_model
name_model = input("Name of the model you want to load: ")
model = load_model('./models/'+name_model)
print("\n\n")
model.summary()
print("\n\n")
return model
``` |
{
"source": "98saurabh98/Collect-Research-Papers-using-Python",
"score": 3
} |
#### File: 98saurabh98/Collect-Research-Papers-using-Python/scrapeAnnualReview.py
```python
import urllib.request, urllib.parse, urllib.error
from bs4 import BeautifulSoup as bs
import re
import webbrowser
from selenium import webdriver
def similarUrl(url):
try:
x = url.find("/pdf/")
if "/pdf/" in url:
url = url[:x] + url[x+4:]
except:
pass
try:
y = url.find("/pdf/")
if "/abs/" in url:
url = url[:y] + url[y+4:]
except:
pass
try:
z = url.find("/full/")
if "/full/" in url:
url = url[:z] + url[z+5:]
except:
pass
return url
#x = similarUrl(input("Enter URL"))
#print (x)
browser = webdriver.Chrome()
html = urllib.request.urlopen("http://www.annualreviews.org/action/showPublications")
soup = bs(html, 'lxml')
lst = list()
tags = soup('a')
for tag in tags:
try:
if "journal" in tag.get('href', None):
lst.append(tag.get('href', None))
except:
pass
# lst.append(tag.get('href', None))
# print(tag.get('href', None))
print(lst)
file = open("AnnualReview.txt","a")
#----------------------#-------------------------#------------------------#---------
for elm in lst:
url = "http://www.annualreviews.org" + elm
browser.get(url)
innerHTML = browser.execute_script("return document.body.innerHTML")
soup = bs(innerHTML, 'lxml')
lst2 = list()
tags = soup('a')
for tag in tags:
x= tag.get('href', None)
try:
if "toc" in x and x not in lst2:
lst2.append(x)
except:
pass
print(lst2)
for elm2 in lst2:
url = "http://www.annualreviews.org" + elm2
browser.get(url)
innerHTML = browser.execute_script("return document.body.innerHTML")
soup = bs(innerHTML, 'lxml')
lst3 = list()
tags = soup('a')
for tag in tags:
x= tag.get('href', None)
try:
if "doi" in x and "#f" not in x:
x = similarUrl(x)
try:
if lst3[-1]==x or lst3[-2]==x:
continue
else:
lst3.append(x)
except:
lst3.append(x)
# lst3.append(x)
# for i in ["pdf", "#f", "full"]:
# if i not in x:
# lst2.append(x)
except:
pass
print(lst3)
for newElm in lst3:
file.write("<a href = http://www.annualreviews.org" + newElm + ">" + 'http://www.annualreviews.org' + newElm + "</a> <br>")
driver.close()
#file.write("http://www.annualreviews.org" + tag.get('href', None))
#file = open("AnnualReview.html","w")
#lstn = list()
#n=0
#for elm in bst:
# n= n+1
# if n>1:
# break
# html = urllib.request.urlopen("http://www.annualreviews.org" + elm)
# print(html)
# for line in html:
# file.write(line.decode())
# print(line.decode())
# print("http://www.annualreviews.org" + elm)
# soup = bs(html, 'lxml')
# lst2 = list()
# tags = soup('a')
# for tag in tags:
# try:
# if "doi" in tag.get('href', None):
# lst2.append(tag.get('href', None))
# except:
# pass
# print(lst2)
# lstn[n] = lst2
# n=n+1
#print(lst2)
#print(sorted(bst))
#print(tags)
#print(html)
#print(soup)
``` |
{
"source": "98shimpei/lecture2021",
"score": 2
} |
#### File: controllers/robotSupervisorController/robotSupervisorController.py
```python
from deepbots.supervisor.controllers.robot_supervisor import RobotSupervisor
from utilities import normalizeToRange, plotData
from PPO_agent import PPOAgent, Transition
from gym.spaces import Box, Discrete
import numpy as np
class CartpoleRobot(RobotSupervisor):
def __init__(self):
super().__init__()
self.observation_space = Box(low=np.array([-0.4, -np.inf, -1.3, -np.inf]),
high=np.array([0.4, np.inf, 1.3, np.inf]),
dtype=np.float64)
self.action_space = Discrete(2)
# self.robot = self.getSelf() # Grab the robot reference from the supervisor to access various robot methods
# self.positionSensor = self.getDevice("polePosSensor")
self.robot = self.supervisor.getSelf() # Fix
self.positionSensor = self.supervisor.getDevice("polePosSensor") # Fix
self.positionSensor.enable(self.timestep)
# self.poleEndpoint = self.getFromDef("POLE_ENDPOINT")
self.poleEndpoint = self.supervisor.getFromDef("POLE_ENDPOINT") # Fix
self.wheels = []
for wheelName in ['wheel1', 'wheel2', 'wheel3', 'wheel4']:
wheel = self.supervisor.getDevice(wheelName) # Fix
# wheel = self.getDevice(wheelName) # Get the wheel handle
wheel.setPosition(float('inf')) # Set starting position
wheel.setVelocity(0.0) # Zero out starting velocity
self.wheels.append(wheel)
self.stepsPerEpisode = 200 # Max number of steps per episode
self.episodeScore = 0 # Score accumulated during an episode
self.episodeScoreList = [] # A list to save all the episode scores, used to check if task is solved
def get_observations(self):
# Position on z axis
cartPosition = normalizeToRange(self.robot.getPosition()[2], -0.4, 0.4, -1.0, 1.0)
# Linear velocity on z axis
cartVelocity = normalizeToRange(self.robot.getVelocity()[2], -0.2, 0.2, -1.0, 1.0, clip=True)
# Pole angle off vertical
poleAngle = normalizeToRange(self.positionSensor.getValue(), -0.23, 0.23, -1.0, 1.0, clip=True)
# Angular velocity x of endpoint
endpointVelocity = normalizeToRange(self.poleEndpoint.getVelocity()[3], -1.5, 1.5, -1.0, 1.0, clip=True)
return [cartPosition, cartVelocity, poleAngle, endpointVelocity]
def get_reward(self, action=None):
return 1
def is_done(self):
if self.episodeScore > 195.0:
return True
poleAngle = round(self.positionSensor.getValue(), 2)
if abs(poleAngle) > 0.261799388: # 15 degrees off vertical
return True
cartPosition = round(self.robot.getPosition()[2], 2) # Position on z axis
if abs(cartPosition) > 0.39:
return True
return False
def solved(self):
if len(self.episodeScoreList) > 100: # Over 100 trials thus far
if np.mean(self.episodeScoreList[-100:]) > 195.0: # Last 100 episodes' scores average value
return True
return False
def get_default_observation(self):
return [0.0 for _ in range(self.observation_space.shape[0])]
def apply_action(self, action):
action = int(action[0])
if action == 0:
motorSpeed = 5.0
else:
motorSpeed = -5.0
for i in range(len(self.wheels)):
self.wheels[i].setPosition(float('inf'))
self.wheels[i].setVelocity(motorSpeed)
def render(self, mode='human'):
print("render() is not used")
def get_info(self):
return None
env = CartpoleRobot()
agent = PPOAgent(numberOfInputs=env.observation_space.shape[0], numberOfActorOutputs=env.action_space.n)
solved = False
episodeCount = 0
episodeLimit = 2000
# Run outer loop until the episodes limit is reached or the task is solved
while not solved and episodeCount < episodeLimit:
observation = env.reset() # Reset robot and get starting observation
env.episodeScore = 0
for step in range(env.stepsPerEpisode):
# In training mode the agent samples from the probability distribution, naturally implementing exploration
selectedAction, actionProb = agent.work(observation, type_="selectAction")
# Step the supervisor to get the current selectedAction's reward, the new observation and whether we reached
# the done condition
newObservation, reward, done, info = env.step([selectedAction])
# Save the current state transition in agent's memory
trans = Transition(observation, selectedAction, actionProb, reward, newObservation)
agent.storeTransition(trans)
if done:
# Save the episode's score
env.episodeScoreList.append(env.episodeScore)
agent.trainStep(batchSize=step)
solved = env.solved() # Check whether the task is solved
break
env.episodeScore += reward # Accumulate episode reward
observation = newObservation # observation for next step is current step's newObservation
print("Episode #", episodeCount, "score:", env.episodeScore)
episodeCount += 1 # Increment episode counter
#add for save
from datetime import datetime, timezone, timedelta
time_date = datetime.now(timezone(timedelta(hours=+9), 'JST')).strftime("%Y%m%d%H%M")
file_path = "/home/kanazawa/Desktop/codes/in_jsk/agent-system/agent-system-2021-memo/deepbots/tutorials/controllers/robotSupervisorController/weights/" + time_date
agent.save(file_path)
print("agent saved at " + file_path )
if not solved:
print("Task is not solved, deploying agent for testing...")
elif solved:
print("Task is solved, deploying agent for testing...")
observation = env.reset()
while True:
selectedAction, actionProb = agent.work(observation, type_="selectActionMax")
observation, _, _, _ = env.step([selectedAction])
``` |
{
"source": "98ZhaoJeffrey/Glorious-Future",
"score": 3
} |
#### File: mysite/userApp/forms.py
```python
from django import forms
from .models import User
from django.contrib.auth.forms import UserCreationForm
class UserRegisterForm(UserCreationForm):
email = forms.EmailField()
first_name = forms.CharField(label='First name')
last_name = forms.CharField(label='Last name', required=False)
location = forms.CharField(label='Location of the organization', required=False)
is_staff = forms.BooleanField(label='I am an Organization', required=False)
def save(self, commit=True):
user_instance = super(UserRegisterForm, self).save(commit=False)
if commit:
user_instance.save()
class Meta:
model = User
fields = ['username', 'email', 'first_name', 'last_name', '<PASSWORD>', '<PASSWORD>', "location", "is_staff"]
``` |
{
"source": "99002479/PY",
"score": 3
} |
#### File: 99002479/PY/server.py
```python
import socket
import threading
import pickle
import os
import sys
groups = {}
fileTransferCondition = threading.Condition()
class Group:
def __init__(self,admin,client):
self.admin = admin
self.clients = {}
self.offlineMessages = {}
self.allMembers = set()
self.onlineMembers = set()
self.joinRequests = set()
self.waitClients = {}
self.clients[admin] = client
self.allMembers.add(admin)
self.onlineMembers.add(admin)
def disconnect(self,username):
self.onlineMembers.remove(username)
del self.clients[username]
def connect(self,username,client):
self.onlineMembers.add(username)
self.clients[username] = client
def sendMessage(self,message,username):
for member in self.onlineMembers:
if member != username:
self.clients[member].send(bytes(username + ": " + message,"utf-8"))
def pyconChat(client, username, groupname):
while True:
msg = client.recv(1024).decode("utf-8")
if msg == "/viewRequests":
client.send(b"/viewRequests")
client.recv(1024).decode("utf-8")
if username == groups[groupname].admin:
client.send(b"/sendingData")
client.recv(1024)
client.send(pickle.dumps(groups[groupname].joinRequests))
else:
client.send(b"You're not an admin.")
elif msg == "/approveRequest":
client.send(b"/approveRequest")
client.recv(1024).decode("utf-8")
if username == groups[groupname].admin:
client.send(b"/proceed")
usernameToApprove = client.recv(1024).decode("utf-8")
if usernameToApprove in groups[groupname].joinRequests:
groups[groupname].joinRequests.remove(usernameToApprove)
groups[groupname].allMembers.add(usernameToApprove)
if usernameToApprove in groups[groupname].waitClients:
groups[groupname].waitClients[usernameToApprove].send(b"/accepted")
groups[groupname].connect(usernameToApprove,groups[groupname].waitClients[usernameToApprove])
del groups[groupname].waitClients[usernameToApprove]
print("Member Approved:",usernameToApprove,"| Group:",groupname)
client.send(b"User has been added to the group.")
else:
client.send(b"The user has not requested to join.")
else:
client.send(b"You're not an admin.")
elif msg == "/disconnect":
client.send(b"/disconnect")
client.recv(1024).decode("utf-8")
groups[groupname].disconnect(username)
print("User Disconnected:",username,"| Group:",groupname)
break
elif msg == "/messageSend":
client.send(b"/messageSend")
message = client.recv(1024).decode("utf-8")
groups[groupname].sendMessage(message,username)
elif msg == "/waitDisconnect":
client.send(b"/waitDisconnect")
del groups[groupname].waitClients[username]
print("Waiting Client:",username,"Disconnected")
break
elif msg == "/allMembers":
client.send(b"/allMembers")
client.recv(1024).decode("utf-8")
client.send(pickle.dumps(groups[groupname].allMembers))
elif msg == "/onlineMembers":
client.send(b"/onlineMembers")
client.recv(1024).decode("utf-8")
client.send(pickle.dumps(groups[groupname].onlineMembers))
elif msg == "/changeAdmin":
client.send(b"/changeAdmin")
client.recv(1024).decode("utf-8")
if username == groups[groupname].admin:
client.send(b"/proceed")
newAdminUsername = client.recv(1024).decode("utf-8")
if newAdminUsername in groups[groupname].allMembers:
groups[groupname].admin = newAdminUsername
print("New Admin:",newAdminUsername,"| Group:",groupname)
client.send(b"Your adminship is now transferred to the specified user.")
else:
client.send(b"The user is not a member of this group.")
else:
client.send(b"You're not an admin.")
elif msg == "/whoAdmin":
client.send(b"/whoAdmin")
groupname = client.recv(1024).decode("utf-8")
client.send(bytes("Admin: "+groups[groupname].admin,"utf-8"))
elif msg == "/kickMember":
client.send(b"/kickMember")
client.recv(1024).decode("utf-8")
if username == groups[groupname].admin:
client.send(b"/proceed")
usernameToKick = client.recv(1024).decode("utf-8")
if usernameToKick in groups[groupname].allMembers:
groups[groupname].allMembers.remove(usernameToKick)
if usernameToKick in groups[groupname].onlineMembers:
groups[groupname].clients[usernameToKick].send(b"/kicked")
groups[groupname].onlineMembers.remove(usernameToKick)
del groups[groupname].clients[usernameToKick]
print("User Removed:",usernameToKick,"| Group:",groupname)
client.send(b"The specified user is removed from the group.")
else:
client.send(b"The user is not a member of this group.")
else:
client.send(b"You're not an admin.")
else:
print("UNIDENTIFIED COMMAND:",msg)
def handshake(client):
username = client.recv(1024).decode("utf-8")
client.send(b"/sendGroupname")
groupname = client.recv(1024).decode("utf-8")
if groupname in groups:
if username in groups[groupname].allMembers:
groups[groupname].connect(username,client)
client.send(b"/ready")
print("User Connected:",username,"| Group:",groupname)
else:
groups[groupname].joinRequests.add(username)
groups[groupname].waitClients[username] = client
groups[groupname].sendMessage(username+" has requested to join the group.","PyconChat")
client.send(b"/wait")
print("Join Request:",username,"| Group:",groupname)
threading.Thread(target=pyconChat, args=(client, username, groupname,)).start()
else:
groups[groupname] = Group(username,client)
threading.Thread(target=pyconChat, args=(client, username, groupname,)).start()
client.send(b"/adminReady")
print("New Group:",groupname,"| Admin:",username)
def main():
if len(sys.argv) < 3:
print("USAGE: python server.py <IP> <Port>")
print("EXAMPLE: python server.py localhost 8000")
return
listenSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
listenSocket.bind((sys.argv[1], int(sys.argv[2])))
listenSocket.listen(10)
print("PyconChat Server running")
while True:
client,_ = listenSocket.accept()
threading.Thread(target=handshake, args=(client,)).start()
if __name__ == "__main__":
main()
``` |
{
"source": "990xan/Collatz",
"score": 4
} |
#### File: 990xan/Collatz/main.py
```python
import os
def TestForExit(text):
imp = (input(text))
if imp.upper() == "EXIT":
raise SystemExit
else:
imp = int(imp)
return imp
mode = 0
while mode == 0:
os.system('cls')
dat = input("Select a mode [Single, Up To, Infinite]: ")
if dat.upper() == "SINGLE":
mode = 1
elif dat.upper() == "UP TO":
mode = 2
elif dat.upper() == "INFINITE":
mode = 3
else:
print("Invalid mode! Please try again.")
continue
_workingnum = 1 # stores current number
_counter = 1 # stores number of steps
_megacounter = 1 # stores number of numbers iterated through for upto and infinite modes
cntrecord = 0 # highest number of steps reached
numrecord = 1 # number with the cntrec
countval = 0 # number needed to be counted to for up to
while mode == 1:
_workingnum = TestForExit("Please enter a positive integer [or 'exit' to exit]: ")
print(str(_workingnum) + " | 0")
while _workingnum != 1:
if (_workingnum % 2) == 0:
_workingnum = _workingnum / 2
print(str(_workingnum) + " | DIV 2 | " + str(_counter))
else:
_workingnum = _workingnum * 3
_workingnum += 1
print(str(_workingnum) + " | MUL 3 ADD 1 | " + str(_counter))
_counter += 1
_counter = 0
while mode == 2:
countval = TestForExit("Please enter a positive integer to go up to [or 'exit' to exit]: ")
while _megacounter <= countval:
print("------------------")
print(_megacounter)
print("Rec: " + str(cntrecord) + " Num Rec: " + str(numrecord))
while _workingnum != 1:
if (_workingnum % 2) == 0:
_workingnum = _workingnum / 2
print(str(_workingnum) + " | DIV 2 | " + str(_counter))
else:
_workingnum = _workingnum * 3
_workingnum += 1
print(str(_workingnum) + " | MUL 3 ADD 1 | " + str(_counter))
_counter += 1
# records
if _counter >= cntrecord:
cntrecord = _counter
numrecord = _megacounter
_counter = 0
_megacounter += 1
_workingnum = _megacounter
# infinite mode, no if needed since it's the last mode
while True:
print("------------------")
print(_megacounter)
print("Rec: " + str(cntrecord) + " Num Rec: " + str(numrecord))
while _workingnum != 1:
if (_workingnum % 2) == 0:
_workingnum = _workingnum / 2
print(str(_workingnum) + " | DIV 2 | " + str(_counter))
else:
_workingnum = _workingnum * 3
_workingnum += 1
print(str(_workingnum) + " | MUL 3 ADD 1 | " + str(_counter))
_counter += 1
if _counter >= cntrecord:
cntrecord = _counter
numrecord = _megacounter
_counter = 0
_megacounter += 1
_workingnum = _megacounter
``` |
{
"source": "991693552/donkeycar-pi",
"score": 3
} |
#### File: donkeycar/parts/clock.py
```python
import datetime
class Timestamp():
def run(self,):
return str(datetime.datetime.utcnow())
``` |
{
"source": "9921/Software",
"score": 2
} |
#### File: ros_cap/src/cosa.py
```python
import copy
import cv2
import numpy as np
from keras.models import load_model
from phue import Bridge
import pygame
import time
import rospy
# General Settings
prediction = ''
action = ''
score = 0
img_counter = 500
# pygame.event.wait()
# Turn on/off the ability to save images
save_images, selected_gesture = False, 'peace'
gesture_names = {0: 'Fist',
1: 'L',
2: 'Okay',
3: 'Palm',
4: 'Peace'}
model = load_model('/home/camilo/Descargas/VGG_cross_validated.h5')
def predict_rgb_image_vgg(image):
image = np.array(image, dtype='float32')
image /= 255
pred_array = model.predict(image)
print(f'pred_array: {pred_array}')
result = gesture_names[np.argmax(pred_array)]
print(f'Result: {result}')
print(max(pred_array[0]))
score = float("%0.2f" % (max(pred_array[0]) * 100))
print(result)
return result, score
# parameters
cap_region_x_begin = 0.5 # start point/total width
cap_region_y_end = 0.8 # start point/total width
threshold = 60 # binary threshold
blurValue = 41 # GaussianBlur parameter
bgSubThreshold = 50
learningRate = 0
# variableslt
isBgCaptured = 0 # bool, whether the background captured
triggerSwitch = False # if true, keyboard simulator works
def remove_background(frame):
fgmask = bgModel.apply(frame, learningRate=learningRate)
kernel = np.ones((3, 3), np.uint8)
fgmask = cv2.erode(fgmask, kernel, iterations=1)
res = cv2.bitwise_and(frame, frame, mask=fgmask)
return res
# Camera
camera = cv2.VideoCapture(0)
camera.set(10, 200)
def prediccion():
while camera.isOpened():
ret, frame = camera.read()
frame = cv2.bilateralFilter(frame, 5, 50, 100) # smoothing filter
frame = cv2.flip(frame, 1) # flip the frame horizontally
cv2.rectangle(frame, (int(cap_region_x_begin * frame.shape[1]), 0),
(frame.shape[1], int(cap_region_y_end * frame.shape[0])), (255, 0, 0), 2)
cv2.imshow('original', frame)
# Run once background is captured
if isBgCaptured == 1:
img = remove_background(frame)
img = img[0:int(cap_region_y_end * frame.shape[0]),
int(cap_region_x_begin * frame.shape[1]):frame.shape[1]] # clip the ROI
# cv2.imshow('mask', img)
# convert the image into binary image
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray, (blurValue, blurValue), 0)
# cv2.imshow('blur', blur)
ret, thresh = cv2.threshold(blur, threshold, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# Add prediction and action text to thresholded image
# cv2.putText(thresh, f"Prediction: {prediction} ({score}%)", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255))
# cv2.putText(thresh, f"Action: {action}", (50, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255)) # Draw the text
# Draw the text
cv2.putText(thresh, f"Prediction: {prediction} ({score}%)", (50, 30), cv2.FONT_HERSHEY_SIMPLEX, 1,
(255, 255, 255))
cv2.putText(thresh, f"Action: {action}", (50, 80), cv2.FONT_HERSHEY_SIMPLEX, 1,
(255, 255, 255)) # Draw the text
cv2.imshow('ori', thresh)
# get the contours
thresh1 = copy.deepcopy(thresh)
_, contours, hierarchy = cv2.findContours(thresh1, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
length = len(contours)
maxArea = -1
if length > 0:
for i in range(length): # find the biggest contour (according to area)
temp = contours[i]
area = cv2.contourArea(temp)
if area > maxArea:
maxArea = area
ci = i
res = contours[ci]
hull = cv2.convexHull(res)
drawing = np.zeros(img.shape, np.uint8)
cv2.drawContours(drawing, [res], 0, (0, 255, 0), 2)
cv2.drawContours(drawing, [hull], 0, (0, 0, 255), 3)
cv2.imshow('output', drawing)
# Keyboard OP
k = cv2.waitKey(10)
if k == 27: # press ESC to exit all windows at any time
break
elif k == ord('b'): # press 'b' to capture the background
bgModel = cv2.createBackgroundSubtractorMOG2(0, bgSubThreshold)
b.set_light(6, on_command)
time.sleep(2)
isBgCaptured = 1
print('Background captured')
elif k == ord('r'): # press 'r' to reset the background
time.sleep(1)
bgModel = None
triggerSwitch = False
isBgCaptured = 0
print('Reset background')
# pasará algo si lo quitamos?
elif k == 32:
# If space bar pressed
cv2.imshow('original', frame)
# copies 1 channel BW image to all 3 RGB channels
target = np.stack((thresh,) * 3, axis=-1)
target = cv2.resize(target, (224, 224))
target = target.reshape(1, 224, 224, 3)
prediction, score = predict_rgb_image_vgg(target)
if prediction == 'Palm': # no lo detecta bien
pass
elif prediction == 'Fist':
action = 'Adelante'
elif prediction == 'L':
action = 'Izquierda'
elif prediction == 'Okay':
action = 'Derecha'
elif prediction == 'Peace':
action = 'Atrás'
else:
pass
if save_images:
img_name = f"./frames/drawings/drawing_{selected_gesture}_{img_counter}.jpg".format(
img_counter)
cv2.imwrite(img_name, drawing)
print("{} written".format(img_name))
img_name2 = f"./frames/silhouettes/{selected_gesture}_{img_counter}.jpg".format(
img_counter)
cv2.imwrite(img_name2, thresh)
print("{} written".format(img_name2))
img_name3 = f"./frames/masks/mask_{selected_gesture}_{img_counter}.jpg".format(
img_counter)
cv2.imwrite(img_name3, img)
print("{} written".format(img_name3))
img_counter += 1
elif k == ord('t'):
print('Tracker turned on.')
cap = cv2.VideoCapture(0)
ret, frame = cap.read()
# Select Region of Interest (ROI)
r = cv2.selectROI(frame)
# Crop image
imCrop = frame[int(r[1]):int(r[1] + r[3]), int(r[0]):int(r[0] + r[2])]
# setup initial location of window
r, h, c, w = 250, 400, 400, 400
track_window = (c, r, w, h)
# set up the ROI for tracking
roi = imCrop
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv_roi, np.array((0., 60., 32.)), np.array((180., 255., 255.)))
roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180])
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)
# Setup the termination criteria, either 10 iteration or move by at least 1 pt
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)
while (1):
ret, frame = cap.read()
if ret == True:
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1)
# apply meanshift to get the new location
ret, track_window = cv2.CamShift(dst, track_window, term_crit)
# Draw it on image
pts = cv2.boxPoints(ret)
pts = np.int0(pts)
img2 = cv2.polylines(frame, [pts], True, (0, 255, 0), 2)
cv2.imshow('img2', img2)
k = cv2.waitKey(60) & 0xff
if k == 27: # if ESC key
break
else:
cv2.imwrite(chr(k) + ".jpg", img2)
else:
break
cv2.destroyAllWindows()
return action
cap.release()
``` |
{
"source": "9929105/KEEP",
"score": 2
} |
#### File: keep_backend/api/data.py
```python
import pymongo
from backend.db import db
from backend.db import DataSerializer
from bson import ObjectId
from bson.code import Code
from django.conf import settings
from django.conf.urls import url
from django.http import HttpResponse
from tastypie import fields
from tastypie.authentication import MultiAuthentication, SessionAuthentication
from tastypie.http import HttpUnauthorized, HttpBadRequest
from repos.models import Repository
from .authentication import ApiTokenAuthentication
from .authorization import DataAuthorization
from .resources import MongoDBResource, Document
from .serializers import CSVSerializer
FILTER_PREFIX = 'filter'
DATA_FILTER_PREFIX = 'data'
PREFIXES = [ FILTER_PREFIX, DATA_FILTER_PREFIX ]
class DataResource( MongoDBResource ):
id = fields.CharField( attribute='_id' )
repo_id = fields.CharField( attribute='repo' )
survey_label = fields.CharField( attribute='survey_label', null=True )
timestamp = fields.DateTimeField( attribute='timestamp' )
data = fields.DictField( attribute='data', null=True )
class Meta:
collection = 'data'
resource_name = 'data'
object_class = Document
serializer = CSVSerializer()
list_allowed_methos = []
detail_allowed_methods = [ 'get','delete' ]
authentication = MultiAuthentication( ApiTokenAuthentication(),
SessionAuthentication() )
authorization = DataAuthorization()
def prepend_urls(self):
base_url = '^(?P<resource_name>%s)/(?P<mongo_id>\w+)' % ( self._meta.resource_name )
return [
url( regex=r"%s/stats/$" % ( base_url ),
view=self.wrap_view( 'get_statistics' ),
name='api_dispatch_statistics' ),
url( regex=r"%s/sample/$" % ( base_url ),
view=self.wrap_view( 'sample_data' ),
name='api_dispatch_data_sample' ) ]
def _build_filters( self, request ):
"""
Build filters based on request parameters. Filters are formatted as
follows:
PREFIX __ KEY = VALUE or
PREFIX __ KEY __ RELATION = VALUE
For the data resource, the prefix can either be 'filter' or 'data'.
A basic 'filter' prefix only looks at the top level meta-data for
a piece of survey data. The 'data' prefix looks into the actual
survey data itself.
Params
------
request : HttpRequest
"""
filters = {}
for param in request.GET:
# Split the parameter into the possible PREFIX/KEY/RELATION tokens.
values = param.split( '__' )
# Not a filter param? Skip to the next parameter
if values[0] not in PREFIXES:
continue
key = values[1]
value = request.GET[ param ]
# Ensure we go a level deeper for the 'data' prefix
if DATA_FILTER_PREFIX == values[0]:
key = 'data.%s' % ( key )
# Handle relations. No relation token is assumed to mean we want
# an exact match.
if len( values ) == 2:
filters[ key ] = value
else:
if values[2] == 'gt':
filters[ key ] = { '$gt': value }
elif value[2] == 'lt':
filters[ key ] = { '$lt': value }
return filters
def _build_sort( self, request ):
if 'sort' not in request:
return None
sort = {}
sort[ 'param' ] = 'data.%s' % ( request.get('sort') )
sort[ 'type' ] = pymongo.DESCENDING
if 'sort_type' in request and request.get('sort_type') in [ 'asc', 'ascending' ]:
sort[ 'type' ] = pymongo.ASCENDING
return sort
def delete_detail( self, request, **kwargs ):
repo_id = kwargs[ 'pk' ]
try:
basic_bundle = self.build_bundle( request=request )
repo = Repository.objects.get( mongo_id=repo_id )
if not self.authorized_delete_detail( repo, basic_bundle ):
return HttpUnauthorized()
data_id = request.GET['data_id']
if not data_id:
return HttpResponse( status=404 )
db.data.remove( { '_id': ObjectId( data_id ) } )
return HttpResponse( status=200 )
except Exception as e:
return HttpBadRequest( str( e ) )
def get_detail( self, request, **kwargs ):
# Grab the survey that we're querying survey data for
repo_id = kwargs[ 'pk' ]
try:
basic_bundle = self.build_bundle( request=request )
repo = Repository.objects.get( mongo_id=repo_id )
if not self.authorized_read_detail( repo, basic_bundle ):
return HttpUnauthorized()
query_parameters = self._build_filters( request )
query_parameters['repo'] = ObjectId( repo_id )
if 'bbox' in request.GET and 'geofield' in request.GET:
# Convert the bounding box into the $box format needed to do
# a geospatial search in MongoDB
# http://docs.mongodb.org/manual/reference/operator/box/
try:
bbox = map( float, request.GET[ 'bbox' ].split( ',' ) )
except ValueError:
return HttpBadRequest( 'Invalid bounding box' )
bbox = [ [ bbox[0], bbox[1] ], [ bbox[2], bbox[3] ] ]
geofield = request.GET[ 'geofield' ]
query_parameters[ 'data.%s' % ( geofield ) ] = {'$geoWithin': {'$box': bbox}}
# Query data from MongoDB
cursor = db.data.find( query_parameters )
sort_params = self._build_sort( request.GET )
if sort_params is not None:
cursor = cursor.sort( sort_params.get( 'param' ), sort_params.get( 'type' ) )
# Ensure correct pagination
offset = max( int( request.GET.get( 'offset', 0 ) ), 0 )
#
# TODO: Smarter way of printing out entire dataset for CSVs
# When people download CSVs, make sure we include the entire dataset.
limit = 50
if request.GET.get( 'format', None ) == 'csv':
limit = cursor.count()
# Determine the number of pages available.
pages = 0
if limit > 0:
pages = cursor.count() / limit
meta = {
'form_name': repo.name,
'fields': repo.flatten_fields(),
'limit': limit,
'offset': offset,
'count': cursor.count(),
'pages': pages }
data_serializer = DataSerializer()
if repo.is_tracker and repo.study:
linked = Repository.objects.filter( study=repo.study ).exclude( id=repo.id )
data = {
'meta': meta,
'data': data_serializer.dehydrate( cursor.skip( offset * limit ).limit( limit ),
repo, linked ) }
else:
data = {
'meta': meta,
'data': data_serializer.dehydrate( cursor.skip( offset * limit ).limit( limit ),
repo ) }
return self.create_response( request, data )
except ValueError as e:
return HttpBadRequest( str( e ) )
def sample_data( self, request, **kwargs ):
'''
Run data sampling using the MongoDB aggregate command.
'''
xaxis = request.GET.get( 'x', None )
yaxis = request.GET.get( 'y', None )
if xaxis is None or yaxis is None:
return HttpBadRequest( 'x and y params must be set' )
xaxis = xaxis.split( '.' )
yaxis = yaxis.split( '.' )
if xaxis[0] not in [ 'data', 'timestamp', 'count' ]:
return HttpBadRequest( 'invalid x param' )
if yaxis[0] not in [ 'data', 'timestamp', 'count' ]:
return HttpBadRequest( 'invalid y param' )
x_label = '%s.%s' % ( xaxis[0], xaxis[1] )
y_label = '%s.%s' % ( yaxis[0], yaxis[1] )
# Create the aggregate pipeline needed to do our query
match = { '$match': {
'repo': ObjectId( kwargs.get( 'mongo_id' ) ),
x_label: { '$exists': True },
y_label: { '$exists': True } } }
project = { '$project': {
'_id': 0,
'x': '$%s.%s' % ( xaxis[0], xaxis[1] ),
'y': '$%s.%s' % ( yaxis[0], yaxis[1] ) } }
sort = { '$sort': { 'x': 1 } }
aggregate = db.data.aggregate( pipeline=[match, project, sort] )
results = []
for row in aggregate.get( 'result' ):
results.append( row )
return self.create_response( request, results )
def get_statistics( self, request, **kwargs ):
'''
Get "statistics" aim is to (ultimately) run MapReduce functions on
the set of data in a specific repository.
'''
day_map = Code( '''
function() {
day = Date.UTC( this.timestamp.getFullYear(), this.timestamp.getMonth(), this.timestamp.getDate() );
emit( { day: day }, { count: 1 } )
}''')
day_reduce = Code( '''
function( key, values ) {
var count = 0;
values.forEach( function( v ) {
count += v[ 'count' ];
});
return {count: count};
}''')
# Grab the survey that we're querying survey data for
repo_filter = { 'repo': ObjectId( kwargs.get( 'mongo_id' ) ) }
cursor = db.data.find( repo_filter )
first = db.data.find_one( repo_filter, sort=[( '_id', pymongo.ASCENDING )] )
last = db.data.find_one( repo_filter, sort=[( '_id', pymongo.DESCENDING )] )
count_by_day = []
result = db.data.map_reduce( day_map, day_reduce, "myresults", query=repo_filter )
for doc in result.find():
count_by_day.append( {
'day': doc[ '_id' ][ 'day' ],
'value': doc[ 'value' ][ 'count' ] })
stats = {
'total_count': cursor.count(),
'count_by_day': count_by_day,
'first_submission': first,
'last_submission': last,
}
return self.create_response( request, stats )
```
#### File: keep_backend/backend/db.py
```python
from bson import ObjectId
from django.conf import settings
from django.contrib.auth.models import User
from pymongo import MongoClient
from organizations.models import Organization
connection = MongoClient( settings.MONGODB_HOST, settings.MONGODB_PORT )
db = connection[ settings.MONGODB_DBNAME ]
class DataSerializer( object ):
def dehydrate( self, data, repository, linked=None ):
hydrated = []
fields = repository.fields()
for row in data:
copy = dict( row )
# Hydrate the base data keys.
# 1. Remove the "repo" key if it exists.
# 2. Rename the "_id" key into the more common "id" key.
# 3. Convert the python timestamp into a JSON friendly one.
repo = copy.pop( 'repo' )
copy[ 'id' ] = str(copy.pop( '_id' ))
copy[ 'timestamp' ] = copy[ 'timestamp' ].strftime( '%Y-%m-%dT%X' )
# Now serialize the data according to the field data.
copy[ 'data' ] = self.serialize_data( data=copy[ 'data' ],
fields=fields,
repo_id=repo,
data_id=copy[ 'id' ] )
if repository.is_tracker and repository.study and linked:
link_dict = {}
tracker_id = 'data.' + repository.study.tracker
data_id = dict(row)['data'].get(repository.study.tracker)
# Create list of results
repo_datas = db.data.find( { tracker_id: data_id } )
repo_dict = dict( (repo['label'], repo) for repo in repo_datas )
# Check if data is complete or not
for linked_repo in linked:
if linked_repo in repo_dict:
if repo_dict[linked_repo]['is_finished']:
link_dict[ linked_repo.name ] = 'finished'
else:
link_dict[ linked_repo.name ] = 'incomplete'
else:
link_dict[ linked_repo.name ] = 'empty'
copy['linked'] = link_dict
hydrated.append( copy )
return hydrated
def serialize_data( self, data, fields, repo_id, data_id ):
copy = {}
for field in fields:
key = field.get( 'name' )
val = data.get( key )
# Convert strings into a unicode representation.
if field.get( 'type' ) in [ 'text', 'note' ]:
val = unicode( val ).encode( 'utf-8' )
copy[ key ] = val
# Give a full URL for media
elif field.get( 'type' ) in [ 'photo' ]:
if settings.DEBUG or settings.TESTING:
host = 'localhost:8000/media'
else:
host = settings.AWS_S3_MEDIA_DOMAIN
val = 'http://%s/%s/%s/%s' % ( host, repo_id, data_id, val )
copy[ key ] = val
# Correctly recurse through groups
elif field.get( 'type' ) == 'group':
val = self.serialize_data( data=data,
fields=field.get( 'children' ),
repo_id=repo_id,
data_id=data_id )
for k in val:
copy[ k ] = val[ k ]
else:
copy[ key ] = val
return copy
def dehydrate( survey ):
# Reformat python DateTime into JS DateTime
if 'timestamp' in survey:
survey[ 'timestamp' ] = survey[ 'timestamp' ].strftime( '%Y-%m-%dT%X' )
if '_id' in survey:
survey[ 'id' ] = survey.pop( '_id' )
for key in survey.keys():
if isinstance( survey[key], dict ):
survey[ key ] = dehydrate( survey[key] )
elif isinstance( survey[key], list ):
survey[ key ] = dehydrate_list( survey[key] )
else:
survey[ key ] = unicode( survey[ key ] ).encode( 'utf-8' )
return survey
def dehydrate_list( target ):
hydrated = []
for el in target:
if isinstance( el, dict ):
hydrated.append( dehydrate( el ) )
elif isinstance( el, list ):
hydrated.append( dehydrate_list( el ) )
else:
hydrated.append( unicode( el ).encode( 'utf-8' ) )
return hydrated
def dehydrate_survey( cursor ):
'''
Decrypt survey data and turn any timestamps into javascript-readable
values.
'''
if isinstance( cursor, dict ):
return dehydrate( cursor )
return [ dehydrate( row ) for row in cursor ]
def user_or_organization( name ):
results = User.objects.filter( username=name )
if len( results ) > 0:
return results[0]
results = Organization.objects.filter( name=name )
if len( results ) > 0:
return results[0]
return None
```
#### File: keep_backend/backend/forms.py
```python
import re
from django import forms
from django.contrib.auth.models import User
from django.utils.translation import ugettext as _
from registration.forms import RegistrationFormUniqueEmail
from registration.models import RegistrationProfile
from twofactor.models import UserAuthToken
class ReportForm( forms.Form ):
name = forms.CharField()
report_json = forms.CharField( widget=forms.HiddenInput )
class ResendActivationForm( forms.Form ):
email = forms.EmailField(widget=forms.TextInput())
class RegistrationFormUserProfile( RegistrationFormUniqueEmail ):
class Meta:
pass
_reserved_usernames = [
'accounts', 'about', 'admin', 'clients', 'crowdform', 'crowdforms',
'data', 'forms', 'maps', 'odk', 'people', 'submit', 'submission',
'support', 'syntax', 'xls2xform', 'users', 'worldbank', 'unicef',
'who', 'wb', 'wfp', 'save', 'ei', 'modilabs', 'mvp', 'unido',
'unesco', 'savethechildren', 'worldvision', 'afsis']
username = forms.CharField(widget=forms.TextInput(), max_length=30)
email = forms.EmailField(widget=forms.TextInput())
legal_usernames_re = re.compile("^\w+$")
def clean_username(self):
username = self.cleaned_data['username'].lower()
if username in self._reserved_usernames:
raise forms.ValidationError(
_(u'%s is a reserved name, please choose another') % username)
elif not self.legal_usernames_re.search(username):
raise forms.ValidationError(
_(u'username may only contain alpha-numeric characters and '
u'underscores'))
try:
User.objects.get(username=username)
except User.DoesNotExist:
return username
raise forms.ValidationError(_(u'%s already exists') % username)
def save(self, profile_callback=None):
new_user = RegistrationProfile.objects.create_inactive_user(
username=self.cleaned_data['username'],
password=self.cleaned_data['<PASSWORD>'],
email=self.cleaned_data['email'],
site='http://distributedhealth.org',
send_email=False)
auth_token = UserAuthToken(user=new_user)
auth_token.save()
return ( new_user, auth_token )
```
#### File: keep_backend/openrosa/json_xls_convert.py
```python
import re
from django.http import HttpResponse
from openpyxl import Workbook
from openpyxl.writer.excel import save_virtual_workbook
class jsonXlsConvert():
def __init__(self, file_name):
jsonXlsConvert.wb = Workbook()
jsonXlsConvert.worksheet1 = self.wb.get_active_sheet()
self.worksheet1.title = 'survey'
jsonXlsConvert.surveyHeaders = ['type', 'name', 'label', 'hint', 'media::image',
'media::video', 'media::audio', 'constraint',
'constraint_message', 'required', 'default',
'relevant', 'read_only', 'calculation', 'appearance']
self.writeArrayToXLS(self.worksheet1, self.surveyHeaders, 'A1')
jsonXlsConvert.worksheet2 = self.wb.create_sheet(1)
self.worksheet2.title = 'choices'
jsonXlsConvert.choicesHeaders = ['list name', 'name', 'label', 'image']
self.writeArrayToXLS(self.worksheet2, self.choicesHeaders, 'A1')
jsonXlsConvert.file_name = (file_name + ".xlsx")
jsonXlsConvert.iterRow = 1
jsonXlsConvert.choicesRow = 1
#self.surveyHeaders = [s.replace('read_only', 'readonly') for s in self.surveyHeaders]
self.surveyHeaders[12] = 'readonly'
self.choicesHeaders.pop(0)
def writeToXls(self, json_dict):
self.recurseWriter(json_dict)
response = HttpResponse(save_virtual_workbook(self.wb), content_type='application/vnd.ms-excel')
response['Content-Disposition'] = 'attachment; filename="' + self.file_name + '"'
print self.surveyHeaders
return response
def recurseWriter(self, json_dict):
for element in json_dict:
self.iterRow += 1
surveyWriteRow = []
prepBinds = []
try:
prepBinds = element['bind']
except KeyError:
pass
if element.get("type") == 'group':
#self.iterRow += 1
surveyWriteRow = ['begin group']
self.writeArrayToXLS(self.worksheet1, surveyWriteRow, ('A' + `self.iterRow`))
self.recurseWriter(element.get("children"))
self.iterRow += 1
surveyWriteRow = ['end group']
self.writeArrayToXLS(self.worksheet1, surveyWriteRow, ('A' + `self.iterRow`))
#self.iterRow += 1
else:
for header in self.surveyHeaders:
if header in element:
if header is 'type':
print element[header]
if element[header] == 'select one':
element[header] = ('select one from ' + element.get('name'))
elif element[header] == 'select all that apply':
element[header] = ('select_multiple ' + element.get('name'))
surveyWriteRow += [element.get(header)]
elif header in prepBinds:
surveyWriteRow += [prepBinds.get(header)]
else:
surveyWriteRow += [""]
self.writeArrayToXLS(self.worksheet1, surveyWriteRow, ('A' + `self.iterRow`))
if 'choices' in element:
choiceOptions = element['choices']
self.choicesRow += 1
for choice in choiceOptions:
choiceWriteRow = [element.get("name")]
for header in self.choicesHeaders:
if header in choice:
choiceWriteRow += [choice.get(header)]
else:
choiceWriteRow += [""]
self.writeArrayToXLS(self.worksheet2, choiceWriteRow, ('A' + `self.choicesRow`))
self.choicesRow += 1
'''Utility function to write an array to excel using openpyxl'''
def writeArrayToXLS(self, worksheet, array_to_write, starting_cell, horizontal=True):
res = re.findall(r'\d+', starting_cell)
row = res[0]
col = starting_cell[:-len(res[0])]
col_ind = ord(col) - 96 + 32 # only works for A-Z in caps
if horizontal:
for i in range(0,len(array_to_write)):
cell_str = '%s%d' % (chr(col_ind + 64 + i), int(row))
worksheet.cell(cell_str).value = array_to_write[i]
# print cell_str
else:
for i in range(0,len(array_to_write)):
cell_str = '%s%d' % (chr(col_ind + 64 ), int(row) + i)
worksheet.cell(cell_str).value = array_to_write[i]
# print cell_str
```
#### File: keep_backend/privacy/map.py
```python
from random import random
from math import log
import numpy as np
def intervalq(point, bounds):
'''find which interval a point lies in given interval bounds
input: point - number to identify bucket for
bounds - list of increasing bucket bounds including ends
output: index such that bounds[index - 1] <= point < bounds[index]
'''
right = len(bounds) - 1
left = 0
assert(right > 0) # check that bounds contains at least two elements
# deal with points outside bounds range
if point >= bounds[right]:
return right
if point <= bounds[left]:
return 1
# binary search for interval
while left < right - 1:
assert(bounds[left] < bounds[right]) # check that bounds are sorted
mid = (left + right)/2
if point >= bounds[mid]:
left = mid
else:
right = mid
return right
def rlaplace(scale, location=0):
'''genrate a random deviate from Laplace(location, scale)'''
assert(scale > 0)
r = random()
signr = 1 if r >= 0.5 else -1
rr = r if r < 0.5 else 1 - r
return location - signr * scale * log(2 * rr)
def noisyh(h, epsilon=1.0, tau=0.5):
'''make a histogram ina numpy array differentially private.
Expected maximal noise added is O(lon(n)/epsilon) where
n are the number of times noise is added, i.e., size of
histogram. Using this, we set entries that are smaller than
tau * log(n)/epsilon 0.'''
hp = map(lambda x: rlaplace(scale=2/epsilon, location=x), h.flatten())
threshold = tau * log(len(hp))/epsilon
hpt = map(lambda y: 0 if y < threshold else y, hp)
return np.reshape(hpt, h.shape)
def p2m(points, xbounds, ybounds):
'''convert a list of points to histogram.
xbounds and ybounds contain grid axis points
into which points are discretized.'''
xb = sorted(xbounds) # make sure boundaries are sorted
yb = sorted(ybounds) # make sure boundaries are sorted
nxb = len(xb) - 1 # number of x intervals
nyb = len(yb) - 1 # number of y intervals
h = np.zeros((nxb, nyb))
for x, y in points:
i = intervalq(x, xb) - 1
j = intervalq(y, yb) - 1
h[i, j] += 1
return h
def m2p(h, xbounds, ybounds):
'''transform histogram into points
xbounds and ybounds give grid axis points,
meaning that h[i,j] is translated into a
point (x,y) such that x is uniformly distributed
in [xbounds[i], xbounds[i + 1]), and similarly for y.'''
xb = sorted(xbounds) # make sure boundaries are sorted
yb = sorted(ybounds) # make sure boundaries are sorted
nxb = len(xb) - 1 # number of x intervals
nyb = len(yb) - 1 # number of y intervals
assert(h.shape == (nxb, nyb))
points = []
for i in range(nxb):
ax = xb[i]
bx = xb[i + 1]
xwidth = bx - ax
for j in range(nyb):
ay = yb[j]
by = yb[j + 1]
ywidth = by - ay
pnts = map(lambda _: (ax + random() * xwidth,
ay + random() * ywidth),
range(int(h[i, j])))
points = pnts + points
return points
def privatize(points, xbounds, ybounds, epsilon=1.0, tau=1.5):
'''create differentially private version of list of points using a grid
the grid is defined by axis points in xbounds and ybounds.
epsilon is the differential privacy level.
tau is a filtering parameter, see noisyh().
'''
dph = np.array( noisyh( p2m(points, xbounds, ybounds), epsilon, tau).round(), int)
return m2p(dph, xbounds, ybounds)
```
#### File: keep_backend/repos/forms.py
```python
import csv
import json
import os
import re
from django import forms
from django.conf import settings
from django.core.exceptions import ObjectDoesNotExist
from django.core.files.base import ContentFile
from django.core.files.storage import default_storage as storage
from django.utils.text import slugify
from pyxform.xls2json import SurveyReader
from openrosa.xform_reader import XFormReader
from .models import Repository
from api.tasks import create_repo_from_file
from studies.models import Study
class NewBatchRepoForm( forms.Form ):
'''
Create a new repo from a CSV file.
'''
# File used to create/populate the new repo
repo_file = forms.FileField( required=True )
# The study this repo is associated with
study = forms.IntegerField( required=False )
# Whether or not this repo is a "tracker" repo.
tracker = forms.BooleanField( required=False )
VALID_FILE_TYPES = [ 'csv', 'xml', 'xls' ]
def __init__( self, *args, **kwargs ):
self._user = None
if 'user' in kwargs:
self._user = kwargs.pop( 'user' )
self._org = None
if 'org' in kwargs:
self._org = kwargs.pop( 'org' )
super( NewBatchRepoForm, self ).__init__( *args, **kwargs )
def clean( self ):
'''
Run through a final check before creating the new repository:
1. Check that the name of the repo is not already taken.
'''
username = self._user.username if self._user else self._org.name
if Repository.objects.repo_exists( self.cleaned_data[ 'name' ], username ):
raise forms.ValidationError( 'Repository already exists with this name' )
return self.cleaned_data
def clean_study( self ):
'''
Check if the study id that was passed in refers to a valid study.
1. The study must exist
2. The user must have access to this study.
'''
data = self.cleaned_data[ 'study' ]
if data == None:
return data
try:
study = Study.objects.get( id=data, user=self._user )
except ObjectDoesNotExist:
raise forms.ValidationError( 'Invalid study' )
return study
def clean_repo_file( self ):
'''
Determine the file type and check it against our list of valid file
types.
'''
data = self.cleaned_data[ 'repo_file' ]
# Split apart the file name so we can attempt to detect the file type
name, file_ext = os.path.splitext( data.name )
file_ext = file_ext[1:].lower()
# Check that this is a valid CSV file...
if file_ext not in self.VALID_FILE_TYPES:
raise forms.ValidationError( 'Please upload a valid CSV, XML, or XLS file' )
# Gleam some repo meta-data from the file
self.cleaned_data[ 'file_ext' ] = file_ext
self.cleaned_data[ 'name' ] = slugify( name.strip() )
self.cleaned_data[ 'desc' ] = 'Automatically created using %s' % ( data.name )
return self.cleaned_data[ 'repo_file' ]
def save( self ):
'''
Creates a new repository and creates a task to parse the file that
was uploaded by the user.
The task will handle the parsing and addition of fields and data
into the repository.
'''
# For now, the repository will have an empty field list.
repo = { 'fields': [] }
# Attempt to create and save the new repository
new_repo = Repository(
name=self.cleaned_data[ 'name' ],
study=self.cleaned_data[ 'study' ],
description=self.cleaned_data[ 'desc' ],
is_tracker=self.cleaned_data[ 'tracker' ],
user=self._user,
org=self._org,
is_public=False )
new_repo.save( repo=repo )
# Save the file to our storage bucket to be processed ASAP.
if not settings.DEBUG and not settings.TESTING:
storage.bucket_name = settings.AWS_TASK_STORAGE_BUCKET_NAME
s3_url = '%s.%s' % ( new_repo.mongo_id, self.cleaned_data[ 'file_ext' ] )
storage.save( s3_url, self.cleaned_data[ 'repo_file' ] )
# Create a task and go!
task = create_repo_from_file.delay( file=s3_url,
file_type=self.cleaned_data[ 'file_ext' ],
repo=new_repo.mongo_id )
new_repo.add_task( task.task_id, 'create_repo' )
return new_repo
class NewRepoForm( forms.Form ):
"""Validates and creates a new repository based on creation data.
Parameters
----------
forms.Form : Form
Attributes
----------
name : string
name of the form
desc : string
description of the form
privacy
survey_json : string, optional
The JSON of the form as a string, only if creating
a form from scratch
xform_file : File, optional
Generally, the csv/xform that we are creating a repository
from.
"""
name = forms.CharField()
desc = forms.CharField( widget=forms.Textarea(attrs={'rows':5,'class':'input-xxlarge'} ), required=False )
privacy = forms.ChoiceField( choices=[ ('public', 'Public'),
('private', 'Private') ],
widget=forms.RadioSelect )
survey_json = forms.CharField( required=False,
widget=forms.HiddenInput )
xform_file = forms.FileField( required=False )
def __init__( self, *args, **kwargs ):
"""We pass in the current user/org to test for the uniqueness of
the repository name in that current user's/org's list of
repositories.
Params
------
user : User
org : Organization, optional
If a user is acting on behalf of an organization,
this needs to be set.
"""
self._user = None
if 'user' in kwargs:
self._user = kwargs.pop( 'user' )
self._org = None
if 'org' in kwargs:
self._org = kwargs.pop( 'org' )
super( NewRepoForm, self ).__init__( *args, **kwargs )
def clean( self ):
"""
Run final checks on whether we have valid form schema to create the
repository.
"""
if self.cleaned_data[ 'survey_json' ] is None and\
self.cleaned_data[ 'xform_file' ] is None:
raise forms.ValidationError('''Please create or upload an XForm''')
return self.cleaned_data
def clean_name( self ):
"""
Clean & checks for the validity of the repo name.
1. Strip the repo name of any whitespace.
2. Check to see if the form name is a valid form name.
3. Check to see if the form name is not already taken by the user.
See http://docs.python.org/2/library/re.html for more info on the
regexes used.
"""
data = self.cleaned_data[ 'name' ].strip()
# Ensure form name is a valid form
if re.search( '[^-a-zA-Z0-9_]', data ) is not None:
raise forms.ValidationError( '''Repository name can not have
spaces or special characters''' )
# Check that this form name isn't already taken by the user
username = self._org.name if self._org else self._user.username
if Repository.objects.repo_exists( data, username ):
raise forms.ValidationError( '''Repository already exists with
this name''' )
return data
def clean_survey_json( self ):
"""
Clean & checks the validity of the repo JSON representation.
"""
data = self.cleaned_data[ 'survey_json' ].strip()
if len( data ) == 0:
return None
# Attempt to load the into a dict
try:
data = json.loads( data )
except Exception:
return None
# Add a default language
data[ 'default_language' ] = 'default'
# Go through and remove fields that dont have a valid label
to_remove = []
for field in data[ 'children' ]:
if len( field[ 'label' ] ) == 0 or len( field[ 'name' ] ) == 0:
to_remove.append( field )
# Delete fields.
for el in to_remove:
data[ 'children' ].remove( el )
return data
def clean_xform_file( self ):
"""
Clean & checks the validity of the uploaded xform file.
"""
data = self.cleaned_data[ 'xform_file' ]
if data is None:
return None
name, file_ext = os.path.splitext( data.name )
# Parse file depending on file type
if file_ext == '.xls':
survey = SurveyReader( data )
elif file_ext == '.xml':
survey = XFormReader( data )
else:
raise forms.ValidationError( 'Unable to read XForm' )
return survey.to_json_dict()
def save( self ):
"""
If everything is in place, attempt to save the new repository to
MongoDB & our database.
"""
repo = {}
if self.cleaned_data[ 'xform_file' ]:
repo['fields'] = self.cleaned_data[ 'xform_file' ]['children']
repo['type'] = "survey"
else:
repo['fields'] = self.cleaned_data[ 'survey_json' ]['children']
repo['type'] = self.cleaned_data[ 'survey_json' ]['type']
# Needed for xform formatting
# repo[ 'title' ] = self.cleaned_data[ 'name' ]
# repo[ 'id_string' ] = self.cleaned_data[ 'name' ]
new_repo = Repository(
name=self.cleaned_data[ 'name' ],
description=self.cleaned_data[ 'desc' ],
user=self._user,
org=self._org,
is_public=self.cleaned_data[ 'privacy' ] == 'public' )
return new_repo.save( repo=repo )
```
#### File: keep_backend/repos/__init__.py
```python
import logging
from django.core.files import File
from django.http import QueryDict
logger = logging.getLogger( __name__ )
def validate_and_format( fields, data, files ):
"""Do some basic validation and convert strings to <type> where
necessary.
Parameters
----------
fields : []
The JSON empty fields of the form.
data : array of strings
All user data provided to the form.
files : array of strings
All user files provided to the form.
Returns
-------
valid_data : dictionary
Dictionary of all validated data and corresponding questions
valid_files : dictionary
Dictionary of all validated files and corresponding questions
"""
valid_data = {}
valid_files = {}
for element in fields:
etype = element[ 'type' ]
ename = element[ 'name' ]
# Flatten groups by making a recursive call
if 'group' in etype:
temp_data = validate_and_format( element[ 'children' ], data, files )
valid_data.update( temp_data[0] )
valid_files.update( temp_data[1] )
# Do type conversions
if ename in data:
# Convert to integer
if etype == 'integer':
try:
valid_data[ ename ] = int( data[ ename ] )
except ValueError:
pass
elif 'select all' in etype:
# If data is a QueryDict ( from a HttpRequest ), grab the list like so
if isinstance( data, QueryDict ):
valid_data[ ename ] = data.getlist( ename, [] )
# Otherwise attempt to parse the data value
else:
list_data = data.get( ename, [] )
if isinstance( list_data, basestring ):
valid_data[ ename ] = list_data.split( ',' )
logger.info( list_data.split( ',' ) )
else:
valid_data[ ename ] = list_data
elif etype in [ 'photo', 'video' ] and isinstance( data.get( ename ), File ):
valid_data[ ename ] = data.get( ename ).name
valid_files[ ename ] = data.get( ename )
elif etype == 'geopoint':
# Convert a X,Y string into a geocoordinate.
geodata = { 'type': 'Point',
'coordinates': [],
'properties': {
'altitude': 0,
'accuracy': 0,
'comment': '' }}
# TODO: Handle potential errors parsing the string?
coords = data.get( ename )
coords = coords.split( ' ' )
# If the row doesn't have a geopoint, set to None
try:
geodata[ 'coordinates' ] = [ float( coords[0] ), float( coords[1] ) ]
except ValueError:
geodata[ 'coordinates' ] = [ None, None ]
valid_data[ ename ] = geodata
else:
# Otherwise treat the piece of data as whatever it came in as.
valid_data[ ename ] = data[ ename ]
if files is not None and ename in files:
valid_data[ ename ] = files[ ename ].name
valid_files[ ename ] = files[ ename ]
return ( valid_data, valid_files )
```
#### File: tests/test_api/test_openrosa_api.py
```python
import json
from tests import ApiTestCase
class OpenRosaAPITests( ApiTestCase ):
AUTH_DETAILS = { 'format': 'json',
'user': 'admin',
'key': '<KEY>' }
AUTH_DETAILS_XFORM = { 'format': 'xform',
'user': 'admin',
'key': '<KEY>' }
def test_formlist( self ):
'''
'''
response = self.client.get( '/bs/admin/formList', self.AUTH_DETAILS_XFORM, follow=True )
assert response.status_code == 200
def test_repo_xform_xml( self ):
'''
Test if we can list the repo details for a specific repo for a
test user.
'''
# Get the list of repos for the test user
response = self.open( '/repos/', self.AUTH_DETAILS )
response = json.loads( response.content )
for repo in response.get( 'objects' ):
response = self.open( '/repos/%s/' % ( repo.get( 'id' ) ), self.AUTH_DETAILS_XFORM )
assert response.status_code == 200
```
#### File: tests/test_openrosa/test_json_to_xls.py
```python
from django.test import TestCase
from openrosa.xform_reader import XFormReader
from openrosa.json_xls_convert import jsonXlsConvert
# Tutorial xform with basic data/survey types
XFORM_FILE = '../_data/test_docs/tutorial.xml'
class JSONToXLSTests( TestCase ):
def test_conversion( self ):
reader = XFormReader( XFORM_FILE )
json = reader.to_json_dict()
converter = jsonXlsConvert( '/tmp/test.xls' )
converter.writeToXls( json.get( 'children' ) )
```
#### File: tests/test_orgs/test_views.py
```python
import json
from django.core.urlresolvers import reverse
from tests import ViewTestCase
from organizations.models import Organization
class OrgViewTests( ViewTestCase ):
def test_add_member_accept( self ):
org = self.test_new()
self.login()
# Request a member to join
url = reverse( 'organization_member_add', kwargs={'org': org.name, 'user': 'test_user'} )
response = self.client.post( url )
self.assertEqual( response.status_code, 200 )
# Attempt to accept member invitation under another account
url = reverse( 'organization_member_accept', kwargs={'org': org.name, 'user': 'test_user'})
response = self.client.get( url )
self.assertEqual( response.status_code, 404 )
self.logout()
# Login with our test user and accept the member invitation
self.login( username='test_user', password='<PASSWORD>' )
response = self.client.get( url )
self.assertEqual( response.status_code, 302 )
self.logout()
org.delete()
def test_add_member_ignore( self ):
org = self.test_new()
self.login()
# Request a member to join
url = reverse( 'organization_member_add', kwargs={'org': org.name, 'user': 'test_user'} )
response = self.client.post( url )
self.assertEqual( response.status_code, 200 )
# Attempt to accept member invitation under another account
url = reverse( 'organization_member_ignore', kwargs={'org': org.name, 'user': 'test_user'})
response = self.client.get( url )
self.assertEqual( response.status_code, 404 )
self.logout()
# Login with our test user and accept the member invitation
self.login( username='test_user', password='<PASSWORD>' )
response = self.client.get( url )
self.assertEqual( response.status_code, 302 )
self.logout()
org.delete()
def test_dashboard( self ):
org = self.test_new()
url = reverse( 'organization_dashboard', kwargs={ 'org': org.name } )
self.login()
response = self.client.get( url )
self.assertEqual( response.status_code, 200 )
self.logout()
org.delete()
def test_delete( self ):
org = self.test_new()
url = reverse( 'organization_delete', kwargs={ 'org': org.name } )
self.login()
response = self.client.get( url )
self.assertEqual( response.status_code, 302 )
self.logout()
def test_new( self ):
self.login()
url = reverse( 'organization_new' )
# Test GET response
response = self.client.get( url )
self.assertEqual( response.status_code, 200 )
# Test POST response
org_data = {
'name': 'test_org',
'gravatar': '' }
response = self.client.post( url, org_data )
self.assertEqual( response.status_code, 302 )
self.logout()
return Organization.objects.get( name='test_org' )
def test_new_repo( self ):
org = self.test_new()
self.login()
url = reverse( 'organization_repo_new', kwargs={'org': org.name} )
# Test GET response
response = self.client.get( url )
self.assertEqual( response.status_code, 200 )
# Test POST response
repo_data = {
'name': 'new_test',
'desc': 'description',
'privacy': 'private',
'survey_json': json.dumps( {
'type': 'survey',
'children': [ { 'type': 'text',
'name': 'name',
'label': 'What\'s your name?' }]
})
}
response = self.client.post( url, repo_data )
self.assertEqual( response.status_code, 302 )
self.logout()
org.delete()
``` |
{
"source": "994125010/pyanalyze",
"score": 3
} |
#### File: pyanalyze/pyanalyze/yield_checker.py
```python
import ast
from ast_decompiler import decompile
import asynq
import contextlib
from dataclasses import dataclass, field
import qcore
import itertools
import logging
from typing import (
Any,
Dict,
Set,
Callable,
ContextManager,
Iterator,
List,
Optional,
Sequence,
TYPE_CHECKING,
Tuple,
)
from .asynq_checker import AsyncFunctionKind
from .error_code import ErrorCode
from .value import Value, KnownValue, UnboundMethodValue, UNINITIALIZED_VALUE
from .analysis_lib import get_indentation, get_line_range_for_node
from .node_visitor import Replacement
if TYPE_CHECKING:
from .name_check_visitor import NameCheckVisitor
@dataclass
class YieldInfo:
"""Wrapper class for yield nodes."""
yield_node: ast.Yield
statement_node: ast.stmt
lines: List[str]
line_range: List[int] = field(init=False)
def __post_init__(self) -> None:
self.line_range = get_line_range_for_node(self.statement_node, self.lines)
def is_assign_or_expr(self) -> bool:
if not isinstance(self.statement_node, (ast.Expr, ast.Assign)):
return False
return self.statement_node.value is self.yield_node
def get_indentation(self) -> int:
return get_indentation(self.lines[self.statement_node.lineno - 1])
def target_and_value(self) -> Tuple[List[ast.AST], List[ast.AST]]:
"""Returns a pair of a list of target nodes and a list of value nodes."""
assert self.yield_node.value is not None
if isinstance(self.statement_node, ast.Assign):
# this branch is for assign statements
# e.g. x = yield y.asynq()
# _ = yield async_fn.asynq()
if not isinstance(self.statement_node.targets[0], ast.Tuple):
# target is one entity
return ([self.statement_node.targets[0]], [self.yield_node.value])
# target is a tuple
elif (
isinstance(self.yield_node.value, ast.Call)
and isinstance(self.yield_node.value.func, ast.Name)
and self.yield_node.value.func.id == "tuple"
and isinstance(self.yield_node.value.args[0], ast.Tuple)
):
# value is a call to tuple()
# e.g. x, y = yield tuple((a.asynq(), b.asynq()))
# in this case we remove the call to tuple and return
# the plain elements of the tuple but we remove the surrounding braces
return (
self.statement_node.targets[0].elts,
self.yield_node.value.args[0].elts,
)
elif isinstance(self.yield_node.value, ast.Tuple):
# value is a tuple too, return both targets and values as such
# but get rid of the parenthesis
return (self.statement_node.targets[0].elts, self.yield_node.value.elts)
# target is a tuple but only one value
# e.g. x, y = yield f.asynq()
# in this case we'll wrap the target with () so that they
# can be combined with another yield
return ([self.statement_node.targets[0]], [self.yield_node.value])
# not an assign statement
# e.g. yield x.asynq()
if not isinstance(self.yield_node.value, ast.Tuple):
# single entity yielded
return ([ast.Name(id="_", ctx=ast.Store())], [self.yield_node.value])
# multiple values yielded e.g. yield x.asynq(), z.asynq()
return (
[ast.Name(id="_", ctx=ast.Store()) for _ in self.yield_node.value.elts],
self.yield_node.value.elts,
)
class VarnameGenerator:
"""Class to generate a unique variable name from an AST node.
Split off into a separate class for ease of testing.
To construct this class, pass in a function that, given a name, returns whether it is available.
Call .get(node) on the instance to get a variable name for an AST node.
"""
def __init__(self, is_available: Callable[[str], bool]) -> None:
self.is_available = is_available
def get(self, node: ast.AST) -> str:
"""Returns a unique variable name for this node."""
candidate = self._get_candidate(node).lstrip("_")
return self._ensure_unique(candidate)
def _get_candidate(self, node: ast.AST) -> str:
if isinstance(node, ast.Name):
camel_cased = _camel_case_to_snake_case(node.id)
if camel_cased != node.id:
return camel_cased
else:
return f"{node.id}_result"
elif isinstance(node, ast.Attribute):
if node.attr == "async" or node.attr == "asynq":
return self._get_candidate(node.value)
elif node.attr.endswith("_async"):
# probably a method call like .get_async
return self._get_candidate(node.value)
else:
varname = node.attr.lstrip("_")
for prefix in ("render_", "get_"):
if varname.startswith(prefix):
return varname[len(prefix) :]
else:
return varname
elif isinstance(node, ast.Call):
if (
isinstance(node.func, ast.Attribute)
and isinstance(node.func.value, ast.Name)
and node.func.value.id == "async_call"
and node.args
):
return self._get_candidate(node.args[0])
return self._get_candidate(node.func)
else:
return "autogenerated_var"
def _ensure_unique(self, varname: str) -> str:
"""Ensures an autogenerated variable name is unique by appending numbers to it."""
if self.is_available(varname):
return varname
else:
for i in itertools.count(2):
next_varname = f"{varname}{i}"
if self.is_available(next_varname):
return next_varname
assert False, "unreachable"
@dataclass
class YieldChecker:
visitor: "NameCheckVisitor"
variables_from_yield_result: Dict[str, bool] = field(default_factory=dict)
in_yield_result_assignment: bool = False
in_non_async_yield: bool = False
last_yield_in_aug_assign: bool = False
previous_yield: Optional[ast.Yield] = None
statement_for_previous_yield: Optional[ast.stmt] = None
used_varnames: Set[str] = field(default_factory=set)
added_decorator: bool = False
@contextlib.contextmanager
def check_yield(
self, node: ast.Yield, current_statement: ast.stmt
) -> Iterator[None]:
assert current_statement is not None
if self.visitor.async_kind == AsyncFunctionKind.normal:
self._check_for_duplicate_yields(node, self.visitor.current_statement)
in_non_async_yield = self.visitor.async_kind == AsyncFunctionKind.non_async
with qcore.override(self, "in_non_async_yield", in_non_async_yield):
yield
if self.visitor.async_kind == AsyncFunctionKind.normal:
self._maybe_show_unnecessary_yield_error(node, current_statement)
if self.last_yield_in_aug_assign:
self._maybe_show_unnecessary_yield_error(node, current_statement)
self.last_yield_in_aug_assign = self._is_augassign_target(node)
self.variables_from_yield_result = {}
self.previous_yield = node
self.statement_for_previous_yield = current_statement
# Unnecessary yield checking
def check_yield_result_assignment(self, in_yield: bool) -> ContextManager[None]:
return qcore.override(self, "in_yield_result_assignment", in_yield)
def record_assignment(self, name: str) -> None:
if self.in_yield_result_assignment:
self.variables_from_yield_result[name] = False
def record_usage(self, name: str, node: ast.AST) -> None:
if name in self.variables_from_yield_result:
if self._is_augassign_target(node):
return
self.variables_from_yield_result[name] = True
def reset_yield_checks(self) -> None:
"""Resets variables for the unnecessary yield check.
This is done while visiting if statements to prevent the unnecessary yield check from
concluding that yields in one branch of the if are unused.
"""
self.variables_from_yield_result = {}
self.last_yield_in_aug_assign = False
# Missing @async detection
def record_call(self, value: Value, node: ast.Call) -> None:
if (
not self.in_non_async_yield
or not self._is_async_call(value, node.func)
or self.added_decorator
):
return
# prevent ourselves from adding the decorator to the same function multiple times
self.added_decorator = True
func_node = self.visitor.node_context.nearest_enclosing(ast.FunctionDef)
lines = self.visitor._lines()
# this doesn't handle decorator order, it just adds @asynq() right before the def
i = func_node.lineno - 1
def_line = lines[i]
indentation = len(def_line) - len(def_line.lstrip())
replacement = Replacement([i + 1], [" " * indentation + "@asynq()\n", def_line])
self.visitor.show_error(
node, error_code=ErrorCode.missing_asynq, replacement=replacement
)
# Internal part
def _is_augassign_target(self, node: ast.AST) -> bool:
return (
isinstance(self.visitor.current_statement, ast.AugAssign)
and node is self.visitor.current_statement.value
)
def _is_async_call(self, value: Value, node: ast.AST) -> bool:
# calls to something.asynq are always async
if isinstance(node, ast.Attribute) and (
node.attr in ("async", "asynq", "future") or node.attr.endswith("_async")
):
return True
if isinstance(value, UnboundMethodValue):
obj = value.get_method()
elif isinstance(value, KnownValue):
obj = value.val
else:
return False
return self.is_async_fn(obj)
def _maybe_show_unnecessary_yield_error(
self, node: ast.Yield, current_statement: ast.stmt
) -> None:
if isinstance(current_statement, ast.Expr) and current_statement.value is node:
return
current_yield_result_vars = self.variables_from_yield_result
# check if we detected anything being used out of the last yield
self.visitor.log(logging.DEBUG, "Yield result", current_yield_result_vars)
if len(current_yield_result_vars) > 0:
if not any(current_yield_result_vars.values()):
unused = list(current_yield_result_vars.keys())
self.show_unnecessary_yield_error(unused, node, current_statement)
def _check_for_duplicate_yields(
self, node: ast.Yield, current_statement: ast.stmt
) -> None:
if not isinstance(node.value, ast.Tuple) or len(node.value.elts) < 2:
return
duplicate_indices = {} # index to first index
seen = {} # ast.dump result to index
for i, member in enumerate(node.value.elts):
# identical AST nodes don't compare equally, so just stringify them for comparison
code = ast.dump(member)
if code in seen:
duplicate_indices[i] = seen[code]
else:
seen[code] = i
if not duplicate_indices:
return
new_members = [
elt for i, elt in enumerate(node.value.elts) if i not in duplicate_indices
]
if len(new_members) == 1:
new_value = new_members[0]
else:
new_value = ast.Tuple(elts=new_members)
new_yield_node = ast.Yield(value=new_value)
if isinstance(current_statement, ast.Expr) and current_statement.value is node:
new_nodes = [ast.Expr(value=new_yield_node)]
elif (
isinstance(current_statement, ast.Assign)
and current_statement.value is node
):
if (
len(current_statement.targets) != 1
or not isinstance(current_statement.targets[0], ast.Tuple)
or len(current_statement.targets[0].elts) != len(node.value.elts)
):
new_nodes = None
else:
new_targets = []
# these are for cases where we do something like
# a, b = yield f.asynq(), f.asynq()
# we turn this into
# a = yield f.asynq()
# b = a
extra_nodes = []
assignment_targets = current_statement.targets[0].elts
for i, target in enumerate(assignment_targets):
if i not in duplicate_indices:
new_targets.append(target)
elif not (isinstance(target, ast.Name) and target.id == "_"):
extra_nodes.append(
ast.Assign(
targets=[target],
value=assignment_targets[duplicate_indices[i]],
)
)
if len(new_targets) == 1:
new_target = new_targets[0]
else:
new_target = ast.Tuple(elts=new_targets)
new_assign = ast.Assign(targets=[new_target], value=new_yield_node)
new_nodes = [new_assign] + extra_nodes
else:
new_nodes = None
if new_nodes is not None:
lines_to_delete = self._lines_of_node(node)
indent = self._indentation_of_node(current_statement)
new_code = "".join(
decompile(node, starting_indentation=indent) for node in new_nodes
)
new_lines = [line + "\n" for line in new_code.splitlines()]
replacement = Replacement(lines_to_delete, new_lines)
else:
replacement = None
self.visitor.show_error(
node, error_code=ErrorCode.duplicate_yield, replacement=replacement
)
def show_unnecessary_yield_error(
self, unused: Sequence[object], node: ast.Yield, current_statement: ast.stmt
) -> None:
if not unused:
message = "Unnecessary yield: += assignments can be combined"
elif len(unused) == 1:
message = "Unnecessary yield: %s was not used before this yield" % (
unused[0],
)
else:
unused_str = ", ".join(map(str, unused))
message = f"Unnecessary yield: {unused_str} were not used before this yield"
replacement = self._create_replacement_for_yield_nodes(node, current_statement)
self.visitor.show_error(
node, message, ErrorCode.unnecessary_yield, replacement=replacement
)
def _lines_of_node(self, yield_node: ast.Yield) -> List[int]:
"""Returns the lines that the given yield node occupies."""
# see if it has a parent assign node
if hasattr(yield_node, "parent_assign_node"):
first_lineno = yield_node.parent_assign_node.lineno
else:
first_lineno = yield_node.lineno
lines = self.visitor._lines()
first_line = lines[first_lineno - 1]
indent = get_indentation(first_line)
last_lineno = first_lineno + 1
while True:
if last_lineno - 1 >= len(lines):
break
last_line = lines[last_lineno - 1]
last_line_indent = get_indentation(last_line)
# if it is just spaces then stop
if last_line.isspace():
break
if last_line_indent > indent:
last_lineno += 1
elif (
last_line_indent == indent
and len(last_line) >= indent
and last_line[indent] == ")"
):
last_lineno += 1
else:
break
return list(range(first_lineno, last_lineno))
def _create_replacement_for_yield_nodes(
self, second_node: ast.Yield, second_parent: ast.stmt
) -> Optional[Replacement]:
"""Returns one statement that does a batched yield of the given 2 yields."""
lines = self.visitor._lines()
assert self.previous_yield is not None
assert self.statement_for_previous_yield is not None
first_yield = YieldInfo(
self.previous_yield, self.statement_for_previous_yield, lines
)
second_yield = YieldInfo(second_node, second_parent, lines)
# this shouldn't happen in async code but test_scope checks for it elsewhere
if (
first_yield.yield_node.value is None
or second_yield.yield_node.value is None
):
return None
# check whether there is any code between the two yield statements
lines_in_between = list(
range(first_yield.line_range[-1] + 1, second_yield.line_range[0])
)
adjacent = not lines_in_between or all(
lines[i - 1].isspace() for i in lines_in_between
)
if first_yield.is_assign_or_expr() and second_yield.is_assign_or_expr():
if adjacent:
return self._merge_assign_nodes(first_yield, second_yield)
else:
# give up if the two are at different indentations
# this probably means the second one is in a with context or try-except
if first_yield.get_indentation() != second_yield.get_indentation():
return None
# if there is intervening code, first move the first yield to right before the
# second one
to_delete = list(
range(first_yield.line_range[0], second_yield.line_range[0])
)
yield_lines = lines[
first_yield.line_range[0] - 1 : first_yield.line_range[-1]
]
between_lines = lines[
first_yield.line_range[-1] : second_yield.line_range[0] - 1
]
return Replacement(to_delete, between_lines + yield_lines)
elif first_yield.is_assign_or_expr():
# move the target of the second yield to right after the first one
indentation = first_yield.get_indentation()
new_assign_lines, replace_yield = self._move_out_var_from_yield(
second_yield, indentation
)
between_lines = lines[
first_yield.line_range[-1] : second_yield.line_range[0] - 1
]
to_add = [*new_assign_lines, *between_lines]
if replace_yield.lines_to_add:
to_add += replace_yield.lines_to_add
# determine lines to remove
between_range = list(
range(first_yield.line_range[-1] + 1, second_yield.line_range[0])
)
to_delete = [*between_range, *replace_yield.linenos_to_delete]
return Replacement(to_delete, to_add)
else:
indentation = first_yield.get_indentation()
lines_to_add, replace_first = self._move_out_var_from_yield(
first_yield, indentation
)
if second_yield.is_assign_or_expr():
# just move it
second_lines = lines[
second_yield.line_range[0] - 1 : second_yield.line_range[-1]
]
second_indentation = get_indentation(second_lines[0])
difference = indentation - second_indentation
if difference > 0:
second_lines = [" " * difference + line for line in second_lines]
elif difference < 0:
second_lines = [line[(-difference):] for line in second_lines]
lines_to_add += second_lines
lines_for_second_yield = []
else:
second_assign_lines, replace_second = self._move_out_var_from_yield(
second_yield, indentation
)
lines_to_add += second_assign_lines
lines_for_second_yield = replace_second.lines_to_add
lines_to_add += replace_first.lines_to_add or []
lines_to_add += lines[
first_yield.line_range[-1] : second_yield.line_range[0] - 1
]
if lines_for_second_yield:
lines_to_add += lines_for_second_yield
linenos_to_delete = list(
range(first_yield.line_range[0], second_yield.line_range[-1] + 1)
)
return Replacement(linenos_to_delete, lines_to_add)
def _move_out_var_from_yield(
self, yield_info: YieldInfo, indentation: int
) -> Tuple[List[str], Replacement]:
"""Helper for splitting up a yield node and moving it to an earlier place.
For example, it will help turn:
some_code((yield get_value.asynq()))
into:
value = yield get_value.asynq()
...
some_code(value)
Returns a pair of a list of lines to form the new assignment code (value = ...) and a
Replacement object implementing the second change.
"""
assert yield_info.yield_node.value is not None
varname = self.generate_varname_from_node(yield_info.yield_node.value)
name_node = ast.Name(id=varname)
replace = self.visitor.replace_node(
yield_info.yield_node,
name_node,
current_statement=yield_info.statement_node,
)
new_assign = ast.Assign(targets=[name_node], value=yield_info.yield_node)
new_assign_code = decompile(new_assign, starting_indentation=indentation)
assign_lines = [line + "\n" for line in new_assign_code.splitlines()]
return assign_lines, replace
def _merge_assign_nodes(
self, first_yield: YieldInfo, second_yield: YieldInfo
) -> Replacement:
# the basic approach is to extract the targets (left hand side of the assignment) and the
# values to yield (on the right hand side) independently for each of the yield nodes and
# then combine them. But there are different cases to consider
first_node_target_value = first_yield.target_and_value()
second_node_target_value = second_yield.target_and_value()
targets = first_node_target_value[0] + second_node_target_value[0]
values = first_node_target_value[1] + second_node_target_value[1]
yield_node = ast.Yield(value=ast.Tuple(elts=values))
# if everything in targets is an underscore '_', then just avoid creating
# an assignment statement
if all(isinstance(target, ast.Name) and target.id == "_" for target in targets):
new_node = ast.Expr(value=yield_node)
else:
new_node = ast.Assign(targets=[ast.Tuple(elts=targets)], value=yield_node)
indent = self._indentation_of_node(first_yield.statement_node)
new_code = decompile(new_node, starting_indentation=indent)
lines_to_delete = list(
range(first_yield.line_range[0], second_yield.line_range[-1] + 1)
)
return Replacement(lines_to_delete, [new_code])
def _indentation_of_node(self, node: ast.AST) -> int:
"""Calculate the indentation of an AST node."""
line = self.visitor._lines()[node.lineno - 1]
# assumes that there is at least one space in the beginning which should be the case
return get_indentation(line)
def generate_varname_from_node(self, node: ast.AST) -> str:
def is_available(name: str) -> bool:
if name in self.used_varnames:
return False
value = self.visitor.scopes.get(name, node=None, state=None)
return value is UNINITIALIZED_VALUE
varname = VarnameGenerator(is_available).get(node)
self.used_varnames.add(varname)
return varname
def is_async_fn(self, obj: Any) -> bool:
if hasattr(obj, "__self__"):
if isinstance(
obj.__self__, asynq.decorators.AsyncDecorator
) or asynq.is_async_fn(obj.__self__):
return True
return asynq.is_async_fn(obj)
def _camel_case_to_snake_case(s: str) -> str:
"""Converts a CamelCase string to snake_case."""
out = []
last_was_uppercase = False
for c in s:
if c.isupper():
out.append(c.lower())
else:
if last_was_uppercase and len(out) > 1:
out[-1] = "_" + out[-1]
out.append(c)
last_was_uppercase = c.isupper()
return "".join(out)
``` |
{
"source": "994374821/maskrcnn_body25",
"score": 2
} |
#### File: detectron/utils/py_cpu_nms.py
```python
import numpy as np
from matplotlib.patches import Rectangle
import matplotlib.pyplot as plt
from IPython import embed
from detectron.core.config import cfg
debug = False
def soft(dets, confidence=None, ax = None):
thresh = cfg.STD_TH #.6
score_thresh = .7
sigma = .5
N = len(dets)
x1 = dets[:, 0].copy()
y1 = dets[:, 1].copy()
x2 = dets[:, 2].copy()
y2 = dets[:, 3].copy()
scores = dets[:, 4].copy()
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
ious = np.zeros((N,N))
kls = np.zeros((N,N))
for i in range(N):
xx1 = np.maximum(x1[i], x1)
yy1 = np.maximum(y1[i], y1)
xx2 = np.minimum(x2[i], x2)
yy2 = np.minimum(y2[i], y2)
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
inter = w * h
ovr = inter / (areas[i] + areas - inter)
ious[i,:] = ovr
kl = np.zeros_like(ovr)
for j in range(4):
std1 = confidence[i, j]
stdo = confidence[:, j]
mean1 = dets[i, j]
meano = dets[:, j]
kl += np.log(stdo/std1) + (std1**2 + (mean1 - meano)**2) / 2 / (stdo**2) - .5
kls[i, :] = kl.copy()
if False and len(kls) != 0:
print("std",kls.std())
print("mean",kls.mean())
print("max",kls.max())
print("min",kls.min())
i = 0
while i < N:
maxpos = dets[i:N, 4].argmax()
maxpos += i
dets[[maxpos,i]] = dets[[i,maxpos]]
areas[[maxpos,i]] = areas[[i,maxpos]]
confidence[[maxpos,i]] = confidence[[i,maxpos]]
scores[[maxpos,i]] = scores[[i,maxpos]]
ious[[maxpos,i]] = ious[[i,maxpos]]
ious[:,[maxpos,i]] = ious[:,[i,maxpos]]
kls[[maxpos,i]] = kls[[i,maxpos]]
kls[:,[maxpos,i]] = kls[:,[i,maxpos]]
# N N & (scores[(i+1):N] > score_thresh)
#ovr_bbox = np.where((kls[i, (i+1):N] < 300) & (scores[(i+1):N] > score_thresh))[0] + i + 1
#ovr_bbox = np.where((ious[i, (i+1):N] > thresh))[0] + i + 1
#ovr_bbox = np.hstack(([i], ovr_bbox))
ovr_bbox = np.where((ious[i, :N] > thresh))[0]
avg_bbox = (dets[ovr_bbox, :4] * scores[ovr_bbox, np.newaxis]).sum(0) / scores[ovr_bbox].sum()
avg_std_bbox = (dets[ovr_bbox, :4] / confidence[ovr_bbox]).sum(0) / (1/confidence[ovr_bbox]).sum(0)
avg_stds_bbox = (dets[ovr_bbox, :4] / confidence[ovr_bbox]**2).sum(0) / (1/confidence[ovr_bbox]**2).sum(0)
mean_bbox = dets[ovr_bbox, :4].mean(0)
tx1, ty1, tx2, ty2 = dets[i, :4].copy()
#dets[i,:4] = avg_bbox
if cfg.STD_NMS:
#dets[i,:4] = avg_bbox
dets[i,:4] = avg_std_bbox
#dets[i,:4] = mean_bbox
pass
else:
assert(False)
#dets[i,:4] = avg_stds_bbox
#dets[i,:4] = mean_bbox
areai = areas[i] #(tx2 - tx1 + 1) * (ty2 - ty1 + 1)
pos = i + 1
while pos < N:
if ious[i , pos] > 0:
ovr = ious[i , pos]#float(inter) / (areai + area - inter)
dets[pos, 4] *= np.exp(-(ovr * ovr)/sigma)
if dets[pos, 4] < 0.001:
dets[[pos, N-1]] = dets[[N-1, pos]]
areas[[pos, N-1]] = areas[[N-1, pos]]
scores[[pos, N-1]] = scores[[N-1, pos]]
confidence[[pos, N-1]] = confidence[[N-1, pos]]
ious[[pos, N-1]] = ious[[N-1, pos]]
ious[:,[pos, N-1]] = ious[:,[N-1, pos]]
kls[[pos, N-1]] = kls[[N-1, pos]]
kls[:,[pos, N-1]] = kls[:,[N-1, pos]]
N -= 1
pos -= 1
pos += 1
i += 1
keep=[i for i in range(N)]
return dets[keep], keep
def greedy(dets, thresh=None, confidence=None, ax = None):
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
if len(scores) == 0:
return []
elif len(scores) == 1:
return [0]
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
ious = np.zeros([len(x1), len(x1)])
w2 = .42
for i in range(len(x1)):
xx1 = np.maximum(x1[i], x1)
yy1 = np.maximum(y1[i], y1)
xx2 = np.minimum(x2[i], x2)
yy2 = np.minimum(y2[i], y2)
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
inter = w * h
ovr = inter / (areas[i] + areas - inter)
for j in range(len(ovr)):
if i == j:
ious[i, i] = -(1-w2) * scores[i]
ious[i,j] += w2 * ovr[j]
else:
ious[i,j] = w2 * ovr[j]
score = 0
keep = []
remain = list(range(len(x2)))
while len(remain) > 0:
if len(keep) == 0:
inc = np.diag(ious)[remain]
else:
try:
d = ious[remain][:, keep]
if len(d.shape) == 2:
d = d.sum(1)
inc = d+np.diag(ious)[remain]
except:
embed()
if inc.min() >= 0:
break
idx = inc.argmin()
obj = remain[idx]
remain.remove(obj)
keep.append(obj)
if len(keep) !=0:
print(len(keep), len(x1))
return keep
def qb(dets, thresh=None, confidence=None, ax = None):
from dwave_qbsolv import QBSolv
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
if len(scores) == 0:
return []
elif len(scores) == 1:
return [0]
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
ious = {}#np.zeros([len(x1), len(x1)])
w2 = 0.4
for i in range(len(x1)):
xx1 = np.maximum(x1[i], x1)
yy1 = np.maximum(y1[i], y1)
xx2 = np.minimum(x2[i], x2)
yy2 = np.minimum(y2[i], y2)
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
inter = w * h
ovr = inter / (areas[i] + areas - inter)
for j in range(len(ovr)):
if i == j:
ious[i, i] = -(1-w2) * scores[i]
ious[i,j] += w2 * ovr[j]
else:
ious[i,j] = w2 * ovr[j]
response = QBSolv().sample_qubo(ious, verbosity=0)
samples = list(response.samples())[0]
keep = []
for i in range(len(x1)):
if samples[i] == 1:
keep.append(i)
#if len(keep) == 0:
# keep_dets = np.ndarray((0, 4))
#else:
# keep_dets = dets[keep]
## print(keep_dets)
#return keep_dets
return keep
def py_cpu_nms(dets, thresh):
"""Pure Python NMS baseline."""
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
order = scores.argsort()[::-1]
keep = []
while order.size > 0:
i = order[0]
keep.append(i)
xx1 = np.maximum(x1[i], x1[order[1:]])
yy1 = np.maximum(y1[i], y1[order[1:]])
xx2 = np.minimum(x2[i], x2[order[1:]])
yy2 = np.minimum(y2[i], y2[order[1:]])
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
inter = w * h
ovr = inter / (areas[i] + areas[order[1:]] - inter)
inds = np.where(ovr <= thresh)[0]
order = order[inds + 1]
return keep
def show_box(ax, bbox, text, color):
ax.add_patch(
Rectangle((bbox[0], bbox[1]),
bbox[2] - bbox[0],
bbox[3] - bbox[1], fill=False,
edgecolor=color, linewidth=3)
)
ax.text(bbox[0] + 3, bbox[1]+7,
text,
fontsize=7, color=color)
def confidence_nms(dets, thresh, confidence, ax = None):
softnms = 0
softthresh = .4
score_thresh = .7
keep_dets = []
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
order = scores.argsort()[::-1]
keep = []
while order.size > 0:
i = order[0]
keep.append(i)
xx1 = np.maximum(x1[i], x1[order[1:]])
yy1 = np.maximum(y1[i], y1[order[1:]])
xx2 = np.minimum(x2[i], x2[order[1:]])
yy2 = np.minimum(y2[i], y2[order[1:]])
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
inter = w * h
ovr = inter / (areas[i] + areas[order[1:]] - inter)
ovr_bbox = order[np.where((ovr > thresh) & (scores[order[1:]] > score_thresh))[0] + 1]
ovr_bbox = np.hstack(([i], ovr_bbox))
avg_std_bbox = (dets[ovr_bbox, :4] / confidence[ovr_bbox]).sum(0) / (1/confidence[ovr_bbox]).sum(0)
avg_bbox = (dets[ovr_bbox, :4] * scores[ovr_bbox, np.newaxis]).sum(0) / scores[ovr_bbox].sum()
merged = (dets[ovr_bbox, :4] / (confidence[ovr_bbox] * (1/confidence[ovr_bbox]).sum(0))).sum(0)
bbox = dets[ovr_bbox, :4][(confidence[ovr_bbox].sum(1)).argmin(), :]
lrdu = confidence[ovr_bbox].argmin(0)
split_box = np.zeros_like(bbox)
for i in range(4):
split_box[i] = dets[ovr_bbox, :4][lrdu[i]][i]
min_bbox = dets[ovr_bbox, :4][lrdu, range(4)]
# keep_dets.append(merged)
#keep_dets.append(avg_bbox)
keep_dets.append(avg_std_bbox)
#keep_dets.append(min_bbox)
# keep_dets.append(bbox)
# keep_dets.append(split_box)
# keep_dets.append(dets[i])
if ax is None:
pass
else:
if scores[i] > score_thresh:
# print(dets[ovr_bbox, :4].shape, confidence[ovr_bbox].shape)
# bbox = dets[ovr_bbox, :4][((1/confidence[ovr_bbox]).sum(1)).argmax(), :]
ax.add_patch(
Rectangle((bbox[0], bbox[1]),
bbox[2] - bbox[0],
bbox[3] - bbox[1], fill=False,
edgecolor='blue', linewidth=3)
)
ax.text(bbox[0] + 3, bbox[1]+7,
'b',# bbox=dict(facecolor='blue', alpha=0.5),
fontsize=7, color='white')
# lrdu = confidence[ovr_bbox].argmin(0)
# bbox[0] = x1[lrdu[0]]
# bbox[1] = y1[lrdu[1]]
# bbox[2] = x2[lrdu[2]]
# bbox[3] = y2[lrdu[3]]
# ax.add_patch(
# Rectangle((bbox[0], bbox[1]),
# bbox[2] - bbox[0],
# bbox[3] - bbox[1], fill=False,
# edgecolor='green', linewidth=3)
# )
ax.add_patch(
Rectangle((merged[0], merged[1]),
merged[2] - merged[0],
merged[3] - merged[1], fill=False,
edgecolor='green', linewidth=3)
)
ax.add_patch(
Rectangle((dets[i][0], dets[i][1]),
dets[i][2] - dets[i][0],
dets[i][3] - dets[i][1], fill=False,
edgecolor='red', linewidth=3)
)
inds = np.where(ovr <= thresh)[0]
order = order[inds + 1]
if debug:
print((np.array(keep_dets), scores[keep, np.newaxis]))
if len(keep) == 0:
keep_dets = np.ndarray((0, 4))
else:
keep_dets = np.hstack((np.array(keep_dets), scores[keep, np.newaxis]))
# print(keep_dets)
return keep_dets
def avg_nms(dets, thresh):
pass
``` |
{
"source": "99611400/machineLearningDemoApp",
"score": 2
} |
#### File: detectFace/train/predict_test.py
```python
import os
import json
import time
import torch
import cv2
import numpy as np
from matplotlib import pyplot as plt
from build_utils import img_utils
from build_utils import torch_utils
from build_utils import utils
from models import Darknet
from draw_box_utils import draw_box
def main():
img_size = 512 # 必须是32的整数倍 [416, 512, 608]
cfg = "cfg/my_yolov3.cfg" # 改成生成的.cfg文件
weights = "F:\机器学习数据\yolov3_spp\weights\yolov3spp-12.pt".format(img_size) # 改成自己训练好的权重文件
json_path = "./data/pascal_voc_classes.json" # json标签文件
img_path = "F:/0_Parade_marchingband_1_15.jpg"
assert os.path.exists(cfg), "cfg file {} dose not exist.".format(cfg)
assert os.path.exists(weights), "weights file {} dose not exist.".format(weights)
assert os.path.exists(json_path), "json file {} dose not exist.".format(json_path)
assert os.path.exists(img_path), "image file {} dose not exist.".format(img_path)
json_file = open(json_path, 'r')
class_dict = json.load(json_file)
category_index = {v: k for k, v in class_dict.items()}
input_size = (img_size, img_size)
device = torch.device("cpu")
model = Darknet(cfg, img_size)
model.load_state_dict(torch.load(weights, map_location=device)["model"])
model.to(device)
model.eval()
with torch.no_grad():
# init
img = torch.zeros((1, 3, img_size, img_size), device=device)
model(img)
img_o = cv2.imread(img_path) # BGR
assert img_o is not None, "Image Not Found " + img_path
img = img_utils.letterbox(img_o, new_shape=input_size, auto=True, color=(0, 0, 0))[0]
# Convert
img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416
img = np.ascontiguousarray(img)
img = torch.from_numpy(img).to(device).float()
img /= 255.0 # scale (0, 255) to (0, 1)
img = img.unsqueeze(0) # add batch dimension
t1 = torch_utils.time_synchronized()
pred = model(img)[0] # only get inference result
t2 = torch_utils.time_synchronized()
print(t2 - t1)
pred = utils.non_max_suppression(pred, conf_thres=0.1, iou_thres=0.6, multi_label=True)[0]
t3 = time.time()
print(t3 - t2)
if pred is None:
print("No target detected.")
exit(0)
# process detections
pred[:, :4] = utils.scale_coords(img.shape[2:], pred[:, :4], img_o.shape).round()
print(pred.shape)
bboxes = pred[:, :4].detach().cpu().numpy()
scores = pred[:, 4].detach().cpu().numpy()
classes = pred[:, 5].detach().cpu().numpy().astype(np.int) + 1
cv2.namedWindow('input_image', 0)
cv2.resizeWindow('input_image', 600, 800)
print(bboxes.tolist())
draw_1 = img_o
for ele in range(len(bboxes.tolist())) :
x = int(bboxes.tolist()[ele][0])
y = int(bboxes.tolist()[ele][1])
x1 = int(bboxes.tolist()[ele][2])
y1 = int(bboxes.tolist()[ele][3])
draw_1 =cv2.rectangle(draw_1, (x,y), (x1,y1), (0, 0,255),1)
cv2.imshow("input_image",draw_1)
cv2.waitKey(0)
if __name__ == "__main__":
main()
```
#### File: train/train_utils/train_eval_utils.py
```python
import sys
from torch.cuda import amp
import torch.nn.functional as F
from build_utils.utils import *
from train_utils.coco_eval import CocoEvaluator
from train_utils.coco_utils import get_coco_api_from_dataset
import train_utils.distributed_utils as utils
def train_one_epoch(model, optimizer, data_loader, device, epoch,
print_freq, accumulate, img_size,
grid_min, grid_max, gs,
multi_scale=False, warmup=False):
model.train()
metric_logger = utils.MetricLogger(delimiter=" ")
metric_logger.add_meter('lr', utils.SmoothedValue(window_size=1, fmt='{value:.6f}'))
header = 'Epoch: [{}]'.format(epoch)
lr_scheduler = None
if epoch == 0 and warmup is True: # 当训练第一轮（epoch=0）时，启用warmup训练方式，可理解为热身训练
warmup_factor = 1.0 / 1000
warmup_iters = min(1000, len(data_loader) - 1)
lr_scheduler = utils.warmup_lr_scheduler(optimizer, warmup_iters, warmup_factor)
accumulate = 1
enable_amp = True if "cuda" in device.type else False
scaler = amp.GradScaler(enabled=enable_amp)
mloss = torch.zeros(4).to(device) # mean losses
now_lr = 0.
nb = len(data_loader) # number of batches
# imgs: [batch_size, 3, img_size, img_size]
# targets: [num_obj, 6] , that number 6 means -> (img_index, obj_index, x, y, w, h)
# paths: list of img path
for i, (imgs, targets, paths, _, _) in enumerate(metric_logger.log_every(data_loader, print_freq, header)):
# ni 统计从epoch0开始的所有batch数
ni = i + nb * epoch # number integrated batches (since train start)
imgs = imgs.to(device).float() / 255.0 # uint8 to float32, 0 - 255 to 0.0 - 1.0
targets = targets.to(device)
# Multi-Scale
if multi_scale:
# 每训练64张图片，就随机修改一次输入图片大小，
# 由于label已转为相对坐标，故缩放图片不影响label的值
if ni % accumulate == 0: # adjust img_size (67% - 150%) every 1 batch
# 在给定最大最小输入尺寸范围内随机选取一个size(size为32的整数倍)
img_size = random.randrange(grid_min, grid_max + 1) * gs
sf = img_size / max(imgs.shape[2:]) # scale factor
# 如果图片最大边长不等于img_size, 则缩放图片，并将长和宽调整到32的整数倍
if sf != 1:
# gs: (pixels) grid size
ns = [math.ceil(x * sf / gs) * gs for x in imgs.shape[2:]] # new shape (stretched to 32-multiple)
imgs = F.interpolate(imgs, size=ns, mode='bilinear', align_corners=False)
# 混合精度训练上下文管理器，如果在CPU环境中不起任何作用
with amp.autocast(enabled=enable_amp):
pred = model(imgs)
# loss
loss_dict = compute_loss(pred, targets, model)
losses = sum(loss for loss in loss_dict.values())
# reduce losses over all GPUs for logging purpose
loss_dict_reduced = utils.reduce_dict(loss_dict)
losses_reduced = sum(loss for loss in loss_dict_reduced.values())
loss_items = torch.cat((loss_dict_reduced["box_loss"],
loss_dict_reduced["obj_loss"],
loss_dict_reduced["class_loss"],
losses_reduced)).detach()
mloss = (mloss * i + loss_items) / (i + 1) # update mean losses
if not torch.isfinite(losses_reduced):
print('WARNING: non-finite loss, ending training ', loss_dict_reduced)
print("training image path: {}".format(",".join(paths)))
sys.exit(1)
losses *= 1. / accumulate # scale loss
# backward
scaler.scale(losses).backward()
# optimize
# 每训练64张图片更新一次权重
if ni % accumulate == 0:
scaler.step(optimizer)
scaler.update()
optimizer.zero_grad()
metric_logger.update(loss=losses_reduced, **loss_dict_reduced)
now_lr = optimizer.param_groups[0]["lr"]
metric_logger.update(lr=now_lr)
if ni % accumulate == 0 and lr_scheduler is not None: # 第一轮使用warmup训练方式
lr_scheduler.step()
return mloss, now_lr
@torch.no_grad()
def evaluate(model, data_loader, coco=None, device=None):
n_threads = torch.get_num_threads()
# FIXME remove this and make paste_masks_in_image run on the GPU
torch.set_num_threads(1)
cpu_device = torch.device("cpu")
model.eval()
metric_logger = utils.MetricLogger(delimiter=" ")
header = "Test: "
if coco is None:
coco = get_coco_api_from_dataset(data_loader.dataset)
iou_types = _get_iou_types(model)
coco_evaluator = CocoEvaluator(coco, iou_types)
for imgs, targets, paths, shapes, img_index in metric_logger.log_every(data_loader, 100, header):
imgs = imgs.to(device).float() / 255.0 # uint8 to float32, 0 - 255 to 0.0 - 1.0
# targets = targets.to(device)
# 当使用CPU时，跳过GPU相关指令
if device != torch.device("cpu"):
torch.cuda.synchronize(device)
model_time = time.time()
pred = model(imgs)[0] # only get inference result
pred = non_max_suppression(pred, conf_thres=0.01, iou_thres=0.6, multi_label=False)
outputs = []
for index, p in enumerate(pred):
if p is None:
p = torch.empty((0, 6), device=cpu_device)
boxes = torch.empty((0, 4), device=cpu_device)
else:
# xmin, ymin, xmax, ymax
boxes = p[:, :4]
# shapes: (h0, w0), ((h / h0, w / w0), pad)
# 将boxes信息还原回原图尺度，这样计算的mAP才是准确的
boxes = scale_coords(imgs[index].shape[1:], boxes, shapes[index][0]).round()
# 注意这里传入的boxes格式必须是xmin, ymin, xmax, ymax，且为绝对坐标
info = {"boxes": boxes.to(cpu_device),
"labels": p[:, 5].to(device=cpu_device, dtype=torch.int64),
"scores": p[:, 4].to(cpu_device)}
outputs.append(info)
model_time = time.time() - model_time
res = {img_id: output for img_id, output in zip(img_index, outputs)}
evaluator_time = time.time()
coco_evaluator.update(res)
evaluator_time = time.time() - evaluator_time
metric_logger.update(model_time=model_time, evaluator_time=evaluator_time)
# gather the stats from all processes
metric_logger.synchronize_between_processes()
print("Averaged stats:", metric_logger)
coco_evaluator.synchronize_between_processes()
# accumulate predictions from all images
coco_evaluator.accumulate()
coco_evaluator.summarize()
torch.set_num_threads(n_threads)
result_info = coco_evaluator.coco_eval[iou_types[0]].stats.tolist() # numpy to list
return result_info
def _get_iou_types(model):
model_without_ddp = model
if isinstance(model, torch.nn.parallel.DistributedDataParallel):
model_without_ddp = model.module
iou_types = ["bbox"]
return iou_types
``` |
{
"source": "99611400/SdustDataBaseExperiment",
"score": 3
} |
#### File: src/entity/Table.py
```python
import time # 引入time模块
import pandas as pd
import re
import sqlparse
attributeNameArray = ['tableName', 'createTime', 'lastModifyTime', 'owner', 'rowNumber', 'columnNumber',
'primaryKey', 'uniqueKey', 'foreignKey', 'notNullColumn', 'indexColumn', 'columnDataType']
remarksList = ['表名', '创建时间', '最后修改时间', '所有者', '数据行数', '字段数', '主键',
'唯一键', '外键', '不能为空字段', '索引字段', '数据类型']
# 这个函数是自己的拼接函数 str2TableClass 中会调用
def myConcat(array: list, separator: str):
temp = ""
for i in range(0, len(array)):
temp += array[i] + separator
temp = temp[:-1]
return temp
# 这个函数用来根据正则解析传入的create table指令 数据分解出来 tableinit 会调用
def str2TableClass(tempStr: str, tableName: str):
tempStr = re.search(r"[(](.*)[)]", tempStr).group(1) # 拿到括号里的内容
primaryKey = ""
uniqueKey = ""
foreignKey = ""
# primary key部分
p1 = re.search(r"primary key(.*?)[(](.*?)[)]", tempStr)
# print(p1.group(0))
# print(p1.group(2) + " 主键值")
if p1 is not None:
primaryKey = p1.group(2).strip()
primaryKeyList = primaryKey.split(",")
for index, ele in enumerate(primaryKeyList):
primaryKeyList[index] = ele.strip()
primaryKey = myConcat(primaryKeyList, ",")
tempStr = re.sub(r"primary key(.*?)[(](.*?)[)]", "", tempStr) # 删除primary key 防止影响到后边内容
# unique key部分
p2 = re.search(r"unique key(.*?)[(](.*?)[)]", tempStr)
# print(p2.group(0))
# print(p2.group(2) + " 唯一键值")
if p2 is not None:
uniqueKey = p2.group(2)
tempStr = re.sub(r"unique key(.*?)[(](.*?)[)]", "", tempStr)
# foreign key部分 这里其实有bug foreign key 可以有多个 但是我这里 search方法只能找到一个
p3 = re.search(r"foreign key(.*?)[(](.*?)[)](.*?)references(.*?)[(](.*?)[)]", tempStr)
# print(p2.group(0))
# print(p2.group(2) + " 当前表中值")
# print(p2.group(4).strip() + " 被参考的表名")
# print(p2.group(5).strip() + " 外表的键")
if p3 is not None:
foreignKey = p3.group(2) + "|" + p3.group(4).strip() + "|" + p3.group(5).strip()
tempStr = re.sub(r"foreign key(.*?)[(](.*?)[)](.*?)references(.*?)[(](.*?)[)]", "", tempStr)
# 分解 剩下的 这样里边全都是类似 school varchar not null 、 age int 或者是空格 的字符串
array = tempStr.split(",")
tempArray = [] # 用于临时记录去除空格的形如 school varchar not null 这样的
columnCount = 0 # 用来计数有多少个字段 因为存在全是空格的字符串
for ele in array:
if not ele.isspace(): # 自带函数 当全是空格的时候 为 true
columnCount += 1 # 用来计数有多少个字段 因为存在全是空格的字符串
tempArray.append(ele.strip()) # 去除前后两边的空格
columnNameArray = [] # 字段名数组
columnDataTypeArray = [] # 字段类型数组
notNullColumn = [] # 设置了不空的字段
for ele in tempArray:
p = re.search(r"(.*?)not( +)null", ele)
if p is None:
arrayAA = re.split(r" +", ele.strip())
else:
arrayAA = re.split(r" +", p.group(1).strip())
notNullColumn.append(arrayAA[0])
# 将提取出来的 字段名 和 字段类型 添加进去
columnNameArray.append(arrayAA[0])
columnDataTypeArray.append(arrayAA[1])
uniqueKeyList = uniqueKey.strip().split(",")
uniqueKey = myConcat(uniqueKeyList, ",")
# myConcat是自己写的函数 将notNull的column拼接起来 形如 school,home
notNullColumnStr = myConcat(notNullColumn, ",")
notNullColumnStr += "," + primaryKey + "," +uniqueKey # 加上主键也不能为空
# 拼接成形如 id#int,name#varchar,age#int,school#varchar,home#varchar,aad#varchar 的字符串
# 前边是 字段名称 后边是字段类型 两者用#分割 不同字段之间用, 分割
temp = ""
for i in range(0, len(columnNameArray)):
temp += columnNameArray[i] + "#" + columnDataTypeArray[i] + ","
columnDataTypeArrayStr = temp[:-1]
# 构造一个类 很好用
print(tempStr)
tableTemp = Table(tableName=tableName,
createTime=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
lastModifyTime=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
owner="root", rowNumber=0, columnNumber=columnCount,
primaryKey=primaryKey, uniqueKey=uniqueKey, foreignKey=foreignKey,
notNullColumn=notNullColumnStr, indexColumn="", columnDataType=columnDataTypeArrayStr)
# 将一些信息存入类中 后边还会用
tableTemp.columnNameArray = columnNameArray
tableTemp.columnDataTypeArray = columnDataTypeArray
return tableTemp
# 用来进行表的初始化 主要做的就是提取数据 然后把相关信息写入excel表中去
def tableInit(databaseLocation: str, databaseName: str, currentIndex: int, tokens):
for index in range(currentIndex, len(tokens)):
while str(tokens[index].ttype) != "None":
index += 1
tableName = str(tokens[index].tokens[0])
tempStr = str(tokens[index])
break
# 引入writer 防止覆盖 这样可以向两个工作表(sheet)中写入信息
src = databaseLocation + "\\" + databaseName.upper() + "\\" + tableName + ".xlsx"
writer = pd.ExcelWriter(src, engine='openpyxl')
initTableAttributeObject = str2TableClass(tempStr, tableName)
tempArray = list(range(1, len(attributeNameArray) + 1)) # 索引列需要
s1 = pd.Series(tempArray, index=tempArray, name="index") # 索引列 一共需要12个属性
s2 = pd.Series(attributeNameArray, index=tempArray, name="attribute") # 属性名列
s3 = pd.Series(initTableAttributeObject.toArray(), index=tempArray, name="value") # 这个是最麻烦的 注意调用了 Table类的toArray方法
s4 = pd.Series(remarksList, index=tempArray, name="备注") # 备注列 这个是写死的
attributeDf = pd.DataFrame({s1.name: s1, s2.name: s2, s3.name: s3, s4.name: s4}) # 插入4列
attributeDf = attributeDf.set_index("index") # 设置索引
dataDf = pd.DataFrame(columns=initTableAttributeObject.columnNameArray)
# 将内容写回excel表格
attributeDf.to_excel(writer, sheet_name="attribute")
dataDf.to_excel(writer, sheet_name="data", index=False)
writer.save()
writer.close()
return tableName # 返回创建表的名字
def checkSafety(attributeDf, dataDf, aa: list, dic):
primaryKeyList: list = attributeDf["value"].at[6].strip().split(",")
uniqueKeyList: list = attributeDf["value"].at[7].strip().split(",")
notNullStrArray: list = attributeDf["value"].at[9].strip().split(",")
error: str = ""
# 检查 非空约束 primary key
# print(notNullStrArray)
for ele in notNullStrArray:
if ele not in aa:
# print("字段 " + ele + " 不能为空，插入失败")
return "字段 " + ele + " 不能为空，插入失败"
# 主键不能重复
for ele in primaryKeyList:
dataDf = dataDf.loc[dataDf[ele].apply(lambda xx: str(xx) == dic[ele])]
# print(dataDf)
if dataDf.empty is False:
# print("主键重复，请重试")
return "主键重复，请重试"
return error
# 唯一键不能重复
# for ele in uniqueKeyList:
# temp = dataDf.loc[dataDf[ele].apply(lambda xx: str(xx) == dic[ele])]
# 这个函数是进行完整性校验无误后 将数据写入到excel表中 tableInsert会调用
def judgeAndInsert(src: str, aa: list, bb: list, all: list):
# 注意这里的地址 还是相对于main.py 这个文件而言的 而不是相对于 本文件Table.py
# print(aa)
# print(bb)
# aa 是需要插入列表字段列表 bb是值
writer = pd.ExcelWriter(src)
dic = {}
for index, ele in enumerate(bb):
dic[aa[index]] = ele
attributeDf = pd.read_excel(writer, sheet_name="attribute")
# print(attributeDf)
dataDf = pd.read_excel(writer, sheet_name="data", usecols=all)
# print(dataDf)
error = checkSafety(attributeDf, dataDf, aa, dic)
if error != "":
print(error)
return
dataDf = dataDf.append(dic, ignore_index=True)
attributeDf["value"].at[2] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) # 更新时间
attributeDf["value"].at[4] += 1 # 增加行数
attributeDf.to_excel(writer, sheet_name="attribute", index=False)
dataDf.to_excel(writer, sheet_name="data", index=False)
writer.save()
writer.close()
print("插入成功")
# 提取关键词 比如 id > 20 key是 id algebraicSymbol 是 > 20是 value
def getDataframeByRequirement(key, value, algebraicSymbol, dataframe: pd.DataFrame):
#print(key)
#print(value)
#print(algebraicSymbol)
tempDataFrame = None
if algebraicSymbol == ">":
tempDataFrame = dataframe.loc[dataframe[key].apply(lambda xx: xx > int(value))]
if algebraicSymbol == ">=":
tempDataFrame = dataframe.loc[dataframe[key].apply(lambda xx: xx >= int(value))]
if algebraicSymbol == "<":
tempDataFrame = dataframe.loc[dataframe[key].apply(lambda xx: xx < int(value))]
if algebraicSymbol == "<=":
tempDataFrame = dataframe.loc[dataframe[key].apply(lambda xx: xx <= int(value))]
if algebraicSymbol == "=":
tempDataFrame = dataframe.loc[dataframe[key].apply(lambda xx: str(xx) == str(value))]
if algebraicSymbol == "!=":
tempDataFrame = dataframe.loc[dataframe[key].apply(lambda xx: str(xx) != str(value))]
return tempDataFrame
# 根据表达式 得到一个字符串数组 里边有 tempList = [key, value, algebraicSymbol]
def getKeyValueAndAlgebraicSymbol(expression: str):
key = ""
value = ""
algebraicSymbol = ""
if "=" in expression:
equalIndex = expression.index("=")
if expression[equalIndex - 1] == "!":
algebraicSymbol = "!="
elif expression[equalIndex - 1] == ">":
algebraicSymbol = ">="
elif expression[equalIndex - 1] == "<":
algebraicSymbol = "<="
else:
algebraicSymbol = "="
else:
if ">" in expression:
algebraicSymbol = ">"
elif "<" in expression:
algebraicSymbol = "<"
key = (expression.split(algebraicSymbol))[0].strip()
value = (expression.split(algebraicSymbol))[1].strip()
tempList = [key, value, algebraicSymbol]
return tempList
# 根据where条件 拿到dataframe数据
def parseWhereGetDf(src: str, whereStr: str):
dataDf = pd.read_excel(src, sheet_name="data")
# strTemp3 = "sno< 20 and sno > 5 and sno >=10 and sno > 17 or sno < 12"
# strTemp4 = "sno > 17 or sno < 12 "
noOrDataDf = dataDf
if whereStr == "":
# print(dataDf)
return dataDf
else:
andSplitStrArray = re.split(r" and ", whereStr)
orList = []
for ele in andSplitStrArray:
if " or " in ele:
orSplitStrArray = re.split(r" or ", ele)
orDfList = []
# 拿到所有的or 中的表达式 做一个交集
for factor in orSplitStrArray:
tempArray = getKeyValueAndAlgebraicSymbol(factor)
OrDataDf = getDataframeByRequirement(tempArray[0], tempArray[1], tempArray[2], dataDf)
orDfList.append(OrDataDf)
oneTempOrDf = orDfList[0]
# 取所有的并集 用or隔开的表达式的并集
for element in orDfList:
oneTempOrDf = pd.merge(oneTempOrDf, element, how="outer") # 取并集
orList.append(oneTempOrDf)
else:
tempArray = getKeyValueAndAlgebraicSymbol(ele)
key = tempArray[0]
value = tempArray[1]
algebraicSymbol = tempArray[2]
noOrDataDf = getDataframeByRequirement(key, value, algebraicSymbol, noOrDataDf)
finallyDf = noOrDataDf
# 举个例子 sno< 20 and sno > 5 and sno >=10 and sno > 17 or sno < 12 and sno > 17 or sno < 12
# orlist中有 2个元素 最终下方函数是对三个dataframe做交集
for ele in orList:
finallyDf = pd.merge(finallyDf, ele, how="inner")
# print(finallyDeleteDf)
return finallyDf
# 外界会调用这个全局函数
def tableInsert(currentDatabase, token):
# print(token) # INSERT INTO student (name, age) value('jack', 30)
tokenStr = "" # 直接提取出来所有的sql指令 进行正则匹配
for ele in token:
tokenStr += ele.normalized
columnNameArray = [] #
valueArray = []
allArray = []
src = ""
p1 = re.search(r'INSERT( +)INTO( +)(.*?)( +)[(](.*?)[)]( +)value[(](.*?)[)]', tokenStr)
if p1 is not None:
# print(p1.group(0)) # INSERT INTO student (name, age) value('jack', 30)
# print(p1.group(3)) # student
tableName = p1.group(3)
src = "databases/" + currentDatabase.upper() + "/" + tableName + ".xlsx"
# 求出所有属性 会用到
attributeDf = pd.read_excel(src, sheet_name="attribute")
array = str(attributeDf["value"].at[11]).split(",")
for ele in array:
allArray.append(ele.split("#")[0])
# print(p1.group(5)) # name, age
columnNameArray = p1.group(5).strip().split(",")
for index in range(0, len(columnNameArray)):
columnNameArray[index] = columnNameArray[index].strip()
# print(p1.group(7)) # 'jack', 30
valueArray = p1.group(7).strip().split(",")
for index in range(0, len(valueArray)):
valueArray[index] = valueArray[index].strip().strip("'")
print(valueArray)
# print("p1")
p2 = re.search(r'INSERT( +)INTO( +)(.*?)( +)values[(](.*?)[)]', tokenStr)
if p2 is not None:
# print(p2.group(0)) # INSERT INTO my_teacher values('lilei',28)
# print(p2.group(3)) # student
tableName = p2.group(3)
src = "databases/" + currentDatabase.upper() + "/" + tableName + ".xlsx"
attributeDf = pd.read_excel(src, sheet_name="attribute")
array = str(attributeDf["value"].at[11]).split(",")
for ele in array:
allArray.append(ele.split("#")[0])
columnNameArray = allArray
valueArray = p2.group(5).strip().split(",")
for index in range(0, len(valueArray)):
valueArray[index] = valueArray[index].strip().strip("'")
# 调用插入函数 传入 表的路径 字段名称数组 值数组 所有字段数组
judgeAndInsert(src, columnNameArray, valueArray, allArray)
def handleDeleteInExcel(src: str, whereStr: str):
# print(src)
# print(whereStr)
# 读取数据
writer = pd.ExcelWriter(src)
attributeDf = pd.read_excel(writer, sheet_name="attribute")
dataDf = pd.read_excel(writer, sheet_name="data")
# print(attributeDf)
# print(dataDf)
if whereStr == "":
# 修改数据
dataDf.drop(dataDf.index, inplace=True) # 删除所有数据
attributeDf["value"].at[4] = 0 # 把rowNumber数据行改成0 代表里面没有数据
else:
# print(whereStr)
# 提取出关键信息 进行筛选
tempDf = parseWhereGetDf(src=src, whereStr=whereStr)
# print(dataDf)
print("删除了{}行".format(len(tempDf)))
# print(tempDf)
dataDf = dataDf.append(tempDf)
dataDf = dataDf.drop_duplicates(subset=dataDf.columns, keep=False)
# print(dataDf)
attributeDf["value"].at[4] -= len(tempDf) # 减少行数
# 写回数据
attributeDf.to_excel(writer, sheet_name="attribute", index=False)
dataDf.to_excel(writer, sheet_name="data", index=False)
writer.save()
writer.close()
print("删除成功")
def tableDelete(currentDatabase: str, token):
tokenStr = "" # 直接提取出来所有的sql指令 进行正则匹配
for ele in token:
tokenStr += ele.normalized
# print(tokenStr)
# 去除多余的空格
tokenStr = re.sub(r" +", " ", tokenStr)
tableName: str = ""
src: str = ""
whereStr: str = ""
# 两个分支 如果存在
if "where" in tokenStr:
p1 = re.search(r'DELETE FROM (.*?) where (.*)', tokenStr)
# print(p1.group(0)) # 全语句 DELETE FROM student where home != 'shandong' or id = 30
# print(p1.group(1)) # 表名 student
# print(p1.group(2)) # 条件 home != 'shandong' or id = 30
tableName = p1.group(1).strip()
whereStr = p1.group(2).strip()
else:
p2 = re.search(r'DELETE FROM (.*)', tokenStr)
# print(p2.group(0)) # DELETE FROM student
# print(p2.group(1)) # student
tableName = p2.group(1).strip()
whereStr = ""
print("你真的想要删除 {} 表中所有数据吗(yes/no)".format(tableName))
if "n" in input():
return
src = "databases/" + currentDatabase.upper() + "/" + tableName + ".xlsx"
handleDeleteInExcel(src, whereStr)
# 处理orderby字句的 order by id asc, name desc; 返回列表如右侧 [['id', 'name'], [True, False]]
def getListOfOrderBy(orderByStr: str):
# print(orderByStr)
orderByKeyList = []
orderByValueList = []
tempArray1 = orderByStr.split(",")
for ele in tempArray1:
tempArray2 = ele.split()
orderByKeyList.append(tempArray2[0].strip())
if "asc" == tempArray2[1].strip():
orderByValueList.append(True)
else:
orderByValueList.append(False)
return [orderByKeyList, orderByValueList]
def tableSelect(currentDatabase: str, token):
tokenStr = "" # 直接提取出来所有的sql指令 进行正则匹配
for ele in token:
tokenStr += ele.normalized
# 去除多余的空格
tokenStr = re.sub(r" +", " ", tokenStr)
tableName: str = ""
src: str = ""
whereStr: str = ""
orderByList = None
columnStr = ""
columnStrList = []
# 处理 order by语句
if "ORDER BY" in tokenStr:
p3 = re.search("ORDER BY (.*)", tokenStr)
# print(p3.group(0))
# print(p3.group(1))
orderByStr = p3.group(1).strip()
orderByList = getListOfOrderBy(orderByStr)
# print(orderByList)
tokenStr = re.sub(r" ORDER BY (.*)", "", tokenStr)
# 正则区分出表名
if "where" not in tokenStr:
p1 = re.search(r'SELECT (.*?) FROM (.*)', tokenStr)
# print(p1.group(0)) # SELECT * FROM student
# print(p1.group(1)) # *
columnStr = p1.group(1)
# print(p1.group(2)) # student
tableName = p1.group(2)
else:
p2 = re.search(r'SELECT (.*?) FROM (.*?) where (.*)', tokenStr)
# print(p2.group(0)) # SELECT * FROM student where sno< 20 and sno > 5 and sno >=10 and sno > 17 or sno < 12
# print(p2.group(1)) # *
columnStr = p2.group(1)
# print(p2.group(2)) # student
# print(p2.group(3)) # sno< 20 and sno > 5 and sno >=10 and sno > 17 or sno < 12
tableName = p2.group(2)
whereStr = p2.group(3)
# 拿到要显示的字段列表
if columnStr != "*":
for ele in columnStr.split(","):
columnStrList.append(ele.strip())
# print(columnStrList)
src = "databases/" + currentDatabase.upper() + "/" + tableName + ".xlsx"
targetDataframe = parseWhereGetDf(src, whereStr)
if orderByList is not None:
targetDataframe.sort_values(by=orderByList[0], inplace=True, ascending=orderByList[1])
print(targetDataframe[columnStrList if columnStr!="*" else targetDataframe.columns])
# name=姓名测试,id=1
def getListOfUpdateSet(updateStr: str):
# print(updateStr)
updateKeyList = []
updateValueList = []
tempArray1 = updateStr.split(",")
for ele in tempArray1:
tempArray2 = ele.split("=")
updateKeyList.append(tempArray2[0].strip())
updateValueList.append(tempArray2[1].strip())
return [updateKeyList, updateValueList]
def handleUpdateInExcel(src: str, whereStr: str, modifyStr: str):
writer = pd.ExcelWriter(src)
attributeDf = pd.read_excel(writer, sheet_name="attribute")
# 先删除然后再插入
tempDataframe: pd.DataFrame = parseWhereGetDf(src, whereStr)
# print(tempDataframe)
handleDeleteInExcel(src, whereStr) # 需要进行删完再读
dataDf: pd.DataFrame = pd.read_excel(writer, sheet_name="data")
updateList = getListOfUpdateSet(modifyStr)
# print(updateList) # [['name', 'id'], ['姓名测试', '1']]
primaryKeyStr: str = attributeDf["value"].at[6].strip() # 读出主键
primaryKeyList = primaryKeyStr.strip().split(",")
for index, ele in enumerate(primaryKeyList):
primaryKeyList[index] = ele.strip()
backUpTempDataframe = tempDataframe.copy(deep=True)
# print(primaryKeyList) # 主键的列表
for index, ele in enumerate(updateList[0]):
tempDataframe[ele] = updateList[1][index]
dataTempDf = pd.concat([tempDataframe, dataDf], join="outer", ignore_index=True) # 取并集
dataTempDf.to_excel("./temp.xlsx", index=False)
dataTempDf = pd.read_excel("./temp.xlsx")
flag = dataTempDf[primaryKeyList].duplicated()
# 判断是否主键是否重复 如果重复 拒绝修改
if flag.any() == True:
print("主键重复 更新失败")
dataDf = dataDf.append(backUpTempDataframe)
else:
print("更新成功")
dataDf = dataTempDf
dataDf.sort_values(by=primaryKeyList) # 重新排序
attributeDf.to_excel(writer, sheet_name="attribute", index=False)
dataDf.to_excel(writer, sheet_name="data", index=False)
writer.save()
writer.close()
def tableUpdate(currentDatabase: str, token):
tokenStr = "" # 直接提取出来所有的sql指令 进行正则匹配
for ele in token:
tokenStr += ele.normalized
# 去除多余的空格
tokenStr = re.sub(r" +", " ", tokenStr)
tableName: str = ""
src: str = ""
whereStr: str = ""
modifyStr = ""
modifyList: list = []
if "where" not in tokenStr:
p2 = re.search(r'UPDATE (.*?) SET (.*)', tokenStr)
# print(p2.group(0)) # UPDATE my_teacher SET name=lucy
# print(p2.group(1)) # my_teacher
tableName = p2.group(1).strip()
# print(p2.group(2)) # name=lucy
modifyStr = p2.group(2).strip()
else:
p1 = re.search(r'UPDATE (.*?) SET (.*?) where (.*)', tokenStr)
# print(p1.group(0)) # UPDATE my_teacher SET name=lucy where age=30
# print(p1.group(1)) # my_teacher
tableName = p1.group(1).strip()
# print(p1.group(2)) # name=lucy
modifyStr = p1.group(2).strip()
# print(p1.group(3)) # age=30
whereStr = p1.group(3).strip()
src = "databases/" + currentDatabase.upper() + "/" + tableName + ".xlsx"
handleUpdateInExcel(src, whereStr, modifyStr)
class Table:
tableName: str = ""
createTime: time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
lastModifyTime: time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
owner: str = ""
rowNumber: int = 0
columnNumber: int = 0
primaryKey: str = ""
uniqueKey: str = ""
foreignKey: str = ""
notNullColumn: str = ""
indexColumn: str = ""
columnDataType: str = ""
columnDataTypeArray = []
columnNameArray = []
def __init__(self, tableName: str, createTime: time,
lastModifyTime: time, owner: str,
rowNumber: int, columnNumber: int,
primaryKey: str, uniqueKey: str,
foreignKey: str, notNullColumn: str,
indexColumn: str, columnDataType: str):
self.tableName = tableName
self.createTime = createTime
self.lastModifyTime = lastModifyTime
self.owner = owner
self.rowNumber = rowNumber
self.columnNumber = columnNumber
self.primaryKey = primaryKey
self.uniqueKey = uniqueKey
self.foreignKey = foreignKey
self.notNullColumn = notNullColumn
self.indexColumn = indexColumn
self.columnDataType = columnDataType
def toArray(self):
tempArray = [self.tableName, self.createTime,
self.lastModifyTime, self.owner,
self.rowNumber, self.columnNumber,
self.primaryKey, self.uniqueKey,
self.foreignKey, self.notNullColumn,
self.indexColumn, self.columnDataType]
return tempArray
```
#### File: src/fake/fake.py
```python
import json
# print("yhnsql>", end="")
# strTemp = input()
# print("回收授权成功")
# file = open("abc").read()
# print(file)
# print("yhnsql>", end="")
# strTemp = input()
# print("创建成功")
# print("视图abc为 : select sno,sname from student where sno >= 2012")
print("yhnsql>", end="")
strTemp = input()
# print("student表的索引情况如下")
# print("默认为主键索引 sno,sname")
# print("sno sname age school home")
# print("2013 张三2 15 school99 shandong3")
# print("2014 张三3 12 school1 shandong2")
# print("9999 张三1 19 测试学校 shandong6")
# create unique index studentSno on student(sno);
print("student 表上的索引 studentSno 创建成功")
#
# def grant(tableName)
# file = open("../config/Login.json")
# jsonStr = json.load(file) # 解析json
#
# print(jsonStr)
#
# jsonStr
``` |
{
"source": "996268132/NodeGraphQt",
"score": 3
} |
#### File: NodeGraphQt/AITreeEditor/AINodes.py
```python
import sys
sys.path.append("..")
from PySide6 import QtCore, QtGui, QtWidgets
import sys
sys.path.append("..")
from NodeGraphQt import (NodeGraph,
BaseNode,
BackdropNode,
PropertiesBinWidget,
NodeTreeWidget,
setup_context_menu)
# import example nodes from the "example_nodes" package
from example_nodes import basic_nodes, widget_nodes
def draw_triangle_port(painter, rect, info):
"""
Custom paint function for drawing a Triangle shaped port.
Args:
painter (QtGui.QPainter): painter object.
rect (QtCore.QRectF): port rect used to describe parameters
needed to draw.
info (dict): information describing the ports current state.
{
'port_type': 'in',
'color': (0, 0, 0),
'border_color': (255, 255, 255),
'multi_connection': False,
'connected': False,
'hovered': False,
}
"""
painter.save()
size = int(rect.height() / 2)
triangle = QtGui.QPolygonF()
triangle.append(QtCore.QPointF(-size, size))
triangle.append(QtCore.QPointF(0.0, -size))
triangle.append(QtCore.QPointF(size, size))
transform = QtGui.QTransform()
transform.translate(rect.center().x(), rect.center().y())
port_poly = transform.map(triangle)
# mouse over port color.
if info['hovered']:
color = QtGui.QColor(14, 45, 59)
border_color = QtGui.QColor(136, 255, 35)
# port connected color.
elif info['connected']:
color = QtGui.QColor(195, 60, 60)
border_color = QtGui.QColor(200, 130, 70)
# default port color
else:
color = QtGui.QColor(*info['color'])
border_color = QtGui.QColor(*info['border_color'])
pen = QtGui.QPen(border_color, 1.8)
pen.setJoinStyle(QtCore.Qt.MiterJoin)
painter.setPen(pen)
painter.setBrush(color)
painter.drawPolygon(port_poly)
painter.restore()
def draw_square_port(painter, rect, info):
"""
Custom paint function for drawing a Square shaped port.
Args:
painter (QtGui.QPainter): painter object.
rect (QtCore.QRectF): port rect used to describe parameters
needed to draw.
info (dict): information describing the ports current state.
{
'port_type': 'in',
'color': (0, 0, 0),
'border_color': (255, 255, 255),
'multi_connection': False,
'connected': False,
'hovered': False,
}
"""
painter.save()
# mouse over port color.
if info['hovered']:
color = QtGui.QColor(14, 45, 59)
border_color = QtGui.QColor(136, 255, 35, 255)
# port connected color.
elif info['connected']:
color = QtGui.QColor(195, 60, 60)
border_color = QtGui.QColor(200, 130, 70)
# default port color
else:
color = QtGui.QColor(*info['color'])
border_color = QtGui.QColor(*info['border_color'])
pen = QtGui.QPen(border_color, 1.8)
pen.setJoinStyle(QtCore.Qt.MiterJoin)
painter.setPen(pen)
painter.setBrush(color)
painter.drawRect(rect)
painter.restore()
graph = None
def init_ai_node_menu(graph, nodes):
root_menu = graph.get_context_menu('graph')
node_menu = root_menu.add_menu('&Node')
#node_menu = graph.context_nodes_menu()
for node in nodes:
node_menu.add_command(node.NODE_NAME, create_ai_node,node.NODE_NAME)
#node_menu.add_command(node.NODE_NAME, create_node, node_class=node)
def create_ai_node(graph,action):
print(action.text())
graph.create_node('com.chantasticvfx.' + action.text())
class GAINode(BaseNode):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GAINode'
def __init__(self):
super(GAINode, self).__init__()
self.set_color(25, 58, 51)
#self.add_input('SkillID', color=(200, 10, 0))
self.add_input('TitleIn', multi_input=False, display_name=False,
color=(255, 10, 0), data_type='Title', painter_func=draw_square_port)
self.add_output('TitleOut', multi_output=True, display_name=False,
color=(255, 10, 0), data_type='Title', painter_func=draw_square_port)
class GAIBase(BaseNode):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GAIBase'
def __init__(self):
super(GAIBase, self).__init__()
self.set_color(25, 58, 51)
self.add_output('TitleOut', multi_output=True, display_name=False,
color=(60, 255, 0), data_type='Title', painter_func=draw_square_port)
class GRoot(GAIBase):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GRoot'
def __init__(self):
super(GRoot, self).__init__()
self.set_color(58, 255, 51)
class GStage(GAINode):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GStage'
def __init__(self):
super(GStage, self).__init__()
self.set_color(25, 58, 51)
self.add_text_input("condition", 'stage condition', tab='widgets')
class GParaller(GAINode):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GParaller'
def __init__(self):
super(GParaller, self).__init__()
self.set_color(25, 58, 51)
class GSelector(GAINode):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GSelector'
def __init__(self):
super(GSelector, self).__init__()
self.set_color(25, 58, 51)
class GRandomor(GAINode):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GRandomor'
def __init__(self):
super(GRandomor, self).__init__()
self.set_color(25, 58, 51)
class GSequence(GAINode):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GSequence'
def __init__(self):
super(GSequence, self).__init__()
self.set_color(25, 58, 51)
class GDoAction(GAINode):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GDoAction'
def __init__(self):
super(GDoAction, self).__init__()
self.set_color(25, 58, 51)
self.add_text_input('LogicID', 'ligic id', tab='widgets')
self.add_text_input('DataID', 'logic data id', tab='widgets')
class GIdle(GAINode):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GIdle'
def __init__(self):
super(GIdle, self).__init__()
self.add_text_input('Time', 'time idle', tab='widgets')
class GRandomPos(GAINode):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GRandomPos'
def __init__(self):
super(GRandomPos, self).__init__()
self.set_color(25, 58, 51)
self.add_text_input('radius', 'random radius', tab='widgets')
class GMoveToTarget(GAINode):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GMoveToTarget'
def __init__(self):
super(GMoveToTarget, self).__init__()
self.set_color(25, 58, 51)
self.add_text_input('BuffID', 'buff id', tab='widgets')
class GRandomTarget(GAINode):
__identifier__ = 'com.chantasticvfx'
NODE_NAME = 'GRandomTarget'
def __init__(self):
super(GRandomTarget, self).__init__()
self.set_color(25, 58, 51)
self.add_text_input('radius', 'random radius', tab='widgets')
```
#### File: example_auto_nodes/wrappers/tuple.py
```python
def count(self, value):
return self.count(value)
def index(self, value):
return self.index(value)
# custom functions
def get(self, index):
return self.__getitem__(index)
```
#### File: NodeGraphQt/example_nodes/__init__.py
```python
import os
import sys
import ast
VALID_NODE_TYPE = ['BaseNode', 'AutoNode']
def detectNodesFromText(filepath):
"""returns Node names from a python script"""
froms = []
with open(filepath, "r") as source:
tree = ast.parse(source.read())
for node in tree.body:
if isinstance(node, ast.ClassDef):
for base in node.bases:
if base.id in VALID_NODE_TYPE:
for indef in node.body:
if isinstance(indef, ast.Assign):
for target in indef.targets:
if target.id == '__identifier__':
froms.append(node.name)
return froms
def getNodesRecursively(path=__file__):
""" Returns imported nodes. """
Nodes = []
basedir, filename = os.path.split(path)
rootModule = os.path.basename(basedir)
for root, dirs, files in os.walk(basedir, topdown=False):
if root not in sys.path:
sys.path.append(root)
for name in files:
if name.endswith('.py') and not name.startswith('_'):
module_name = root.split(rootModule)[1].replace('\\', '.') + name[:-3]
modulePath = os.path.join(root, name)
froms = detectNodesFromText(modulePath)
if not froms:
continue
try:
mod = __import__(module_name, globals(), locals(), froms, 0)
for node in froms:
Nodes.append(getattr(mod, node))
except ImportError as e:
print ('Error in importing class: %s' % (e))
continue
return Nodes
Nodes = getNodesRecursively()
```
#### File: NodeGraphQt/example_nodes/math_node.py
```python
import example_nodes.wrappers.math as math
import inspect
from functools import partial
from NodeGraphQt import BaseNode
class MathFunctionsNode(BaseNode):
"""
Math functions node.
"""
# set a unique node identifier.
__identifier__ = 'Math'
# set the initial default node name.
NODE_NAME = 'Math Functions'
mathFuncs = [func for func in dir(math) if not func.startswith('_')]
def __init__(self):
super(MathFunctionsNode, self).__init__()
self.set_color(25, 58, 51)
self.add_combo_menu('funcs', 'Functions', items=self.mathFuncs,
tab='widgets')
# switch math function type
self.view.widgets['funcs'].value_changed.connect(self.addFunction)
self.view.widgets['funcs'].value_changed.connect(self.update_stream)
self.add_output('output')
self.create_property('output', None)
self.trigger_type = 'no_inPorts'
self.view.widgets['funcs'].get_custom_widget().setCurrentIndex(2)
def addFunction(self, prop, func):
"""
Create inputs based on math functions arguments.
"""
self.func = getattr(math, func)
dataFunc = inspect.getfullargspec(self.func)
for arg in dataFunc.args:
if not self.has_property(arg):
inPort = self.add_input(arg)
inPort.trigger = True
self.create_property(arg, None)
for inPort in self._inputs:
if inPort.name() in dataFunc.args:
if not inPort.visible():
inPort.set_visible(True)
else:
inPort.set_visible(False)
def run(self):
"""
Evaluate all entries, pass them as arguments of the
chosen mathematical function.
"""
for to_port in self.input_ports():
if to_port.visible() == False:
continue
from_ports = to_port.connected_ports()
if not from_ports:
raise Exception('Port %s not connected!' % to_port.name(),
to_port)
for from_port in from_ports:
from_port.node().run()
data = from_port.node().get_property(from_port.name())
self.set_property(to_port.name(), float(data))
try:
# Execute math function with arguments.
data = self.func(*[self.get_property(inport.name()) for inport in self._inputs if inport.visible()])
self.set_property('output', data)
except KeyError as error:
print("An input is missing! %s" % str(error))
except TypeError as error:
print("Error evaluating function: %s" % str(error))
def on_input_connected(self, to_port, from_port):
"""Override node callback method."""
self.set_property(to_port.name(), from_port.node().run())
self.update_stream()
def on_input_disconnected(self, to_port, from_port):
"""Override node callback method."""
self.set_property('output', None)
self.update_stream()
``` |
{
"source": "99649952/estore",
"score": 2
} |
#### File: estore/account/forms.py
```python
from django import forms
from django.utils.translation import pgettext_lazy
from django.contrib.auth import forms as django_forms
from django.conf import settings
from django.utils.translation import pgettext
from ..account.models import User
class SignupForm(forms.ModelForm):
password = forms.CharField(
widget=forms.PasswordInput)
email = forms.EmailField(
error_messages={
'unique': pgettext_lazy(
'Registration error',
'This email has already been registered.')})
class Meta:
model = User
fields = ('email',)
labels = {
'email': pgettext_lazy(
'Email', 'Email'),
'password': pgettext_lazy(
'Password', 'Password')}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if self._meta.model.USERNAME_FIELD in self.fields:
self.fields[self._meta.model.USERNAME_FIELD].widget.attrs.update(
{'autofocus': ''})
def save(self, request=None, commit=True):
user = super().save(commit=False)
password = self.cleaned_data['password']
user.set_password(password)
if commit:
user.save()
return user
class LoginForm(django_forms.AuthenticationForm):
username = forms.EmailField(
label=pgettext('Form field', 'Email'), max_length=75)
def __init__(self, request=None, *args, **kwargs):
super().__init__(request=request, *args, **kwargs)
if request:
email = request.GET.get('email')
if email:
self.fields['username'].initial = email
``` |
{
"source": "99649952/python_notes",
"score": 3
} |
#### File: 99649952/python_notes/util.py
```python
import time
import functools
import os
import subprocess
import logging
import logging.handlers
def time_count(func):
"""Calculate the running time of the function. Will change the
return of the function. Returns a tuple containing the time and the
return of the function itself
"""
@functools.wraps(func)
def func_wrapper(*args, **kwargs):
st = time.time()
task_r = func(*args, **kwargs)
et = time.time()
mt = et - st
return task_r, mt
return func_wrapper
def ensure_dir(path, backup=True):
"""Make sure a path exists.
If the path exists but It's not a directory, it can be backed up
or deleted.
:param path: A path string.
:param backup: True or False.
"""
if os.path.isdir:
return
tmp = path
while True:
if os.path.lexists(tmp):
if not os.path.isdir(tmp) and backup:
bak = tmp + ".%s" % (int(time.time()))
os.rename(tmp, bak)
elif not os.path.isdir(tmp):
os.remove(tmp)
os.makedirs(path)
break
tmp = os.path.dirname(tmp)
def execute_cmd(cmd):
"""Execute a Linux command synchronously.
:param cmd: A Linux command
:return: (str, str, str)
"""
p = subprocess.Popen(
cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, err = p.communicate()
return p.returncode, output, err
def execute_cmd_async(cmd):
"""Execute a Linux command asynchronously."""
subprocess.Popen(
cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
def get_logger(name="sven.txt", directory=None, file_level=logging.DEBUG,
terminal_level=logging.WARN, max_bytes=10*1024*1024):
"""Convenient to record log.
It is very convenient for debugging and logging.
:param name: Log file name，If directory is None. created in the current directory.
:param directory: If directory is not exist, will create.
:param file_level: log file record level.
:param terminal_level: log terminal show level.
:param max_bytes: log file max Bytes.
:return: <class 'logging.Logger'>
"""
terminal_formatter = logging.Formatter(
"%(module)s.%(funcName)s:%(lineno)s - %(levelname)s - %(message)s")
file_formatter = logging.Formatter(
"%(asctime)s - %(module)s.%(funcName)s:%(lineno)s - %(levelname)s - %(message)s", '%m/%d/%Y %H:%M:%S')
logger = logging.getLogger(name)
logger.setLevel(logging.DEBUG)
if directory is None:
path = os.path.join(os.path.dirname(__file__), name)
else:
os.mkdir(directory)
path = os.path.join(directory, name)
# create handler file_handler
terminal_handler = logging.StreamHandler()
file_handler = logging.handlers.RotatingFileHandler(
path, maxBytes=max_bytes, backupCount=10)
# set level
terminal_handler.setLevel(terminal_level)
file_handler.setLevel(file_level)
# set formatter
terminal_handler.setFormatter(terminal_formatter)
file_handler.setFormatter(file_formatter)
# add handler
logger.addHandler(terminal_handler)
logger.addHandler(file_handler)
return logger
``` |
{
"source": "997Yi/Flask-web",
"score": 3
} |
#### File: tree/tests/test_recognition.py
```python
import pytest
import networkx as nx
class TestTreeRecognition(object):
graph = nx.Graph
multigraph = nx.MultiGraph
@classmethod
def setup_class(cls):
cls.T1 = cls.graph()
cls.T2 = cls.graph()
cls.T2.add_node(1)
cls.T3 = cls.graph()
cls.T3.add_nodes_from(range(5))
edges = [(i, i + 1) for i in range(4)]
cls.T3.add_edges_from(edges)
cls.T5 = cls.multigraph()
cls.T5.add_nodes_from(range(5))
edges = [(i, i + 1) for i in range(4)]
cls.T5.add_edges_from(edges)
cls.T6 = cls.graph()
cls.T6.add_nodes_from([6, 7])
cls.T6.add_edge(6, 7)
cls.F1 = nx.compose(cls.T6, cls.T3)
cls.N4 = cls.graph()
cls.N4.add_node(1)
cls.N4.add_edge(1, 1)
cls.N5 = cls.graph()
cls.N5.add_nodes_from(range(5))
cls.N6 = cls.graph()
cls.N6.add_nodes_from(range(3))
cls.N6.add_edges_from([(0, 1), (1, 2), (2, 0)])
cls.NF1 = nx.compose(cls.T6, cls.N6)
def test_null_tree(self):
with pytest.raises(nx.NetworkXPointlessConcept):
nx.is_tree(self.graph())
nx.is_tree(self.multigraph())
def test_null_forest(self):
with pytest.raises(nx.NetworkXPointlessConcept):
nx.is_forest(self.graph())
nx.is_forest(self.multigraph())
def test_is_tree(self):
assert nx.is_tree(self.T2)
assert nx.is_tree(self.T3)
assert nx.is_tree(self.T5)
def test_is_not_tree(self):
assert not nx.is_tree(self.N4)
assert not nx.is_tree(self.N5)
assert not nx.is_tree(self.N6)
def test_is_forest(self):
assert nx.is_forest(self.T2)
assert nx.is_forest(self.T3)
assert nx.is_forest(self.T5)
assert nx.is_forest(self.F1)
assert nx.is_forest(self.N5)
def test_is_not_forest(self):
assert not nx.is_forest(self.N4)
assert not nx.is_forest(self.N6)
assert not nx.is_forest(self.NF1)
class TestDirectedTreeRecognition(TestTreeRecognition):
graph = nx.DiGraph
multigraph = nx.MultiDiGraph
def test_disconnected_graph():
# https://github.com/networkx/networkx/issues/1144
G = nx.Graph()
G.add_edges_from([(0, 1), (1, 2), (2, 0), (3, 4)])
assert not nx.is_tree(G)
G = nx.DiGraph()
G.add_edges_from([(0, 1), (1, 2), (2, 0), (3, 4)])
assert not nx.is_tree(G)
def test_dag_nontree():
G = nx.DiGraph()
G.add_edges_from([(0, 1), (0, 2), (1, 2)])
assert not nx.is_tree(G)
assert nx.is_directed_acyclic_graph(G)
def test_multicycle():
G = nx.MultiDiGraph()
G.add_edges_from([(0, 1), (0, 1)])
assert not nx.is_tree(G)
assert nx.is_directed_acyclic_graph(G)
def test_emptybranch():
G = nx.DiGraph()
G.add_nodes_from(range(10))
assert nx.is_branching(G)
assert not nx.is_arborescence(G)
def test_path():
G = nx.DiGraph()
nx.add_path(G, range(5))
assert nx.is_branching(G)
assert nx.is_arborescence(G)
def test_notbranching1():
# Acyclic violation.
G = nx.MultiDiGraph()
G.add_nodes_from(range(10))
G.add_edges_from([(0, 1), (1, 0)])
assert not nx.is_branching(G)
assert not nx.is_arborescence(G)
def test_notbranching2():
# In-degree violation.
G = nx.MultiDiGraph()
G.add_nodes_from(range(10))
G.add_edges_from([(0, 1), (0, 2), (3, 2)])
assert not nx.is_branching(G)
assert not nx.is_arborescence(G)
def test_notarborescence1():
# Not an arborescence due to not spanning.
G = nx.MultiDiGraph()
G.add_nodes_from(range(10))
G.add_edges_from([(0, 1), (0, 2), (1, 3), (5, 6)])
assert nx.is_branching(G)
assert not nx.is_arborescence(G)
def test_notarborescence2():
# Not an arborescence due to in-degree violation.
G = nx.MultiDiGraph()
nx.add_path(G, range(5))
G.add_edge(6, 4)
assert not nx.is_branching(G)
assert not nx.is_arborescence(G)
```
#### File: classes/tests/test_digraph.py
```python
import pytest
import networkx as nx
from networkx.testing import assert_nodes_equal
from .test_graph import BaseGraphTester, BaseAttrGraphTester, TestGraph
from .test_graph import TestEdgeSubgraph as TestGraphEdgeSubgraph
class BaseDiGraphTester(BaseGraphTester):
def test_has_successor(self):
G = self.K3
assert G.has_successor(0, 1) == True
assert G.has_successor(0, -1) == False
def test_successors(self):
G = self.K3
assert sorted(G.successors(0)) == [1, 2]
with pytest.raises(nx.NetworkXError):
G.successors(-1)
def test_has_predecessor(self):
G = self.K3
assert G.has_predecessor(0, 1) == True
assert G.has_predecessor(0, -1) == False
def test_predecessors(self):
G = self.K3
assert sorted(G.predecessors(0)) == [1, 2]
with pytest.raises(nx.NetworkXError):
G.predecessors(-1)
def test_edges(self):
G = self.K3
assert sorted(G.edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
assert sorted(G.edges(0)) == [(0, 1), (0, 2)]
assert sorted(G.edges([0, 1])) == [(0, 1), (0, 2), (1, 0), (1, 2)]
with pytest.raises(nx.NetworkXError):
G.edges(-1)
def test_edges_data(self):
G = self.K3
all_edges = [(0, 1, {}), (0, 2, {}), (1, 0, {}), (1, 2, {}), (2, 0, {}), (2, 1, {})]
assert sorted(G.edges(data=True)) == all_edges
assert sorted(G.edges(0, data=True)) == all_edges[:2]
assert sorted(G.edges([0, 1], data=True)) == all_edges[:4]
with pytest.raises(nx.NetworkXError):
G.edges(-1, True)
def test_out_edges(self):
G = self.K3
assert sorted(G.out_edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
assert sorted(G.out_edges(0)) == [(0, 1), (0, 2)]
with pytest.raises(nx.NetworkXError):
G.out_edges(-1)
def test_out_edges_dir(self):
G = self.P3
assert sorted(G.out_edges()) == [(0, 1), (1, 2)]
assert sorted(G.out_edges(0)) == [(0, 1)]
assert sorted(G.out_edges(2)) == []
def test_out_edges_data(self):
G = nx.DiGraph([(0, 1, {'data': 0}), (1, 0, {})])
assert sorted(G.out_edges(data=True)) == [(0, 1, {'data': 0}), (1, 0, {})]
assert sorted(G.out_edges(0, data=True)) == [(0, 1, {'data': 0})]
assert sorted(G.out_edges(data='data')) == [(0, 1, 0), (1, 0, None)]
assert sorted(G.out_edges(0, data='data')) == [(0, 1, 0)]
def test_in_edges_dir(self):
G = self.P3
assert sorted(G.in_edges()) == [(0, 1), (1, 2)]
assert sorted(G.in_edges(0)) == []
assert sorted(G.in_edges(2)) == [(1, 2)]
def test_in_edges_data(self):
G = nx.DiGraph([(0, 1, {'data': 0}), (1, 0, {})])
assert sorted(G.in_edges(data=True)) == [(0, 1, {'data': 0}), (1, 0, {})]
assert sorted(G.in_edges(1, data=True)) == [(0, 1, {'data': 0})]
assert sorted(G.in_edges(data='data')) == [(0, 1, 0), (1, 0, None)]
assert sorted(G.in_edges(1, data='data')) == [(0, 1, 0)]
def test_degree(self):
G = self.K3
assert sorted(G.degree()) == [(0, 4), (1, 4), (2, 4)]
assert dict(G.degree()) == {0: 4, 1: 4, 2: 4}
assert G.degree(0) == 4
assert list(G.degree(iter([0]))) == [
(0, 4)] # run through iterator
def test_in_degree(self):
G = self.K3
assert sorted(G.in_degree()) == [(0, 2), (1, 2), (2, 2)]
assert dict(G.in_degree()) == {0: 2, 1: 2, 2: 2}
assert G.in_degree(0) == 2
assert list(G.in_degree(iter([0]))) == [(0, 2)] # run through iterator
def test_in_degree_weighted(self):
G = self.K3
G.add_edge(0, 1, weight=0.3, other=1.2)
assert sorted(G.in_degree(weight='weight')) == [(0, 2), (1, 1.3), (2, 2)]
assert dict(G.in_degree(weight='weight')) == {0: 2, 1: 1.3, 2: 2}
assert G.in_degree(1, weight='weight') == 1.3
assert sorted(G.in_degree(weight='other')) == [(0, 2), (1, 2.2), (2, 2)]
assert dict(G.in_degree(weight='other')) == {0: 2, 1: 2.2, 2: 2}
assert G.in_degree(1, weight='other') == 2.2
assert list(G.in_degree(iter([1]), weight='other')) == [(1, 2.2)]
def test_out_degree_weighted(self):
G = self.K3
G.add_edge(0, 1, weight=0.3, other=1.2)
assert sorted(G.out_degree(weight='weight')) == [(0, 1.3), (1, 2), (2, 2)]
assert dict(G.out_degree(weight='weight')) == {0: 1.3, 1: 2, 2: 2}
assert G.out_degree(0, weight='weight') == 1.3
assert sorted(G.out_degree(weight='other')) == [(0, 2.2), (1, 2), (2, 2)]
assert dict(G.out_degree(weight='other')) == {0: 2.2, 1: 2, 2: 2}
assert G.out_degree(0, weight='other') == 2.2
assert list(G.out_degree(iter([0]), weight='other')) == [(0, 2.2)]
def test_out_degree(self):
G = self.K3
assert sorted(G.out_degree()) == [(0, 2), (1, 2), (2, 2)]
assert dict(G.out_degree()) == {0: 2, 1: 2, 2: 2}
assert G.out_degree(0) == 2
assert list(G.out_degree(iter([0]))) == [(0, 2)]
def test_size(self):
G = self.K3
assert G.size() == 6
assert G.number_of_edges() == 6
def test_to_undirected_reciprocal(self):
G = self.Graph()
G.add_edge(1, 2)
assert G.to_undirected().has_edge(1, 2)
assert not G.to_undirected(reciprocal=True).has_edge(1, 2)
G.add_edge(2, 1)
assert G.to_undirected(reciprocal=True).has_edge(1, 2)
def test_reverse_copy(self):
G = nx.DiGraph([(0, 1), (1, 2)])
R = G.reverse()
assert sorted(R.edges()) == [(1, 0), (2, 1)]
R.remove_edge(1, 0)
assert sorted(R.edges()) == [(2, 1)]
assert sorted(G.edges()) == [(0, 1), (1, 2)]
def test_reverse_nocopy(self):
G = nx.DiGraph([(0, 1), (1, 2)])
R = G.reverse(copy=False)
assert sorted(R.edges()) == [(1, 0), (2, 1)]
with pytest.raises(nx.NetworkXError):
R.remove_edge(1, 0)
def test_reverse_hashable(self):
class Foo(object):
pass
x = Foo()
y = Foo()
G = nx.DiGraph()
G.add_edge(x, y)
assert_nodes_equal(G.nodes(), G.reverse().nodes())
assert [(y, x)] == list(G.reverse().edges())
class BaseAttrDiGraphTester(BaseDiGraphTester, BaseAttrGraphTester):
pass
class TestDiGraph(BaseAttrDiGraphTester, TestGraph):
"""Tests specific to dict-of-dict-of-dict digraph data structure"""
def setup_method(self):
self.Graph = nx.DiGraph
# build dict-of-dict-of-dict K3
ed1, ed2, ed3, ed4, ed5, ed6 = ({}, {}, {}, {}, {}, {})
self.k3adj = {0: {1: ed1, 2: ed2}, 1: {0: ed3, 2: ed4}, 2: {0: ed5, 1: ed6}}
self.k3edges = [(0, 1), (0, 2), (1, 2)]
self.k3nodes = [0, 1, 2]
self.K3 = self.Graph()
self.K3._adj = self.K3._succ = self.k3adj
self.K3._pred = {0: {1: ed3, 2: ed5}, 1: {0: ed1, 2: ed6}, 2: {0: ed2, 1: ed4}}
self.K3._node = {}
self.K3._node[0] = {}
self.K3._node[1] = {}
self.K3._node[2] = {}
ed1, ed2 = ({}, {})
self.P3 = self.Graph()
self.P3._adj = {0: {1: ed1}, 1: {2: ed2}, 2: {}}
self.P3._succ = self.P3._adj
self.P3._pred = {0: {}, 1: {0: ed1}, 2: {1: ed2}}
self.P3._node = {}
self.P3._node[0] = {}
self.P3._node[1] = {}
self.P3._node[2] = {}
def test_data_input(self):
G = self.Graph({1: [2], 2: [1]}, name="test")
assert G.name == "test"
assert sorted(G.adj.items()) == [(1, {2: {}}), (2, {1: {}})]
assert sorted(G.succ.items()) == [(1, {2: {}}), (2, {1: {}})]
assert sorted(G.pred.items()) == [(1, {2: {}}), (2, {1: {}})]
def test_add_edge(self):
G = self.Graph()
G.add_edge(0, 1)
assert G.adj == {0: {1: {}}, 1: {}}
assert G.succ == {0: {1: {}}, 1: {}}
assert G.pred == {0: {}, 1: {0: {}}}
G = self.Graph()
G.add_edge(*(0, 1))
assert G.adj == {0: {1: {}}, 1: {}}
assert G.succ == {0: {1: {}}, 1: {}}
assert G.pred == {0: {}, 1: {0: {}}}
def test_add_edges_from(self):
G = self.Graph()
G.add_edges_from([(0, 1), (0, 2, {'data': 3})], data=2)
assert G.adj == {0: {1: {'data': 2}, 2: {'data': 3}}, 1: {}, 2: {}}
assert G.succ == {0: {1: {'data': 2}, 2: {'data': 3}}, 1: {}, 2: {}}
assert G.pred == {0: {}, 1: {0: {'data': 2}}, 2: {0: {'data': 3}}}
with pytest.raises(nx.NetworkXError):
G.add_edges_from([(0,)]) # too few in tuple
with pytest.raises(nx.NetworkXError):
G.add_edges_from([(0, 1, 2, 3)]) # too many in tuple
with pytest.raises(TypeError):
G.add_edges_from([0]) # not a tuple
def test_remove_edge(self):
G = self.K3
G.remove_edge(0, 1)
assert G.succ == {0: {2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}}
assert G.pred == {0: {1: {}, 2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}}
with pytest.raises(nx.NetworkXError):
G.remove_edge(-1, 0)
def test_remove_edges_from(self):
G = self.K3
G.remove_edges_from([(0, 1)])
assert G.succ == {0: {2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}}
assert G.pred == {0: {1: {}, 2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}}
G.remove_edges_from([(0, 0)]) # silent fail
class TestEdgeSubgraph(TestGraphEdgeSubgraph):
"""Unit tests for the :meth:`DiGraph.edge_subgraph` method."""
def setup_method(self):
# Create a doubly-linked path graph on five nodes.
G = nx.DiGraph(nx.path_graph(5))
# Add some node, edge, and graph attributes.
for i in range(5):
G.nodes[i]['name'] = 'node{}'.format(i)
G.edges[0, 1]['name'] = 'edge01'
G.edges[3, 4]['name'] = 'edge34'
G.graph['name'] = 'graph'
# Get the subgraph induced by the first and last edges.
self.G = G
self.H = G.edge_subgraph([(0, 1), (3, 4)])
def test_pred_succ(self):
"""Test that nodes are added to predecessors and successors.
For more information, see GitHub issue #2370.
"""
G = nx.DiGraph()
G.add_edge(0, 1)
H = G.edge_subgraph([(0, 1)])
assert list(H.predecessors(0)) == []
assert list(H.successors(0)) == [1]
assert list(H.predecessors(1)) == [0]
assert list(H.successors(1)) == []
```
#### File: classes/tests/test_multigraph.py
```python
import pytest
import networkx as nx
from networkx.testing.utils import *
from .test_graph import BaseAttrGraphTester, TestGraph
class BaseMultiGraphTester(BaseAttrGraphTester):
def test_has_edge(self):
G = self.K3
assert G.has_edge(0, 1) == True
assert G.has_edge(0, -1) == False
assert G.has_edge(0, 1, 0) == True
assert G.has_edge(0, 1, 1) == False
def test_get_edge_data(self):
G = self.K3
assert G.get_edge_data(0, 1) == {0: {}}
assert G[0][1] == {0: {}}
assert G[0][1][0] == {}
assert G.get_edge_data(10, 20) == None
assert G.get_edge_data(0, 1, 0) == {}
def test_adjacency(self):
G = self.K3
assert (dict(G.adjacency()) ==
{0: {1: {0: {}}, 2: {0: {}}},
1: {0: {0: {}}, 2: {0: {}}},
2: {0: {0: {}}, 1: {0: {}}}})
def deepcopy_edge_attr(self, H, G):
assert G[1][2][0]['foo'] == H[1][2][0]['foo']
G[1][2][0]['foo'].append(1)
assert G[1][2][0]['foo'] != H[1][2][0]['foo']
def shallow_copy_edge_attr(self, H, G):
assert G[1][2][0]['foo'] == H[1][2][0]['foo']
G[1][2][0]['foo'].append(1)
assert G[1][2][0]['foo'] == H[1][2][0]['foo']
def graphs_equal(self, H, G):
assert G._adj == H._adj
assert G._node == H._node
assert G.graph == H.graph
assert G.name == H.name
if not G.is_directed() and not H.is_directed():
assert H._adj[1][2][0] is H._adj[2][1][0]
assert G._adj[1][2][0] is G._adj[2][1][0]
else: # at least one is directed
if not G.is_directed():
G._pred = G._adj
G._succ = G._adj
if not H.is_directed():
H._pred = H._adj
H._succ = H._adj
assert G._pred == H._pred
assert G._succ == H._succ
assert H._succ[1][2][0] is H._pred[2][1][0]
assert G._succ[1][2][0] is G._pred[2][1][0]
def same_attrdict(self, H, G):
# same attrdict in the edgedata
old_foo = H[1][2][0]['foo']
H.adj[1][2][0]['foo'] = 'baz'
assert G._adj == H._adj
H.adj[1][2][0]['foo'] = old_foo
assert G._adj == H._adj
old_foo = H.nodes[0]['foo']
H.nodes[0]['foo'] = 'baz'
assert G._node == H._node
H.nodes[0]['foo'] = old_foo
assert G._node == H._node
def different_attrdict(self, H, G):
# used by graph_equal_but_different
old_foo = H[1][2][0]['foo']
H.adj[1][2][0]['foo'] = 'baz'
assert G._adj != H._adj
H.adj[1][2][0]['foo'] = old_foo
assert G._adj == H._adj
old_foo = H.nodes[0]['foo']
H.nodes[0]['foo'] = 'baz'
assert G._node != H._node
H.nodes[0]['foo'] = old_foo
assert G._node == H._node
def test_to_undirected(self):
G = self.K3
self.add_attributes(G)
H = nx.MultiGraph(G)
self.is_shallow_copy(H, G)
H = G.to_undirected()
self.is_deepcopy(H, G)
def test_to_directed(self):
G = self.K3
self.add_attributes(G)
H = nx.MultiDiGraph(G)
self.is_shallow_copy(H, G)
H = G.to_directed()
self.is_deepcopy(H, G)
def test_number_of_edges_selfloops(self):
G = self.K3
G.add_edge(0, 0)
G.add_edge(0, 0)
G.add_edge(0, 0, key='parallel edge')
G.remove_edge(0, 0, key='parallel edge')
assert G.number_of_edges(0, 0) == 2
G.remove_edge(0, 0)
assert G.number_of_edges(0, 0) == 1
def test_edge_lookup(self):
G = self.Graph()
G.add_edge(1, 2, foo='bar')
G.add_edge(1, 2, 'key', foo='biz')
assert_edges_equal(G.edges[1, 2, 0], {'foo': 'bar'})
assert_edges_equal(G.edges[1, 2, 'key'], {'foo': 'biz'})
def test_edge_attr4(self):
G = self.Graph()
G.add_edge(1, 2, key=0, data=7, spam='bar', bar='foo')
assert_edges_equal(G.edges(data=True),
[(1, 2, {'data': 7, 'spam': 'bar', 'bar': 'foo'})])
G[1][2][0]['data'] = 10 # OK to set data like this
assert_edges_equal(G.edges(data=True),
[(1, 2, {'data': 10, 'spam': 'bar', 'bar': 'foo'})])
G.adj[1][2][0]['data'] = 20
assert_edges_equal(G.edges(data=True),
[(1, 2, {'data': 20, 'spam': 'bar', 'bar': 'foo'})])
G.edges[1, 2, 0]['data'] = 21 # another spelling, "edge"
assert_edges_equal(G.edges(data=True),
[(1, 2, {'data': 21, 'spam': 'bar', 'bar': 'foo'})])
G.adj[1][2][0]['listdata'] = [20, 200]
G.adj[1][2][0]['weight'] = 20
assert_edges_equal(G.edges(data=True),
[(1, 2, {'data': 21, 'spam': 'bar', 'bar': 'foo',
'listdata': [20, 200], 'weight':20})])
class TestMultiGraph(BaseMultiGraphTester, TestGraph):
def setup_method(self):
self.Graph = nx.MultiGraph
# build K3
ed1, ed2, ed3 = ({0: {}}, {0: {}}, {0: {}})
self.k3adj = {0: {1: ed1, 2: ed2},
1: {0: ed1, 2: ed3},
2: {0: ed2, 1: ed3}}
self.k3edges = [(0, 1), (0, 2), (1, 2)]
self.k3nodes = [0, 1, 2]
self.K3 = self.Graph()
self.K3._adj = self.k3adj
self.K3._node = {}
self.K3._node[0] = {}
self.K3._node[1] = {}
self.K3._node[2] = {}
def test_data_input(self):
G = self.Graph({1: [2], 2: [1]}, name="test")
assert G.name == "test"
expected = [(1, {2: {0: {}}}), (2, {1: {0: {}}})]
assert sorted(G.adj.items()) == expected
def test_getitem(self):
G = self.K3
assert G[0] == {1: {0: {}}, 2: {0: {}}}
with pytest.raises(KeyError):
G.__getitem__('j')
with pytest.raises(TypeError):
G.__getitem__(['A'])
def test_remove_node(self):
G = self.K3
G.remove_node(0)
assert G.adj == {1: {2: {0: {}}}, 2: {1: {0: {}}}}
with pytest.raises(nx.NetworkXError):
G.remove_node(-1)
def test_add_edge(self):
G = self.Graph()
G.add_edge(0, 1)
assert G.adj == {0: {1: {0: {}}}, 1: {0: {0: {}}}}
G = self.Graph()
G.add_edge(*(0, 1))
assert G.adj == {0: {1: {0: {}}}, 1: {0: {0: {}}}}
def test_add_edge_conflicting_key(self):
G = self.Graph()
G.add_edge(0, 1, key=1)
G.add_edge(0, 1)
assert G.number_of_edges() == 2
G = self.Graph()
G.add_edges_from([(0, 1, 1, {})])
G.add_edges_from([(0, 1)])
assert G.number_of_edges() == 2
def test_add_edges_from(self):
G = self.Graph()
G.add_edges_from([(0, 1), (0, 1, {'weight': 3})])
assert G.adj == {0: {1: {0: {}, 1: {'weight': 3}}},
1: {0: {0: {}, 1: {'weight': 3}}}}
G.add_edges_from([(0, 1), (0, 1, {'weight': 3})], weight=2)
assert G.adj == {0: {1: {0: {}, 1: {'weight': 3},
2: {'weight': 2}, 3: {'weight': 3}}},
1: {0: {0: {}, 1: {'weight': 3},
2: {'weight': 2}, 3: {'weight': 3}}}}
G = self.Graph()
edges = [(0, 1, {'weight': 3}), (0, 1, (('weight', 2),)),
(0, 1, 5), (0, 1, 's')]
G.add_edges_from(edges)
keydict = {0: {'weight': 3}, 1: {'weight': 2}, 5: {}, 's': {}}
assert G._adj == {0: {1: keydict}, 1: {0: keydict}}
# too few in tuple
with pytest.raises(nx.NetworkXError):
G.add_edges_from([(0,)])
# too many in tuple
with pytest.raises(nx.NetworkXError):
G.add_edges_from([(0, 1, 2, 3, 4)])
# not a tuple
with pytest.raises(TypeError):
G.add_edges_from([0])
def test_remove_edge(self):
G = self.K3
G.remove_edge(0, 1)
assert G.adj == {0: {2: {0: {}}},
1: {2: {0: {}}},
2: {0: {0: {}},
1: {0: {}}}}
with pytest.raises(nx.NetworkXError):
G.remove_edge(-1, 0)
with pytest.raises(nx.NetworkXError):
G.remove_edge(0, 2, key=1)
def test_remove_edges_from(self):
G = self.K3.copy()
G.remove_edges_from([(0, 1)])
kd = {0: {}}
assert G.adj == {0: {2: kd}, 1: {2: kd}, 2: {0: kd, 1: kd}}
G.remove_edges_from([(0, 0)]) # silent fail
self.K3.add_edge(0, 1)
G = self.K3.copy()
G.remove_edges_from(list(G.edges(data=True, keys=True)))
assert G.adj == {0: {}, 1: {}, 2: {}}
G = self.K3.copy()
G.remove_edges_from(list(G.edges(data=False, keys=True)))
assert G.adj == {0: {}, 1: {}, 2: {}}
G = self.K3.copy()
G.remove_edges_from(list(G.edges(data=False, keys=False)))
assert G.adj == {0: {}, 1: {}, 2: {}}
G = self.K3.copy()
G.remove_edges_from([(0, 1, 0), (0, 2, 0, {}), (1, 2)])
assert G.adj == {0: {1: {1: {}}}, 1: {0: {1: {}}}, 2: {}}
def test_remove_multiedge(self):
G = self.K3
G.add_edge(0, 1, key='parallel edge')
G.remove_edge(0, 1, key='parallel edge')
assert G.adj == {0: {1: {0: {}}, 2: {0: {}}},
1: {0: {0: {}}, 2: {0: {}}},
2: {0: {0: {}}, 1: {0: {}}}}
G.remove_edge(0, 1)
kd = {0: {}}
assert G.adj == {0: {2: kd}, 1: {2: kd}, 2: {0: kd, 1: kd}}
with pytest.raises(nx.NetworkXError):
G.remove_edge(-1, 0)
class TestEdgeSubgraph(object):
"""Unit tests for the :meth:`MultiGraph.edge_subgraph` method."""
def setup_method(self):
# Create a doubly-linked path graph on five nodes.
G = nx.MultiGraph()
nx.add_path(G, range(5))
nx.add_path(G, range(5))
# Add some node, edge, and graph attributes.
for i in range(5):
G.nodes[i]['name'] = 'node{}'.format(i)
G.adj[0][1][0]['name'] = 'edge010'
G.adj[0][1][1]['name'] = 'edge011'
G.adj[3][4][0]['name'] = 'edge340'
G.adj[3][4][1]['name'] = 'edge341'
G.graph['name'] = 'graph'
# Get the subgraph induced by one of the first edges and one of
# the last edges.
self.G = G
self.H = G.edge_subgraph([(0, 1, 0), (3, 4, 1)])
def test_correct_nodes(self):
"""Tests that the subgraph has the correct nodes."""
assert [0, 1, 3, 4] == sorted(self.H.nodes())
def test_correct_edges(self):
"""Tests that the subgraph has the correct edges."""
assert ([(0, 1, 0, 'edge010'), (3, 4, 1, 'edge341')] ==
sorted(self.H.edges(keys=True, data='name')))
def test_add_node(self):
"""Tests that adding a node to the original graph does not
affect the nodes of the subgraph.
"""
self.G.add_node(5)
assert [0, 1, 3, 4] == sorted(self.H.nodes())
def test_remove_node(self):
"""Tests that removing a node in the original graph does
affect the nodes of the subgraph.
"""
self.G.remove_node(0)
assert [1, 3, 4] == sorted(self.H.nodes())
def test_node_attr_dict(self):
"""Tests that the node attribute dictionary of the two graphs is
the same object.
"""
for v in self.H:
assert self.G.nodes[v] == self.H.nodes[v]
# Making a change to G should make a change in H and vice versa.
self.G.nodes[0]['name'] = 'foo'
assert self.G.nodes[0] == self.H.nodes[0]
self.H.nodes[1]['name'] = 'bar'
assert self.G.nodes[1] == self.H.nodes[1]
def test_edge_attr_dict(self):
"""Tests that the edge attribute dictionary of the two graphs is
the same object.
"""
for u, v, k in self.H.edges(keys=True):
assert self.G._adj[u][v][k] == self.H._adj[u][v][k]
# Making a change to G should make a change in H and vice versa.
self.G._adj[0][1][0]['name'] = 'foo'
assert (self.G._adj[0][1][0]['name'] ==
self.H._adj[0][1][0]['name'])
self.H._adj[3][4][1]['name'] = 'bar'
assert (self.G._adj[3][4][1]['name'] ==
self.H._adj[3][4][1]['name'])
def test_graph_attr_dict(self):
"""Tests that the graph attribute dictionary of the two graphs
is the same object.
"""
assert self.G.graph is self.H.graph
```
#### File: readwrite/tests/test_yaml.py
```python
import os
import tempfile
import pytest
import networkx as nx
from networkx.testing import assert_edges_equal, assert_nodes_equal
class TestYaml(object):
@classmethod
def setup_class(cls):
cls.build_graphs()
@classmethod
def build_graphs(cls):
cls.G = nx.Graph(name="test")
e = [('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', 'e'), ('e', 'f'), ('a', 'f')]
cls.G.add_edges_from(e)
cls.G.add_node('g')
cls.DG = nx.DiGraph(cls.G)
cls.MG = nx.MultiGraph()
cls.MG.add_weighted_edges_from([(1, 2, 5), (1, 2, 5), (1, 2, 1), (3, 3, 42)])
def assert_equal(self, G, data=False):
(fd, fname) = tempfile.mkstemp()
nx.write_yaml(G, fname)
Gin = nx.read_yaml(fname)
assert_nodes_equal(list(G), list(Gin))
assert_edges_equal(G.edges(data=data), Gin.edges(data=data))
os.close(fd)
os.unlink(fname)
def testUndirected(self):
self.assert_equal(self.G, data=False)
def testDirected(self):
self.assert_equal(self.DG, data=False)
def testMultiGraph(self):
self.assert_equal(self.MG, data=True)
# fixture for pytest tests
def setup_module(module):
import pytest
yaml = pytest.importorskip("yaml")
```
#### File: draw/tests/test_draw.py
```python
import numpy as np
from skimage._shared.testing import test_parallel
from skimage._shared import testing
from skimage._shared.testing import assert_array_equal, assert_equal
from skimage._shared.testing import assert_almost_equal
from skimage.draw import (set_color, line, line_aa, polygon, polygon_perimeter,
circle, circle_perimeter, circle_perimeter_aa,
ellipse, ellipse_perimeter,
_bezier_segment, bezier_curve, rectangle,
rectangle_perimeter)
from skimage.measure import regionprops
def test_set_color():
img = np.zeros((10, 10))
rr, cc = line(0, 0, 0, 30)
set_color(img, (rr, cc), 1)
img_ = np.zeros((10, 10))
img_[0, :] = 1
assert_array_equal(img, img_)
def test_set_color_with_alpha():
img = np.zeros((10, 10))
rr, cc, alpha = line_aa(0, 0, 0, 30)
set_color(img, (rr, cc), 1, alpha=alpha)
# Wrong dimensionality color
with testing.raises(ValueError):
set_color(img, (rr, cc), (255, 0, 0), alpha=alpha)
img = np.zeros((10, 10, 3))
rr, cc, alpha = line_aa(0, 0, 0, 30)
set_color(img, (rr, cc), (1, 0, 0), alpha=alpha)
@test_parallel()
def test_line_horizontal():
img = np.zeros((10, 10))
rr, cc = line(0, 0, 0, 9)
img[rr, cc] = 1
img_ = np.zeros((10, 10))
img_[0, :] = 1
assert_array_equal(img, img_)
def test_line_vertical():
img = np.zeros((10, 10))
rr, cc = line(0, 0, 9, 0)
img[rr, cc] = 1
img_ = np.zeros((10, 10))
img_[:, 0] = 1
assert_array_equal(img, img_)
def test_line_reverse():
img = np.zeros((10, 10))
rr, cc = line(0, 9, 0, 0)
img[rr, cc] = 1
img_ = np.zeros((10, 10))
img_[0, :] = 1
assert_array_equal(img, img_)
def test_line_diag():
img = np.zeros((5, 5))
rr, cc = line(0, 0, 4, 4)
img[rr, cc] = 1
img_ = np.eye(5)
assert_array_equal(img, img_)
def test_line_aa_horizontal():
img = np.zeros((10, 10))
rr, cc, val = line_aa(0, 0, 0, 9)
set_color(img, (rr, cc), 1, alpha=val)
img_ = np.zeros((10, 10))
img_[0, :] = 1
assert_array_equal(img, img_)
def test_line_aa_vertical():
img = np.zeros((10, 10))
rr, cc, val = line_aa(0, 0, 9, 0)
img[rr, cc] = val
img_ = np.zeros((10, 10))
img_[:, 0] = 1
assert_array_equal(img, img_)
def test_line_aa_diagonal():
img = np.zeros((10, 10))
rr, cc, val = line_aa(0, 0, 9, 6)
img[rr, cc] = 1
# Check that each pixel belonging to line,
# also belongs to line_aa
r, c = line(0, 0, 9, 6)
for r_i, c_i in zip(r, c):
assert_equal(img[r_i, c_i], 1)
def test_line_equal_aliasing_horizontally_vertically():
img0 = np.zeros((25, 25))
img1 = np.zeros((25, 25))
# Near-horizontal line
rr, cc, val = line_aa(10, 2, 12, 20)
img0[rr, cc] = val
# Near-vertical (transpose of prior)
rr, cc, val = line_aa(2, 10, 20, 12)
img1[rr, cc] = val
# Difference - should be zero
assert_array_equal(img0, img1.T)
def test_polygon_rectangle():
img = np.zeros((10, 10), 'uint8')
rr, cc = polygon((1, 4, 4, 1, 1), (1, 1, 4, 4, 1))
img[rr, cc] = 1
img_ = np.zeros((10, 10))
img_[1:4, 1:4] = 1
assert_array_equal(img, img_)
def test_polygon_rectangle_angular():
img = np.zeros((10, 10), 'uint8')
poly = np.array(((0, 3), (4, 7), (7, 4), (3, 0), (0, 3)))
rr, cc = polygon(poly[:, 0], poly[:, 1])
img[rr, cc] = 1
img_ = np.array(
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
[0, 0, 1, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
)
assert_array_equal(img, img_)
def test_polygon_parallelogram():
img = np.zeros((10, 10), 'uint8')
poly = np.array(((1, 1), (5, 1), (7, 6), (3, 6), (1, 1)))
rr, cc = polygon(poly[:, 0], poly[:, 1])
img[rr, cc] = 1
img_ = np.array(
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 1, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 1, 0, 0, 0, 0],
[0, 1, 1, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
)
assert_array_equal(img, img_)
def test_polygon_exceed():
img = np.zeros((10, 10), 'uint8')
poly = np.array(((1, -1), (100, -1), (100, 100), (1, 100), (1, 1)))
rr, cc = polygon(poly[:, 0], poly[:, 1], img.shape)
img[rr, cc] = 1
img_ = np.zeros((10, 10))
img_[1:, :] = 1
assert_array_equal(img, img_)
def test_circle():
img = np.zeros((15, 15), 'uint8')
rr, cc = circle(7, 7, 6)
img[rr, cc] = 1
img_ = np.array(
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
)
assert_array_equal(img, img_)
def test_circle_perimeter_bresenham():
img = np.zeros((15, 15), 'uint8')
rr, cc = circle_perimeter(7, 7, 0, method='bresenham')
img[rr, cc] = 1
assert(np.sum(img) == 1)
assert(img[7][7] == 1)
img = np.zeros((17, 15), 'uint8')
rr, cc = circle_perimeter(7, 7, 7, method='bresenham')
img[rr, cc] = 1
img_ = np.array(
[[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
)
assert_array_equal(img, img_)
def test_circle_perimeter_bresenham_shape():
img = np.zeros((15, 20), 'uint8')
rr, cc = circle_perimeter(7, 10, 9, method='bresenham', shape=(15, 20))
img[rr, cc] = 1
shift = 5
img_ = np.zeros((15 + 2 * shift, 20), 'uint8')
rr, cc = circle_perimeter(7 + shift, 10, 9, method='bresenham', shape=None)
img_[rr, cc] = 1
assert_array_equal(img, img_[shift:-shift, :])
def test_circle_perimeter_andres():
img = np.zeros((15, 15), 'uint8')
rr, cc = circle_perimeter(7, 7, 0, method='andres')
img[rr, cc] = 1
assert(np.sum(img) == 1)
assert(img[7][7] == 1)
img = np.zeros((17, 15), 'uint8')
rr, cc = circle_perimeter(7, 7, 7, method='andres')
img[rr, cc] = 1
img_ = np.array(
[[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0],
[0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
[0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
)
assert_array_equal(img, img_)
def test_circle_perimeter_aa():
img = np.zeros((15, 15), 'uint8')
rr, cc, val = circle_perimeter_aa(7, 7, 0)
img[rr, cc] = 1
assert(np.sum(img) == 1)
assert(img[7][7] == 1)
img = np.zeros((17, 17), 'uint8')
rr, cc, val = circle_perimeter_aa(8, 8, 7)
img[rr, cc] = val * 255
img_ = np.array(
[[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 82, 180, 236, 255, 236, 180, 82, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 189, 172, 74, 18, 0, 18, 74, 172, 189, 0, 0, 0, 0],
[ 0, 0, 0, 229, 25, 0, 0, 0, 0, 0, 0, 0, 25, 229, 0, 0, 0],
[ 0, 0, 189, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 189, 0, 0],
[ 0, 82, 172, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 172, 82, 0],
[ 0, 180, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 74, 180, 0],
[ 0, 236, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 236, 0],
[ 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0],
[ 0, 236, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 236, 0],
[ 0, 180, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 74, 180, 0],
[ 0, 82, 172, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 172, 82, 0],
[ 0, 0, 189, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 189, 0, 0],
[ 0, 0, 0, 229, 25, 0, 0, 0, 0, 0, 0, 0, 25, 229, 0, 0, 0],
[ 0, 0, 0, 0, 189, 172, 74, 18, 0, 18, 74, 172, 189, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 82, 180, 236, 255, 236, 180, 82, 0, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
)
assert_array_equal(img, img_)
def test_circle_perimeter_aa_shape():
img = np.zeros((15, 20), 'uint8')
rr, cc, val = circle_perimeter_aa(7, 10, 9, shape=(15, 20))
img[rr, cc] = val * 255
shift = 5
img_ = np.zeros((15 + 2 * shift, 20), 'uint8')
rr, cc, val = circle_perimeter_aa(7 + shift, 10, 9, shape=None)
img_[rr, cc] = val * 255
assert_array_equal(img, img_[shift:-shift, :])
def test_ellipse_trivial():
img = np.zeros((2, 2), 'uint8')
rr, cc = ellipse(0.5, 0.5, 0.5, 0.5)
img[rr, cc] = 1
img_correct = np.array([
[0, 0],
[0, 0]
])
assert_array_equal(img, img_correct)
img = np.zeros((2, 2), 'uint8')
rr, cc = ellipse(0.5, 0.5, 1.1, 1.1)
img[rr, cc] = 1
img_correct = np.array([
[1, 1],
[1, 1],
])
assert_array_equal(img, img_correct)
img = np.zeros((3, 3), 'uint8')
rr, cc = ellipse(1, 1, 0.9, 0.9)
img[rr, cc] = 1
img_correct = np.array([
[0, 0, 0],
[0, 1, 0],
[0, 0, 0],
])
assert_array_equal(img, img_correct)
img = np.zeros((3, 3), 'uint8')
rr, cc = ellipse(1, 1, 1.1, 1.1)
img[rr, cc] = 1
img_correct = np.array([
[0, 1, 0],
[1, 1, 1],
[0, 1, 0],
])
assert_array_equal(img, img_correct)
img = np.zeros((3, 3), 'uint8')
rr, cc = ellipse(1, 1, 1.5, 1.5)
img[rr, cc] = 1
img_correct = np.array([
[1, 1, 1],
[1, 1, 1],
[1, 1, 1],
])
assert_array_equal(img, img_correct)
def test_ellipse_generic():
img = np.zeros((4, 4), 'uint8')
rr, cc = ellipse(1.5, 1.5, 1.1, 1.7)
img[rr, cc] = 1
img_ = np.array([
[0, 0, 0, 0],
[1, 1, 1, 1],
[1, 1, 1, 1],
[0, 0, 0, 0],
])
assert_array_equal(img, img_)
img = np.zeros((5, 5), 'uint8')
rr, cc = ellipse(2, 2, 1.7, 1.7)
img[rr, cc] = 1
img_ = np.array([
[0, 0, 0, 0, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 0, 0, 0, 0],
])
assert_array_equal(img, img_)
img = np.zeros((10, 10), 'uint8')
rr, cc = ellipse(5, 5, 3, 4)
img[rr, cc] = 1
img_ = np.array([
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
])
assert_array_equal(img, img_)
img = np.zeros((10, 10), 'uint8')
rr, cc = ellipse(4.5, 5, 3.5, 4)
img[rr, cc] = 1
img_ = np.array([
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
])
assert_array_equal(img, img_)
img = np.zeros((15, 15), 'uint8')
rr, cc = ellipse(7, 7, 3, 7)
img[rr, cc] = 1
img_ = np.array([
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
])
assert_array_equal(img, img_)
def test_ellipse_with_shape():
img = np.zeros((15, 15), 'uint8')
rr, cc = ellipse(7, 7, 3, 10, shape=img.shape)
img[rr, cc] = 1
img_ = np.array(
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
)
assert_array_equal(img, img_)
img = np.zeros((10, 9, 3), 'uint8')
rr, cc = ellipse(7, 7, 3, 10, shape=img.shape)
img[rr, cc, 0] = 1
img_ = np.zeros_like(img)
img_[..., 0] = np.array(
[[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1]],
)
assert_array_equal(img, img_)
def test_ellipse_negative():
rr, cc = ellipse(-3, -3, 1.7, 1.7)
rr_, cc_ = np.nonzero(np.array([
[0, 0, 0, 0, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 0, 0, 0, 0],
]))
assert_array_equal(rr, rr_ - 5)
assert_array_equal(cc, cc_ - 5)
def test_ellipse_rotation_symmetry():
img1 = np.zeros((150, 150), dtype=np.uint8)
img2 = np.zeros((150, 150), dtype=np.uint8)
for angle in range(0, 180, 15):
img1.fill(0)
rr, cc = ellipse(80, 70, 60, 40, rotation=np.deg2rad(angle))
img1[rr, cc] = 1
img2.fill(0)
rr, cc = ellipse(80, 70, 60, 40, rotation=np.deg2rad(angle + 180))
img2[rr, cc] = 1
assert_array_equal(img1, img2)
def test_ellipse_rotated():
img = np.zeros((1000, 1200), dtype=np.uint8)
for rot in range(0, 180, 10):
img.fill(0)
angle = np.deg2rad(rot)
rr, cc = ellipse(500, 600, 200, 400, rotation=angle)
img[rr, cc] = 1
# estimate orientation of ellipse
angle_estim_raw = regionprops(img)[0].orientation
angle_estim = np.round(angle_estim_raw, 3) % (np.pi / 2)
assert_almost_equal(angle_estim, angle % (np.pi / 2), 2)
def test_ellipse_perimeter_dot_zeroangle():
# dot, angle == 0
img = np.zeros((30, 15), 'uint8')
rr, cc = ellipse_perimeter(15, 7, 0, 0, 0)
img[rr, cc] = 1
assert(np.sum(img) == 1)
assert(img[15][7] == 1)
def test_ellipse_perimeter_dot_nzeroangle():
# dot, angle != 0
img = np.zeros((30, 15), 'uint8')
rr, cc = ellipse_perimeter(15, 7, 0, 0, 1)
img[rr, cc] = 1
assert(np.sum(img) == 1)
assert(img[15][7] == 1)
def test_ellipse_perimeter_flat_zeroangle():
# flat ellipse
img = np.zeros((20, 18), 'uint8')
img_ = np.zeros((20, 18), 'uint8')
rr, cc = ellipse_perimeter(6, 7, 0, 5, 0)
img[rr, cc] = 1
rr, cc = line(6, 2, 6, 12)
img_[rr, cc] = 1
assert_array_equal(img, img_)
def test_ellipse_perimeter_zeroangle():
# angle == 0
img = np.zeros((30, 15), 'uint8')
rr, cc = ellipse_perimeter(15, 7, 14, 6, 0)
img[rr, cc] = 1
img_ = np.array(
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0]]
)
assert_array_equal(img, img_)
def test_ellipse_perimeter_nzeroangle():
# angle != 0
img = np.zeros((30, 25), 'uint8')
rr, cc = ellipse_perimeter(15, 11, 12, 6, 1.1)
img[rr, cc] = 1
img_ = np.array(
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
)
assert_array_equal(img, img_)
def test_ellipse_perimeter_shape():
img = np.zeros((15, 20), 'uint8')
rr, cc = ellipse_perimeter(7, 10, 9, 9, 0, shape=(15, 20))
img[rr, cc] = 1
shift = 5
img_ = np.zeros((15 + 2 * shift, 20), 'uint8')
rr, cc = ellipse_perimeter(7 + shift, 10, 9, 9, 0, shape=None)
img_[rr, cc] = 1
assert_array_equal(img, img_[shift:-shift, :])
def test_bezier_segment_straight():
image = np.zeros((200, 200), dtype=int)
r0, r1, r2 = 50, 150, 150
c0, c1, c2 = 50, 50, 150
rr, cc = _bezier_segment(r0, c0, r1, c1, r2, c2, 0)
image[rr, cc] = 1
image2 = np.zeros((200, 200), dtype=int)
rr, cc = line(r0, c0, r2, c2)
image2[rr, cc] = 1
assert_array_equal(image, image2)
def test_bezier_segment_curved():
img = np.zeros((25, 25), 'uint8')
r0, c0 = 20, 20
r1, c1 = 20, 2
r2, c2 = 2, 2
rr, cc = _bezier_segment(r0, c0, r1, c1, r2, c2, 1)
img[rr, cc] = 1
img_ = np.array(
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
)
assert_equal(img[r0, c0], 1)
assert_equal(img[r2, c2], 1)
assert_array_equal(img, img_)
def test_bezier_curve_straight():
image = np.zeros((200, 200), dtype=int)
r0, c0 = 50, 50
r1, c1 = 150, 50
r2, c2 = 150, 150
rr, cc = bezier_curve(r0, c0, r1, c1, r2, c2, 0)
image[rr, cc] = 1
image2 = np.zeros((200, 200), dtype=int)
rr, cc = line(r0, c0, r2, c2)
image2[rr, cc] = 1
assert_array_equal(image, image2)
def test_bezier_curved_weight_eq_1():
img = np.zeros((23, 8), 'uint8')
r0, c0 = 1, 1
r1, c1 = 11, 11
r2, c2 = 21, 1
rr, cc = bezier_curve(r0, c0, r1, c1, r2, c2, 1)
img[rr, cc] = 1
assert_equal(img[r0, c0], 1)
assert_equal(img[r2, c2], 1)
img_ = np.array(
[[0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0]]
)
assert_equal(img, img_)
def test_bezier_curved_weight_neq_1():
img = np.zeros((23, 10), 'uint8')
r0, c0 = 1, 1
r1, c1 = 11, 11
r2, c2 = 21, 1
rr, cc = bezier_curve(r0, c0, r1, c1, r2, c2, 2)
img[rr, cc] = 1
assert_equal(img[r0, c0], 1)
assert_equal(img[r2, c2], 1)
img_ = np.array(
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
)
assert_equal(img, img_)
def test_bezier_curve_shape():
img = np.zeros((15, 20), 'uint8')
r0, c0 = 1, 5
r1, c1 = 6, 11
r2, c2 = 1, 14
rr, cc = bezier_curve(r0, c0, r1, c1, r2, c2, 2, shape=(15, 20))
img[rr, cc] = 1
shift = 5
img_ = np.zeros((15 + 2 * shift, 20), 'uint8')
r0, c0 = 1 + shift, 5
r1, c1 = 6 + shift, 11
r2, c2 = 1 + shift, 14
rr, cc = bezier_curve(r0, c0, r1, c1, r2, c2, 2, shape=None)
img_[rr, cc] = 1
assert_array_equal(img, img_[shift:-shift, :])
def test_polygon_perimeter():
expected = np.array(
[[1, 1, 1, 1],
[1, 0, 0, 1],
[1, 1, 1, 1]]
)
out = np.zeros_like(expected)
rr, cc = polygon_perimeter([0, 2, 2, 0],
[0, 0, 3, 3])
out[rr, cc] = 1
assert_array_equal(out, expected)
out = np.zeros_like(expected)
rr, cc = polygon_perimeter([-1, -1, 3, 3],
[-1, 4, 4, -1],
shape=out.shape, clip=True)
out[rr, cc] = 1
assert_array_equal(out, expected)
with testing.raises(ValueError):
polygon_perimeter([0], [1], clip=True)
def test_polygon_perimeter_outside_image():
rr, cc = polygon_perimeter([-1, -1, 3, 3],
[-1, 4, 4, -1], shape=(3, 4))
assert_equal(len(rr), 0)
assert_equal(len(cc), 0)
def test_rectangle_end():
expected = np.array([[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 0, 0, 0, 0]], dtype=np.uint8)
start = (0, 1)
end = (3, 3)
img = np.zeros((5, 5), dtype=np.uint8)
rr, cc = rectangle(start, end=end, shape=img.shape)
img[rr, cc] = 1
assert_array_equal(img, expected)
# Swap start and end
img = np.zeros((5, 5), dtype=np.uint8)
rr, cc = rectangle(end=start, start=end, shape=img.shape)
img[rr, cc] = 1
assert_array_equal(img, expected)
# Bottom left and top right
img = np.zeros((5, 5), dtype=np.uint8)
rr, cc = rectangle(start=(3, 1), end=(0, 3), shape=img.shape)
img[rr, cc] = 1
assert_array_equal(img, expected)
img = np.zeros((5, 5), dtype=np.uint8)
rr, cc = rectangle(end=(3, 1), start=(0, 3), shape=img.shape)
img[rr, cc] = 1
assert_array_equal(img, expected)
def test_rectangle_extent():
expected = np.array([[0, 0, 0, 0, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 1, 1, 1, 0],
[0, 0, 0, 0, 0]], dtype=np.uint8)
start = (1, 1)
extent = (3, 3)
img = np.zeros((5, 5), dtype=np.uint8)
rr, cc = rectangle(start, extent=extent, shape=img.shape)
img[rr, cc] = 1
assert_array_equal(img, expected)
img = np.zeros((5, 5, 3), dtype=np.uint8)
rr, cc = rectangle(start, extent=extent, shape=img.shape)
img[rr, cc, 0] = 1
expected_2 = np.zeros_like(img)
expected_2[..., 0] = expected
assert_array_equal(img, expected_2)
def test_rectangle_extent_negative():
# These two tests should be done together.
expected = np.array([[0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 1],
[0, 0, 1, 2, 2, 1],
[0, 0, 1, 1, 1, 1],
[0, 0, 0, 0, 0, 0]], dtype=np.uint8)
start = (3, 5)
extent = (-1, -2)
img = np.zeros(expected.shape, dtype=np.uint8)
rr, cc = rectangle_perimeter(start, extent=extent, shape=img.shape)
img[rr, cc] = 1
rr, cc = rectangle(start, extent=extent, shape=img.shape)
img[rr, cc] = 2
assert_array_equal(img, expected)
# Ensure that rr and cc have no overlap
img = np.zeros(expected.shape, dtype=np.uint8)
rr, cc = rectangle(start, extent=extent, shape=img.shape)
img[rr, cc] = 2
rr, cc = rectangle_perimeter(start, extent=extent, shape=img.shape)
img[rr, cc] = 1
assert_array_equal(img, expected)
def test_rectangle_perimiter():
expected = np.array([[0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 1],
[0, 0, 1, 0, 0, 1],
[0, 0, 1, 1, 1, 1],
[0, 0, 0, 0, 0, 0]], dtype=np.uint8)
start = (2, 3)
end = (2, 4)
img = np.zeros(expected.shape, dtype=np.uint8)
# Test that the default parameter is indeed end
rr, cc = rectangle_perimeter(start, end, shape=img.shape)
img[rr, cc] = 1
assert_array_equal(img, expected)
# Swap start and end
img = np.zeros(expected.shape, dtype=np.uint8)
rr, cc = rectangle_perimeter(end=start, start=end, shape=img.shape)
img[rr, cc] = 1
assert_array_equal(img, expected)
img = np.zeros(expected.shape, dtype=np.uint8)
start = (2, 3)
extent = (1, 2)
rr, cc = rectangle_perimeter(start, extent=extent, shape=img.shape)
img[rr, cc] = 1
assert_array_equal(img, expected)
def test_rectangle_perimiter_clip_bottom_right():
# clip=False
expected = np.array([[0, 0, 0, 0, 0],
[0, 1, 1, 1, 1],
[0, 1, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 1, 0, 0, 0]], dtype=np.uint8)
img = np.zeros((5, 5), dtype=np.uint8)
start = (2, 2)
extent = (10, 10)
rr, cc = rectangle_perimeter(start, extent=extent, shape=img.shape,
clip=False)
img[rr, cc] = 1
assert_array_equal(img, expected)
# clip=True
expected = np.array([[0, 0, 0, 0, 0],
[0, 1, 1, 1, 1],
[0, 1, 0, 0, 1],
[0, 1, 0, 0, 1],
[0, 1, 1, 1, 1]], dtype=np.uint8)
img = np.zeros((5, 5), dtype=np.uint8)
rr, cc = rectangle_perimeter(start, extent=extent, shape=img.shape,
clip=True)
img[rr, cc] = 1
assert_array_equal(img, expected)
def test_rectangle_perimiter_clip_top_left():
# clip=False
expected = np.array([[0, 0, 0, 1, 0],
[0, 0, 0, 1, 0],
[0, 0, 0, 1, 0],
[1, 1, 1, 1, 0],
[0, 0, 0, 0, 0]], dtype=np.uint8)
img = np.zeros((5, 5), dtype=np.uint8)
start = (-5, -5)
end = (2, 2)
rr, cc = rectangle_perimeter(start, end=end, shape=img.shape,
clip=False)
img[rr, cc] = 1
assert_array_equal(img, expected)
# clip=True
expected = np.array([[1, 1, 1, 1, 0],
[1, 0, 0, 1, 0],
[1, 0, 0, 1, 0],
[1, 1, 1, 1, 0],
[0, 0, 0, 0, 0]], dtype=np.uint8)
img = np.zeros((5, 5), dtype=np.uint8)
rr, cc = rectangle_perimeter(start, end=end, shape=img.shape,
clip=True)
img[rr, cc] = 1
assert_array_equal(img, expected)
def test_rectangle_perimiter_clip_top_right():
expected = np.array([[0, 1, 1, 1, 1],
[0, 1, 0, 0, 1],
[0, 1, 0, 0, 1],
[0, 1, 1, 1, 1],
[0, 0, 0, 0, 0]], dtype=np.uint8)
img = np.zeros((5, 5), dtype=np.uint8)
start = (-10, 2)
end = (2, 10)
rr, cc = rectangle_perimeter(start, end=end, shape=img.shape,
clip=True)
img[rr, cc] = 1
assert_array_equal(img, expected)
expected = np.array([[0, 1, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 1, 1, 1, 1],
[0, 0, 0, 0, 0]], dtype=np.uint8)
img = np.zeros((5, 5), dtype=np.uint8)
rr, cc = rectangle_perimeter(start, end=end, shape=img.shape,
clip=False)
img[rr, cc] = 1
assert_array_equal(img, expected)
def test_rectangle_perimiter_clip_bottom_left():
expected = np.array([[0, 0, 0, 0, 0],
[1, 1, 1, 0, 0],
[1, 0, 1, 0, 0],
[1, 0, 1, 0, 0],
[1, 1, 1, 0, 0]], dtype=np.uint8)
img = np.zeros((5, 5), dtype=np.uint8)
start = (2, -3)
end = (10, 1)
rr, cc = rectangle_perimeter(start, end=end, shape=img.shape,
clip=True)
img[rr, cc] = 1
assert_array_equal(img, expected)
expected = np.array([[0, 0, 0, 0, 0],
[1, 1, 1, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 1, 0, 0]], dtype=np.uint8)
img = np.zeros((5, 5), dtype=np.uint8)
rr, cc = rectangle_perimeter(start, end=end, shape=img.shape,
clip=False)
img[rr, cc] = 1
assert_array_equal(img, expected)
```
#### File: skimage/feature/orb.py
```python
import numpy as np
from ..feature.util import (FeatureDetector, DescriptorExtractor,
_mask_border_keypoints,
_prepare_grayscale_input_2D)
from ..feature import (corner_fast, corner_orientations, corner_peaks,
corner_harris)
from ..transform import pyramid_gaussian
from .._shared.utils import check_nD
from .orb_cy import _orb_loop
OFAST_MASK = np.zeros((31, 31))
OFAST_UMAX = [15, 15, 15, 15, 14, 14, 14, 13, 13, 12, 11, 10, 9, 8, 6, 3]
for i in range(-15, 16):
for j in range(-OFAST_UMAX[abs(i)], OFAST_UMAX[abs(i)] + 1):
OFAST_MASK[15 + j, 15 + i] = 1
class ORB(FeatureDetector, DescriptorExtractor):
"""Oriented FAST and rotated BRIEF feature detector and binary descriptor
extractor.
Parameters
----------
n_keypoints : int, optional
Number of keypoints to be returned. The function will return the best
`n_keypoints` according to the Harris corner response if more than
`n_keypoints` are detected. If not, then all the detected keypoints
are returned.
fast_n : int, optional
The `n` parameter in `skimage.feature.corner_fast`. Minimum number of
consecutive pixels out of 16 pixels on the circle that should all be
either brighter or darker w.r.t test-pixel. A point c on the circle is
darker w.r.t test pixel p if ``Ic < Ip - threshold`` and brighter if
``Ic > Ip + threshold``. Also stands for the n in ``FAST-n`` corner
detector.
fast_threshold : float, optional
The ``threshold`` parameter in ``feature.corner_fast``. Threshold used
to decide whether the pixels on the circle are brighter, darker or
similar w.r.t. the test pixel. Decrease the threshold when more
corners are desired and vice-versa.
harris_k : float, optional
The `k` parameter in `skimage.feature.corner_harris`. Sensitivity
factor to separate corners from edges, typically in range ``[0, 0.2]``.
Small values of `k` result in detection of sharp corners.
downscale : float, optional
Downscale factor for the image pyramid. Default value 1.2 is chosen so
that there are more dense scales which enable robust scale invariance
for a subsequent feature description.
n_scales : int, optional
Maximum number of scales from the bottom of the image pyramid to
extract the features from.
Attributes
----------
keypoints : (N, 2) array
Keypoint coordinates as ``(row, col)``.
scales : (N, ) array
Corresponding scales.
orientations : (N, ) array
Corresponding orientations in radians.
responses : (N, ) array
Corresponding Harris corner responses.
descriptors : (Q, `descriptor_size`) array of dtype bool
2D array of binary descriptors of size `descriptor_size` for Q
keypoints after filtering out border keypoints with value at an
index ``(i, j)`` either being ``True`` or ``False`` representing
the outcome of the intensity comparison for i-th keypoint on j-th
decision pixel-pair. It is ``Q == np.sum(mask)``.
References
----------
.. [1] <NAME>, <NAME>, <NAME> and <NAME>
"ORB: An efficient alternative to SIFT and SURF"
http://www.vision.cs.chubu.ac.jp/CV-R/pdf/Rublee_iccv2011.pdf
Examples
--------
>>> from skimage.feature import ORB, match_descriptors
>>> img1 = np.zeros((100, 100))
>>> img2 = np.zeros_like(img1)
>>> np.random.seed(1)
>>> square = np.random.rand(20, 20)
>>> img1[40:60, 40:60] = square
>>> img2[53:73, 53:73] = square
>>> detector_extractor1 = ORB(n_keypoints=5)
>>> detector_extractor2 = ORB(n_keypoints=5)
>>> detector_extractor1.detect_and_extract(img1)
>>> detector_extractor2.detect_and_extract(img2)
>>> matches = match_descriptors(detector_extractor1.descriptors,
... detector_extractor2.descriptors)
>>> matches
array([[0, 0],
[1, 1],
[2, 2],
[3, 3],
[4, 4]])
>>> detector_extractor1.keypoints[matches[:, 0]]
array([[ 42., 40.],
[ 47., 58.],
[ 44., 40.],
[ 59., 42.],
[ 45., 44.]])
>>> detector_extractor2.keypoints[matches[:, 1]]
array([[ 55., 53.],
[ 60., 71.],
[ 57., 53.],
[ 72., 55.],
[ 58., 57.]])
"""
def __init__(self, downscale=1.2, n_scales=8,
n_keypoints=500, fast_n=9, fast_threshold=0.08,
harris_k=0.04):
self.downscale = downscale
self.n_scales = n_scales
self.n_keypoints = n_keypoints
self.fast_n = fast_n
self.fast_threshold = fast_threshold
self.harris_k = harris_k
self.keypoints = None
self.scales = None
self.responses = None
self.orientations = None
self.descriptors = None
def _build_pyramid(self, image):
image = _prepare_grayscale_input_2D(image)
return list(pyramid_gaussian(image, self.n_scales - 1,
self.downscale, multichannel=False))
def _detect_octave(self, octave_image):
# Extract keypoints for current octave
fast_response = corner_fast(octave_image, self.fast_n,
self.fast_threshold)
keypoints = corner_peaks(fast_response, min_distance=1)
if len(keypoints) == 0:
return (np.zeros((0, 2), dtype=np.double),
np.zeros((0, ), dtype=np.double),
np.zeros((0, ), dtype=np.double))
mask = _mask_border_keypoints(octave_image.shape, keypoints,
distance=16)
keypoints = keypoints[mask]
orientations = corner_orientations(octave_image, keypoints,
OFAST_MASK)
harris_response = corner_harris(octave_image, method='k',
k=self.harris_k)
responses = harris_response[keypoints[:, 0], keypoints[:, 1]]
return keypoints, orientations, responses
def detect(self, image):
"""Detect oriented FAST keypoints along with the corresponding scale.
Parameters
----------
image : 2D array
Input image.
"""
check_nD(image, 2)
pyramid = self._build_pyramid(image)
keypoints_list = []
orientations_list = []
scales_list = []
responses_list = []
for octave in range(len(pyramid)):
octave_image = np.ascontiguousarray(pyramid[octave])
keypoints, orientations, responses = \
self._detect_octave(octave_image)
keypoints_list.append(keypoints * self.downscale ** octave)
orientations_list.append(orientations)
scales_list.append(np.full(
keypoints.shape[0], self.downscale ** octave, dtype='float64'))
responses_list.append(responses)
keypoints = np.vstack(keypoints_list)
orientations = np.hstack(orientations_list)
scales = np.hstack(scales_list)
responses = np.hstack(responses_list)
if keypoints.shape[0] < self.n_keypoints:
self.keypoints = keypoints
self.scales = scales
self.orientations = orientations
self.responses = responses
else:
# Choose best n_keypoints according to Harris corner response
best_indices = responses.argsort()[::-1][:self.n_keypoints]
self.keypoints = keypoints[best_indices]
self.scales = scales[best_indices]
self.orientations = orientations[best_indices]
self.responses = responses[best_indices]
def _extract_octave(self, octave_image, keypoints, orientations):
mask = _mask_border_keypoints(octave_image.shape, keypoints,
distance=20)
keypoints = np.array(keypoints[mask], dtype=np.intp, order='C',
copy=False)
orientations = np.array(orientations[mask], dtype=np.double, order='C',
copy=False)
descriptors = _orb_loop(octave_image, keypoints, orientations)
return descriptors, mask
def extract(self, image, keypoints, scales, orientations):
"""Extract rBRIEF binary descriptors for given keypoints in image.
Note that the keypoints must be extracted using the same `downscale`
and `n_scales` parameters. Additionally, if you want to extract both
keypoints and descriptors you should use the faster
`detect_and_extract`.
Parameters
----------
image : 2D array
Input image.
keypoints : (N, 2) array
Keypoint coordinates as ``(row, col)``.
scales : (N, ) array
Corresponding scales.
orientations : (N, ) array
Corresponding orientations in radians.
"""
check_nD(image, 2)
pyramid = self._build_pyramid(image)
descriptors_list = []
mask_list = []
# Determine octaves from scales
octaves = (np.log(scales) / np.log(self.downscale)).astype(np.intp)
for octave in range(len(pyramid)):
# Mask for all keypoints in current octave
octave_mask = octaves == octave
if np.sum(octave_mask) > 0:
octave_image = np.ascontiguousarray(pyramid[octave])
octave_keypoints = keypoints[octave_mask]
octave_keypoints /= self.downscale ** octave
octave_orientations = orientations[octave_mask]
descriptors, mask = self._extract_octave(octave_image,
octave_keypoints,
octave_orientations)
descriptors_list.append(descriptors)
mask_list.append(mask)
self.descriptors = np.vstack(descriptors_list).view(np.bool)
self.mask_ = np.hstack(mask_list)
def detect_and_extract(self, image):
"""Detect oriented FAST keypoints and extract rBRIEF descriptors.
Note that this is faster than first calling `detect` and then
`extract`.
Parameters
----------
image : 2D array
Input image.
"""
check_nD(image, 2)
pyramid = self._build_pyramid(image)
keypoints_list = []
responses_list = []
scales_list = []
orientations_list = []
descriptors_list = []
for octave in range(len(pyramid)):
octave_image = np.ascontiguousarray(pyramid[octave])
keypoints, orientations, responses = \
self._detect_octave(octave_image)
if len(keypoints) == 0:
keypoints_list.append(keypoints)
responses_list.append(responses)
descriptors_list.append(np.zeros((0, 256), dtype=np.bool))
continue
descriptors, mask = self._extract_octave(octave_image, keypoints,
orientations)
scaled_keypoints = keypoints[mask] * self.downscale ** octave
keypoints_list.append(scaled_keypoints)
responses_list.append(responses[mask])
orientations_list.append(orientations[mask])
scales_list.append(self.downscale ** octave *
np.ones(scaled_keypoints.shape[0], dtype=np.intp))
descriptors_list.append(descriptors)
if len(scales_list) == 0:
raise RuntimeError(
"ORB found no features. Try passing in an image containing "
"greater intensity contrasts between adjacent pixels.")
keypoints = np.vstack(keypoints_list)
responses = np.hstack(responses_list)
scales = np.hstack(scales_list)
orientations = np.hstack(orientations_list)
descriptors = np.vstack(descriptors_list).view(np.bool)
if keypoints.shape[0] < self.n_keypoints:
self.keypoints = keypoints
self.scales = scales
self.orientations = orientations
self.responses = responses
self.descriptors = descriptors
else:
# Choose best n_keypoints according to Harris corner response
best_indices = responses.argsort()[::-1][:self.n_keypoints]
self.keypoints = keypoints[best_indices]
self.scales = scales[best_indices]
self.orientations = orientations[best_indices]
self.responses = responses[best_indices]
self.descriptors = descriptors[best_indices]
```
#### File: feature/tests/test_register_translation.py
```python
import numpy as np
from skimage._shared.testing import assert_allclose
from skimage.feature.register_translation import (register_translation,
_upsampled_dft)
from skimage.data import camera, binary_blobs
from scipy.ndimage import fourier_shift
from skimage import img_as_float
from skimage._shared import testing
from skimage._shared.fft import fftmodule as fft
def test_correlation():
reference_image = fft.fftn(camera())
shift = (-7, 12)
shifted_image = fourier_shift(reference_image, shift)
# pixel precision
result, error, diffphase = register_translation(reference_image,
shifted_image,
space="fourier")
assert_allclose(result[:2], -np.array(shift))
def test_subpixel_precision():
reference_image = fft.fftn(camera())
subpixel_shift = (-2.4, 1.32)
shifted_image = fourier_shift(reference_image, subpixel_shift)
# subpixel precision
result, error, diffphase = register_translation(reference_image,
shifted_image, 100,
space="fourier")
assert_allclose(result[:2], -np.array(subpixel_shift), atol=0.05)
def test_real_input():
reference_image = camera()
subpixel_shift = (-2.4, 1.32)
shifted_image = fourier_shift(fft.fftn(reference_image), subpixel_shift)
shifted_image = fft.ifftn(shifted_image)
# subpixel precision
result, error, diffphase = register_translation(reference_image,
shifted_image, 100)
assert_allclose(result[:2], -np.array(subpixel_shift), atol=0.05)
def test_size_one_dimension_input():
# take a strip of the input image
reference_image = fft.fftn(camera()[:, 15]).reshape((-1, 1))
subpixel_shift = (-2.4, 4)
shifted_image = fourier_shift(reference_image, subpixel_shift)
# subpixel precision
result, error, diffphase = register_translation(reference_image,
shifted_image, 20,
space="fourier")
assert_allclose(result[:2], -np.array((-2.4, 0)), atol=0.05)
def test_3d_input():
phantom = img_as_float(binary_blobs(length=32, n_dim=3))
reference_image = fft.fftn(phantom)
shift = (-2., 1., 5.)
shifted_image = fourier_shift(reference_image, shift)
result, error, diffphase = register_translation(reference_image,
shifted_image,
space="fourier")
assert_allclose(result, -np.array(shift), atol=0.05)
# subpixel precision now available for 3-D data
subpixel_shift = (-2.3, 1.7, 5.4)
shifted_image = fourier_shift(reference_image, subpixel_shift)
result, error, diffphase = register_translation(reference_image,
shifted_image,
100,
space="fourier")
assert_allclose(result, -np.array(subpixel_shift), atol=0.05)
def test_unknown_space_input():
image = np.ones((5, 5))
with testing.raises(ValueError):
register_translation(
image, image,
space="frank")
def test_wrong_input():
# Dimensionality mismatch
image = np.ones((5, 5, 1))
template = np.ones((5, 5))
with testing.raises(ValueError):
register_translation(template, image)
# Size mismatch
image = np.ones((5, 5))
template = np.ones((4, 4))
with testing.raises(ValueError):
register_translation(template, image)
def test_4d_input_pixel():
phantom = img_as_float(binary_blobs(length=32, n_dim=4))
reference_image = fft.fftn(phantom)
shift = (-2., 1., 5., -3)
shifted_image = fourier_shift(reference_image, shift)
result, error, diffphase = register_translation(reference_image,
shifted_image,
space="fourier")
assert_allclose(result, -np.array(shift), atol=0.05)
def test_4d_input_subpixel():
phantom = img_as_float(binary_blobs(length=32, n_dim=4))
reference_image = fft.fftn(phantom)
subpixel_shift = (-2.3, 1.7, 5.4, -3.2)
shifted_image = fourier_shift(reference_image, subpixel_shift)
result, error, diffphase = register_translation(reference_image,
shifted_image,
10,
space="fourier")
assert_allclose(result, -np.array(subpixel_shift), atol=0.05)
def test_mismatch_upsampled_region_size():
with testing.raises(ValueError):
_upsampled_dft(
np.ones((4, 4)),
upsampled_region_size=[3, 2, 1, 4])
def test_mismatch_offsets_size():
with testing.raises(ValueError):
_upsampled_dft(np.ones((4, 4)), 3,
axis_offsets=[3, 2, 1, 4])
```
#### File: filters/tests/test_ridges.py
```python
import numpy as np
from numpy.testing import assert_allclose, assert_array_less, assert_equal
from skimage.filters import meijering, sato, frangi, hessian
from skimage.data import camera
from skimage.util import crop, invert
def test_2d_null_matrix():
a_black = np.zeros((3, 3)).astype(np.uint8)
a_white = invert(a_black)
zeros = np.zeros((3, 3))
ones = np.ones((3, 3))
assert_equal(meijering(a_black, black_ridges=True), ones)
assert_equal(meijering(a_white, black_ridges=False), ones)
assert_equal(sato(a_black, black_ridges=True), zeros)
assert_equal(sato(a_white, black_ridges=False), zeros)
assert_allclose(frangi(a_black, black_ridges=True), zeros, atol=1e-3)
assert_allclose(frangi(a_white, black_ridges=False), zeros, atol=1e-3)
assert_equal(hessian(a_black, black_ridges=False), ones)
assert_equal(hessian(a_white, black_ridges=True), ones)
def test_3d_null_matrix():
a_black = np.zeros((3, 3, 3)).astype(np.uint8)
a_white = invert(a_black)
zeros = np.zeros((3, 3, 3))
ones = np.ones((3, 3, 3))
assert_allclose(meijering(a_black, black_ridges=True), ones, atol=1e-1)
assert_allclose(meijering(a_white, black_ridges=False), ones, atol=1e-1)
assert_equal(sato(a_black, black_ridges=True), zeros)
assert_equal(sato(a_white, black_ridges=False), zeros)
assert_allclose(frangi(a_black, black_ridges=True), zeros, atol=1e-3)
assert_allclose(frangi(a_white, black_ridges=False), zeros, atol=1e-3)
assert_equal(hessian(a_black, black_ridges=False), ones)
assert_equal(hessian(a_white, black_ridges=True), ones)
def test_2d_energy_decrease():
a_black = np.zeros((5, 5)).astype(np.uint8)
a_black[2, 2] = 255
a_white = invert(a_black)
assert_array_less(meijering(a_black, black_ridges=True).std(),
a_black.std())
assert_array_less(meijering(a_white, black_ridges=False).std(),
a_white.std())
assert_array_less(sato(a_black, black_ridges=True).std(), a_black.std())
assert_array_less(sato(a_white, black_ridges=False).std(), a_white.std())
assert_array_less(frangi(a_black, black_ridges=True).std(),
a_black.std())
assert_array_less(frangi(a_white, black_ridges=False).std(),
a_white.std())
assert_array_less(hessian(a_black, black_ridges=True).std(),
a_black.std())
assert_array_less(hessian(a_white, black_ridges=False).std(),
a_white.std())
def test_3d_energy_decrease():
a_black = np.zeros((5, 5, 5)).astype(np.uint8)
a_black[2, 2, 2] = 255
a_white = invert(a_black)
assert_array_less(meijering(a_black, black_ridges=True).std(),
a_black.std())
assert_array_less(meijering(a_white, black_ridges=False).std(),
a_white.std())
assert_array_less(sato(a_black, black_ridges=True).std(), a_black.std())
assert_array_less(sato(a_white, black_ridges=False).std(), a_white.std())
assert_array_less(frangi(a_black, black_ridges=True).std(),
a_black.std())
assert_array_less(frangi(a_white, black_ridges=False).std(),
a_white.std())
assert_array_less(hessian(a_black, black_ridges=True).std(),
a_black.std())
assert_array_less(hessian(a_white, black_ridges=False).std(),
a_white.std())
def test_2d_linearity():
a_black = np.ones((3, 3)).astype(np.uint8)
a_white = invert(a_black)
assert_allclose(meijering(1 * a_black, black_ridges=True),
meijering(10 * a_black, black_ridges=True), atol=1e-3)
assert_allclose(meijering(1 * a_white, black_ridges=False),
meijering(10 * a_white, black_ridges=False), atol=1e-3)
assert_allclose(sato(1 * a_black, black_ridges=True),
sato(10 * a_black, black_ridges=True), atol=1e-3)
assert_allclose(sato(1 * a_white, black_ridges=False),
sato(10 * a_white, black_ridges=False), atol=1e-3)
assert_allclose(frangi(1 * a_black, black_ridges=True),
frangi(10 * a_black, black_ridges=True), atol=1e-3)
assert_allclose(frangi(1 * a_white, black_ridges=False),
frangi(10 * a_white, black_ridges=False), atol=1e-3)
assert_allclose(hessian(1 * a_black, black_ridges=True),
hessian(10 * a_black, black_ridges=True), atol=1e-3)
assert_allclose(hessian(1 * a_white, black_ridges=False),
hessian(10 * a_white, black_ridges=False), atol=1e-3)
def test_3d_linearity():
a_black = np.ones((3, 3, 3)).astype(np.uint8)
a_white = invert(a_black)
assert_allclose(meijering(1 * a_black, black_ridges=True),
meijering(10 * a_black, black_ridges=True), atol=1e-3)
assert_allclose(meijering(1 * a_white, black_ridges=False),
meijering(10 * a_white, black_ridges=False), atol=1e-3)
assert_allclose(sato(1 * a_black, black_ridges=True),
sato(10 * a_black, black_ridges=True), atol=1e-3)
assert_allclose(sato(1 * a_white, black_ridges=False),
sato(10 * a_white, black_ridges=False), atol=1e-3)
assert_allclose(frangi(1 * a_black, black_ridges=True),
frangi(10 * a_black, black_ridges=True), atol=1e-3)
assert_allclose(frangi(1 * a_white, black_ridges=False),
frangi(10 * a_white, black_ridges=False), atol=1e-3)
assert_allclose(hessian(1 * a_black, black_ridges=True),
hessian(10 * a_black, black_ridges=True), atol=1e-3)
assert_allclose(hessian(1 * a_white, black_ridges=False),
hessian(10 * a_white, black_ridges=False), atol=1e-3)
def test_2d_cropped_camera_image():
a_black = crop(camera(), ((206, 206), (206, 206)))
a_white = invert(a_black)
zeros = np.zeros((100, 100))
ones = np.ones((100, 100))
assert_allclose(meijering(a_black, black_ridges=True),
meijering(a_white, black_ridges=False))
assert_allclose(sato(a_black, black_ridges=True),
sato(a_white, black_ridges=False))
assert_allclose(frangi(a_black, black_ridges=True), zeros, atol=1e-3)
assert_allclose(frangi(a_white, black_ridges=False), zeros, atol=1e-3)
assert_allclose(hessian(a_black, black_ridges=True), ones, atol=1 - 1e-7)
assert_allclose(hessian(a_white, black_ridges=False), ones, atol=1 - 1e-7)
def test_3d_cropped_camera_image():
a_black = crop(camera(), ((206, 206), (206, 206)))
a_black = np.dstack([a_black, a_black, a_black])
a_white = invert(a_black)
zeros = np.zeros((100, 100, 3))
ones = np.ones((100, 100, 3))
assert_allclose(meijering(a_black, black_ridges=True),
meijering(a_white, black_ridges=False))
assert_allclose(sato(a_black, black_ridges=True),
sato(a_white, black_ridges=False))
assert_allclose(frangi(a_black, black_ridges=True), zeros, atol=1e-3)
assert_allclose(frangi(a_white, black_ridges=False), zeros, atol=1e-3)
assert_allclose(hessian(a_black, black_ridges=True), ones, atol=1 - 1e-7)
assert_allclose(hessian(a_white, black_ridges=False), ones, atol=1 - 1e-7)
if __name__ == "__main__":
from numpy import testing
testing.run_module_suite()
```
#### File: skimage/metrics/_adapted_rand_error.py
```python
from .._shared.utils import check_shape_equality
from ._contingency_table import contingency_table
__all__ = ['adapted_rand_error']
def adapted_rand_error(image_true=None, image_test=None, *, table=None,
ignore_labels=(0,)):
r"""Compute Adapted Rand error as defined by the SNEMI3D contest. [1]_
Parameters
----------
image_true : ndarray of int
Ground-truth label image, same shape as im_test.
image_test : ndarray of int
Test image.
table : scipy.sparse array in crs format, optional
A contingency table built with skimage.evaluate.contingency_table.
If None, it will be computed on the fly.
ignore_labels : sequence of int, optional
Labels to ignore. Any part of the true image labeled with any of these
values will not be counted in the score.
Returns
-------
are : float
The adapted Rand error; equal to $1 - \frac{2pr}{p + r}$,
where $p$ and $r$ are the precision and recall described below.
prec : float
The adapted Rand precision: this is the number of pairs of pixels that
have the same label in the test label image *and* in the true image,
divided by the number in the test image.
rec : float
The adapted Rand recall: this is the number of pairs of pixels that
have the same label in the test label image *and* in the true image,
divided by the number in the true image.
Notes
-----
Pixels with label 0 in the true segmentation are ignored in the score.
References
----------
.. [1] <NAME>, Turaga SC, Berger DR, et al. (2015)
Crowdsourcing the creation of image segmentation algorithms
for connectomics. Front. Neuroanat. 9:142.
:DOI:`10.3389/fnana.2015.00142`
"""
if image_test is not None and image_true is not None:
check_shape_equality(image_true, image_test)
if table is None:
p_ij = contingency_table(image_true, image_test,
ignore_labels=ignore_labels, normalize=False)
else:
p_ij = table
# Sum of the joint distribution squared
sum_p_ij2 = p_ij.data @ p_ij.data - p_ij.sum()
a_i = p_ij.sum(axis=1).A.ravel()
b_i = p_ij.sum(axis=0).A.ravel()
# Sum of squares of the test segment sizes (this is 2x the number of pairs
# of pixels with the same label in im_test)
sum_a2 = a_i @ a_i - a_i.sum()
# Same for im_true
sum_b2 = b_i @ b_i - b_i.sum()
precision = sum_p_ij2 / sum_a2
recall = sum_p_ij2 / sum_b2
fscore = 2. * precision * recall / (precision + recall)
are = 1. - fscore
return are, precision, recall
```
#### File: morphology/tests/test_skeletonize_3d.py
```python
import os
import numpy as np
import scipy.ndimage as ndi
from skimage import io, draw, data_dir
from skimage.data import binary_blobs
from skimage.util import img_as_ubyte
from skimage.morphology import skeletonize, skeletonize_3d
from skimage._shared import testing
from skimage._shared.testing import assert_equal, assert_, parametrize
# basic behavior tests (mostly copied over from 2D skeletonize)
def test_skeletonize_wrong_dim():
im = np.zeros(5, dtype=np.uint8)
with testing.raises(ValueError):
skeletonize(im, method='lee')
im = np.zeros((5, 5, 5, 5), dtype=np.uint8)
with testing.raises(ValueError):
skeletonize(im, method='lee')
def test_skeletonize_1D_old_api():
# a corner case of an image of a shape(1, N)
im = np.ones((5, 1), dtype=np.uint8)
res = skeletonize_3d(im)
assert_equal(res, im)
def test_skeletonize_1D():
# a corner case of an image of a shape(1, N)
im = np.ones((5, 1), dtype=np.uint8)
res = skeletonize(im, method='lee')
assert_equal(res, im)
def test_skeletonize_no_foreground():
im = np.zeros((5, 5), dtype=np.uint8)
result = skeletonize(im, method='lee')
assert_equal(result, im)
def test_skeletonize_all_foreground():
im = np.ones((3, 4), dtype=np.uint8)
assert_equal(skeletonize(im, method='lee'),
np.array([[0, 0, 0, 0],
[1, 1, 1, 1],
[0, 0, 0, 0]], dtype=np.uint8))
def test_skeletonize_single_point():
im = np.zeros((5, 5), dtype=np.uint8)
im[3, 3] = 1
result = skeletonize(im, method='lee')
assert_equal(result, im)
def test_skeletonize_already_thinned():
im = np.zeros((5, 5), dtype=np.uint8)
im[3, 1:-1] = 1
im[2, -1] = 1
im[4, 0] = 1
result = skeletonize(im, method='lee')
assert_equal(result, im)
def test_dtype_conv():
# check that the operation does the right thing with floats etc
# also check non-contiguous input
img = np.random.random((16, 16))[::2, ::2]
img[img < 0.5] = 0
orig = img.copy()
res = skeletonize(img, method='lee')
img_max = img_as_ubyte(img).max()
assert_equal(res.dtype, np.uint8)
assert_equal(img, orig) # operation does not clobber the original
assert_equal(res.max(), img_max) # the intensity range is preserved
@parametrize("img", [
np.ones((8, 8), dtype=float), np.ones((4, 8, 8), dtype=float)
])
def test_input_with_warning(img):
# check that the input is not clobbered
# for 2D and 3D images of varying dtypes
check_input(img)
@parametrize("img", [
np.ones((8, 8), dtype=np.uint8), np.ones((4, 8, 8), dtype=np.uint8),
np.ones((8, 8), dtype=bool), np.ones((4, 8, 8), dtype=bool)
])
def test_input_without_warning(img):
# check that the input is not clobbered
# for 2D and 3D images of varying dtypes
check_input(img)
def check_input(img):
orig = img.copy()
skeletonize(img, method='lee')
assert_equal(img, orig)
def test_skeletonize_num_neighbours():
# an empty image
image = np.zeros((300, 300))
# foreground object 1
image[10:-10, 10:100] = 1
image[-100:-10, 10:-10] = 1
image[10:-10, -100:-10] = 1
# foreground object 2
rs, cs = draw.line(250, 150, 10, 280)
for i in range(10):
image[rs + i, cs] = 1
rs, cs = draw.line(10, 150, 250, 280)
for i in range(20):
image[rs + i, cs] = 1
# foreground object 3
ir, ic = np.indices(image.shape)
circle1 = (ic - 135)**2 + (ir - 150)**2 < 30**2
circle2 = (ic - 135)**2 + (ir - 150)**2 < 20**2
image[circle1] = 1
image[circle2] = 0
result = skeletonize(image, method='lee')
# there should never be a 2x2 block of foreground pixels in a skeleton
mask = np.array([[1, 1],
[1, 1]], np.uint8)
blocks = ndi.correlate(result, mask, mode='constant')
assert_(not np.any(blocks == 4))
def test_two_hole_image():
# test a simple 2D image against FIJI
img_o = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0],
[0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0],
[0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0],
[0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0],
[0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0],
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0],
[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
dtype=np.uint8)
img_f = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
dtype=np.uint8)
res = skeletonize(img_o, method='lee')
assert_equal(res, img_f)
def test_3d_vs_fiji():
# generate an image with blobs and compate its skeleton to
# the skeleton generated by FIJI
img = binary_blobs(32, 0.05, n_dim=3, seed=1234)
img = img[:-2, ...]
img = img.astype(np.uint8)*255
img_s = skeletonize(img)
img_f = io.imread(os.path.join(data_dir, "_blobs_3d_fiji_skeleton.tif"))
assert_equal(img_s, img_f)
```
#### File: registration/tests/test_tvl1.py
```python
import numpy as np
from skimage._shared import testing
from skimage.registration import optical_flow_tvl1
from skimage.transform import warp
def _sin_flow_gen(image0, max_motion=4.5, npics=5):
"""Generate a synthetic ground truth optical flow with a sinusoid as
first component.
Parameters:
----
image0: ndarray
The base image to be warped.
max_motion: float
Maximum flow magnitude.
npics: int
Number of sinusoid pics.
Returns
-------
flow, image1 : ndarray
The synthetic ground truth optical flow with a sinusoid as
first component and the corresponding warped image.
"""
grid = np.meshgrid(*[np.arange(n) for n in image0.shape], indexing='ij')
gt_flow = np.zeros_like(grid)
gt_flow[0, ...] = max_motion * np.sin(grid[0]/grid[0].max()*npics*np.pi)
image1 = warp(image0, grid-gt_flow, mode='nearest')
return gt_flow, image1
def test_2d_motion():
# Generate synthetic data
rnd = np.random.RandomState(0)
image0 = rnd.normal(size=(256, 256))
gt_flow, image1 = _sin_flow_gen(image0)
# Estimate the flow
flow = optical_flow_tvl1(image0, image1, attachment=5)
# Assert that the average absolute error is less then half a pixel
assert abs(flow - gt_flow) .mean() < 0.5
def test_3d_motion():
# Generate synthetic data
rnd = np.random.RandomState(0)
image0 = rnd.normal(size=(128, 128, 128))
gt_flow, image1 = _sin_flow_gen(image0)
# Estimate the flow
flow = optical_flow_tvl1(image0, image1, attachment=5)
# Assert that the average absolute error is less then half a pixel
assert abs(flow - gt_flow) .mean() < 0.5
def test_no_motion_2d():
rnd = np.random.RandomState(0)
img = rnd.normal(size=(256, 256))
flow = optical_flow_tvl1(img, img)
assert np.all(flow == 0)
def test_no_motion_3d():
rnd = np.random.RandomState(0)
img = rnd.normal(size=(128, 128, 128))
flow = optical_flow_tvl1(img, img)
assert np.all(flow == 0)
def test_optical_flow_dtype():
# Generate synthetic data
rnd = np.random.RandomState(0)
image0 = rnd.normal(size=(256, 256))
gt_flow, image1 = _sin_flow_gen(image0)
# Estimate the flow at double precision
flow_f64 = optical_flow_tvl1(image0, image1, attachment=5, dtype=np.float64)
assert flow_f64.dtype == np.float64
# Estimate the flow at single precision
flow_f32 = optical_flow_tvl1(image0, image1, attachment=5, dtype=np.float32)
assert flow_f32.dtype == np.float32
# Assert that floating point precision does not affect the quality
# of the estimated flow
assert np.abs(flow_f64 - flow_f32).mean() < 1e-3
def test_incompatible_shapes():
rnd = np.random.RandomState(0)
I0 = rnd.normal(size=(256, 256))
I1 = rnd.normal(size=(128, 256))
with testing.raises(ValueError):
u, v = optical_flow_tvl1(I0, I1)
def test_wrong_dtype():
rnd = np.random.RandomState(0)
img = rnd.normal(size=(256, 256))
with testing.raises(ValueError):
u, v = optical_flow_tvl1(img, img, dtype=np.int64)
```
#### File: _shared/tests/test_utils.py
```python
from skimage._shared.utils import (copy_func, check_nD)
import numpy.testing as npt
import numpy as np
from skimage._shared import testing
def test_check_nD():
z = np.random.random(200**2).reshape((200, 200))
x = z[10:30, 30:10]
with testing.raises(ValueError):
check_nD(x, 2)
def test_copyfunc():
def foo(a):
return a
bar = copy_func(foo, name='bar')
other = copy_func(foo)
npt.assert_equal(bar.__name__, 'bar')
npt.assert_equal(other.__name__, 'foo')
other.__name__ = 'other'
npt.assert_equal(foo.__name__, 'foo')
if __name__ == "__main__":
npt.run_module_suite()
``` |
{
"source": "99991/alpha-matting-dataset-generator-tool",
"score": 3
} |
#### File: 99991/alpha-matting-dataset-generator-tool/main.py
```python
import cv2
import numpy as np
import random, time, sys, os
from PIL import Image
def save_image(path, image, make_directory=True):
assert(image.dtype in [np.uint8, np.float32, np.float64])
if image.dtype in [np.float32, np.float64]:
image = np.clip(image*255, 0, 255).astype(np.uint8)
if make_directory:
directory, _ = os.path.split(path)
os.makedirs(directory, exist_ok=True)
image = Image.fromarray(image)
image.save(path)
cam_id = 0
def main():
cam = cv2.VideoCapture(cam_id)
try:
a = None
b = None
while True:
ok, image = cam.read()
if not ok:
print("Failed to read frame from", cam)
break
image = image.astype(np.float32) / 255.0
if a is None:
a = image
b = image
else:
a = np.minimum(a, image)
b = np.maximum(b, image)
alpha = 1.0 - (b - a).mean(axis=2)
preview = np.concatenate([
image.mean(axis=2),
alpha,
], axis=1)
scale = 2*576.0/preview.shape[1]
preview = cv2.resize(preview, None, fx=scale, fy=scale, interpolation=cv2.INTER_AREA)
cv2.imshow("preview", preview)
key = cv2.waitKey(1)
if key == ord('r'):
print("reset")
a = None
if key == ord('s'):
name = time.strftime("%Y-%m-%d-%H-%M-%S")
path = f"alpha/{name}.png"
save_image(path, alpha)
print("saved image", path)
if key == ord('q') or key == 27:
print("quit")
break
finally:
cam.release()
cv2.destroyAllWindows()
if __name__ == "__main__":
main()
``` |
{
"source": "99991/btree",
"score": 4
} |
#### File: 99991/btree/btree.py
```python
MIN_KEYS = 2
MAX_KEYS = MIN_KEYS*2 + 1
class Node(object):
def __init__(self):
self.n = 0
self.keys = [None] * MAX_KEYS
self.children = [None] * (MAX_KEYS + 1)
def is_leaf(self):
return self.children[0] is None
def is_full(self):
return self.n >= MAX_KEYS
def __str__(self):
if self.is_leaf():
return str(self.keys[:self.n])
s = ["["]
for i in range(self.n):
s.append(str(self.children[i]))
s.append(",")
s.append(str(self.keys[i]))
s.append(",")
s.append(str(self.children[self.n]))
s.append("]")
return "".join(s)
__repr__ = __str__
def find_key_index(node, key):
i = 0
while i < node.n and key > node.keys[i]:
i += 1
return i
def find_min(node):
while not node.is_leaf():
node = node.children[0]
return node.keys[0]
def find_max(node):
while not node.is_leaf():
node = node.children[node.n]
return node.keys[node.n - 1]
def traverse(node):
if node is not None:
for i in range(node.n):
yield from traverse(node.children[i])
yield node.keys[i]
yield from traverse(node.children[node.n])
def find(node, key):
while node is not None:
i = find_key_index(node, key)
if i < node.n and key == node.keys[i]:
return True
node = node.children[i]
return False
def insert_recursive(node, key):
# find key position in node
i = find_key_index(node, key)
# check if key already exists
if i < node.n and key == node.keys[i]: return
if node.is_leaf():
# insert key into leaf node
for j in range(node.n, i, -1):
node.keys[j] = node.keys[j - 1]
node.keys[i] = key
node.n += 1
else:
# insert key and possibly split child
split = insert_recursive(node.children[i], key)
# done if no split happened
if not split: return
# split result from insertion into child
split_key, right_node = split
# find split_key position in node
i = find_key_index(node, key)
# insert split_key and right_node from split into node
for j in range(node.n, i, -1):
node.keys[j] = node.keys[j - 1]
node.children[j + 1] = node.children[j]
node.keys[i] = split_key
node.children[i + 1] = right_node
node.n += 1
# split node into node and right part if it is full
if node.is_full():
# split in the middle like:
# node.keys / split_key / right.keys
# [:i_split] / [i_split] / [i_split + 1:]
i_split = node.n >> 1
split_key = node.keys[i_split]
right = Node()
right.n = node.n - (i_split + 1)
for i in range(right.n):
j = i + i_split + 1
right.keys[i] = node.keys[j]
right.children[i] = node.children[j]
node.keys[j] = None
node.children[j] = None
right.children[right.n] = node.children[node.n]
node.children[node.n] = None
node.n = i_split
return (split_key, right)
def insert(node, key):
# create new node if none exists yet
if node is None:
node = Node()
node.keys[0] = key
node.n = 1
return node
split = insert_recursive(node, key)
if split:
# create new parent node from node and split result
split_key, right_node = split
parent = Node()
parent.children[0] = node
parent.children[1] = right_node
parent.keys[0] = split_key
parent.n = 1
return parent
return node
def remove(node, key):
i = find_key_index(node, key)
if i < node.n and key == node.keys[i]:
if node.is_leaf():
# move keys[i+1:] to the left by 1
for j in range(i + 1, node.n):
node.keys[j - 1] = node.keys[j]
node.n -= 1
else:
# override key with predecessor from child, then fix child
predecessor = find_max(node.children[i])
node.keys[i] = predecessor
remove(node.children[i], predecessor)
fix(node, i)
else:
# key not found
if node.is_leaf(): return
remove(node.children[i], key)
# TODO why is this true?
assert(i <= node.n)
fix(node, i)
return node if node.n > 0 else node.children[0]
def merge(parent, i):
# merge child and its successor with parent's key[i] inbetween
child = parent.children[i]
successor = parent.children[i + 1]
# remove key from node by moving keys and children to the left by 1
key = parent.keys[i]
for j in range(i + 1, parent.n):
parent.keys[j - 1] = parent.keys[j]
parent.children[j] = parent.children[j + 1]
parent.children[parent.n] = None
parent.n -= 1
# append key and successor keys and children to child
child.keys[child.n] = key
for i in range(successor.n):
child.keys[child.n + 1 + i] = successor.keys[i]
child.children[child.n + 1 + i] = successor.children[i]
child.children[child.n + 1 + successor.n] = successor.children[successor.n]
child.n += successor.n + 1
def fix(node, i):
# make it so that node's child[i] has at least MIN_KEYS
if node.children[i].n >= MIN_KEYS: return
if i == 0:
# steal from successor if that node has keys
if node.children[i + 1].n > MIN_KEYS:
steal_from_successor(node, i)
else:
# merge child and its successor if both have few keys
merge(node, i)
else:
# steal from predecessor if that node has keys
if node.children[i - 1].n > MIN_KEYS:
steal_from_predecessor(node, i)
else:
# merge child and its predecessor if both have few keys
merge(node, i - 1)
def steal_from_predecessor(parent, i):
child = parent.children[i]
predecessor = parent.children[i - 1]
# move child keys and values to the right
child.children[child.n + 1] = child.children[child.n]
for j in reversed(range(child.n)):
child.keys[j + 1] = child.keys[j]
child.children[j + 1] = child.children[j]
# child steals key form parent and node from predecessor
child.keys[0] = parent.keys[i - 1]
child.children[0] = predecessor.children[predecessor.n]
# parent steals key from predecessor of child
parent.keys[i - 1] = predecessor.keys[predecessor.n - 1]
predecessor.children[predecessor.n] = None
child.n += 1
predecessor.n -= 1
def steal_from_successor(parent, i):
child = parent.children[i]
successor = parent.children[i + 1]
# child steals key from parent and node from successor
child.keys[child.n] = parent.keys[i]
child.children[child.n + 1] = successor.children[0]
# parent steals key from successor
parent.keys[i] = successor.keys[0]
# move successor keys and children to the left
for j in range(1, successor.n):
successor.keys[j - 1] = successor.keys[j]
successor.children[j - 1] = successor.children[j]
successor.children[successor.n - 1] = successor.children[successor.n]
successor.children[successor.n] = None
child.n += 1
successor.n -= 1
def get_depths(node, depth=0):
if node.is_leaf():
yield depth
else:
for i in range(node.n + 1):
yield from get_depths(node.children[i], depth + 1)
def check_node(node, lower_bound=-float("inf"), upper_bound=float("inf"), depth=0):
if node is None:
assert(depth == 0)
return
assert(node.n < MAX_KEYS)
if depth == 0:
depths = list(get_depths(node))
assert(all(depth == depths[0] for depth in depths))
else:
assert(node.n >= MIN_KEYS)
# check if keys exist
assert(all(node.keys[i] is not None for i in range(node.n)))
# check if keys are within bounds
assert(all(lower_bound < node.keys[i] < upper_bound for i in range(node.n)))
# check if either all or no childen exist
if node.is_leaf():
assert(all(node.children[i] is None for i in range(node.n + 1)))
else:
assert(all(node.children[i] is not None for i in range(node.n + 1)))
# check children within bounds
check_node(node.children[0], lower_bound, node.keys[0], depth + 1)
for i in range(1, node.n):
check_node(node.children[i], node.keys[i - 1], node.keys[i], depth + 1)
check_node(node.children[node.n], node.keys[node.n - 1], upper_bound, depth + 1)
class BTreeSet(object):
def __init__(self):
self.root = None
def add(self, key):
self.root = insert(self.root, key)
def remove(self, key):
self.root = remove(self.root, key)
def __iter__(self):
yield from traverse(self.root)
def check(self):
check_node(self.root)
def min(self):
return find_min(self.root)
def max(self):
return find_max(self.root)
def __in__(self, key):
return find(self.root, key)
def __str__(self):
return "BTreeSet(%s)" % str(self.root)
__repr__ = __str__
``` |
{
"source": "99991/cifar10-fast-simple",
"score": 3
} |
#### File: 99991/cifar10-fast-simple/model.py
```python
import torch
import torch.nn as nn
import torch.nn.functional as F
def label_smoothing_loss(inputs, targets, alpha):
log_probs = torch.nn.functional.log_softmax(inputs, dim=1, _stacklevel=5)
kl = -log_probs.mean(dim=1)
xent = torch.nn.functional.nll_loss(log_probs, targets, reduction="none")
loss = (1 - alpha) * xent + alpha * kl
return loss
class GhostBatchNorm(nn.BatchNorm2d):
def __init__(self, num_features, num_splits, **kw):
super().__init__(num_features, **kw)
running_mean = torch.zeros(num_features * num_splits)
running_var = torch.ones(num_features * num_splits)
self.weight.requires_grad = False
self.num_splits = num_splits
self.register_buffer("running_mean", running_mean)
self.register_buffer("running_var", running_var)
def train(self, mode=True):
if (self.training is True) and (mode is False):
# lazily collate stats when we are going to use them
self.running_mean = torch.mean(
self.running_mean.view(self.num_splits, self.num_features), dim=0
).repeat(self.num_splits)
self.running_var = torch.mean(
self.running_var.view(self.num_splits, self.num_features), dim=0
).repeat(self.num_splits)
return super().train(mode)
def forward(self, input):
n, c, h, w = input.shape
if self.training or not self.track_running_stats:
return F.batch_norm(
input.view(-1, c * self.num_splits, h, w),
self.running_mean,
self.running_var,
self.weight.repeat(self.num_splits),
self.bias.repeat(self.num_splits),
True,
self.momentum,
self.eps,
).view(n, c, h, w)
else:
return F.batch_norm(
input,
self.running_mean[: self.num_features],
self.running_var[: self.num_features],
self.weight,
self.bias,
False,
self.momentum,
self.eps,
)
def conv_bn_relu(c_in, c_out, kernel_size=(3, 3), padding=(1, 1)):
return nn.Sequential(
nn.Conv2d(c_in, c_out, kernel_size=kernel_size, padding=padding, bias=False),
GhostBatchNorm(c_out, num_splits=16),
nn.CELU(alpha=0.3),
)
def conv_pool_norm_act(c_in, c_out):
return nn.Sequential(
nn.Conv2d(c_in, c_out, kernel_size=(3, 3), padding=(1, 1), bias=False),
nn.MaxPool2d(kernel_size=2, stride=2),
GhostBatchNorm(c_out, num_splits=16),
nn.CELU(alpha=0.3),
)
def patch_whitening(data, patch_size=(3, 3)):
h, w = patch_size
c = data.size(1)
patches = data.unfold(2, h, 1).unfold(3, w, 1)
patches = patches.transpose(1, 3).reshape(-1, c, h, w).to(torch.float32)
n, c, h, w = patches.shape
X = patches.reshape(n, c * h * w)
X = X / (X.size(0) - 1) ** 0.5
covariance = X.t() @ X
eigenvalues, eigenvectors = torch.symeig(covariance, eigenvectors=True)
eigenvalues = eigenvalues.flip(0)
eigenvectors = eigenvectors.t().reshape(c * h * w, c, h, w).flip(0)
return eigenvectors / torch.sqrt(eigenvalues + 1e-2).view(-1, 1, 1, 1)
class ResNetBagOfTricks(nn.Module):
def __init__(self, first_layer_weights, c_in, c_out, scale_out):
super().__init__()
c = first_layer_weights.size(0)
conv1 = nn.Conv2d(c_in, c, kernel_size=(3, 3), padding=(1, 1), bias=False)
conv1.weight.data = first_layer_weights
conv1.weight.requires_grad = False
self.conv1 = conv1
self.conv2 = conv_bn_relu(c, 64, kernel_size=(1, 1), padding=0)
self.conv3 = conv_pool_norm_act(64, 128)
self.conv4 = conv_bn_relu(128, 128)
self.conv5 = conv_bn_relu(128, 128)
self.conv6 = conv_pool_norm_act(128, 256)
self.conv7 = conv_pool_norm_act(256, 512)
self.conv8 = conv_bn_relu(512, 512)
self.conv9 = conv_bn_relu(512, 512)
self.pool10 = nn.MaxPool2d(kernel_size=4, stride=4)
self.linear11 = nn.Linear(512, c_out, bias=False)
self.scale_out = scale_out
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = self.conv3(x)
x = x + self.conv5(self.conv4(x))
x = self.conv6(x)
x = self.conv7(x)
x = x + self.conv9(self.conv8(x))
x = self.pool10(x)
x = x.reshape(x.size(0), x.size(1))
x = self.linear11(x)
x = self.scale_out * x
return x
``` |
{
"source": "99991/foreground-estimation-evaluation",
"score": 3
} |
#### File: foreground-estimation-evaluation/scripts/compute_errors.py
```python
import os, json, util
import numpy as np
def compute_errors(directory):
errors_path = f"{directory}/errors.json"
try:
with open(errors_path) as f:
errors = json.load(f)
except FileNotFoundError:
errors = {}
for index in range(1, 28):
name = "GT%02d" % index
foreground_path = f"{directory}/converted/foreground/{name}.bmp"
true_foreground = util.load_image(foreground_path)
alpha_path = f"{directory}/gt_training_highres/{name}.png"
alpha = util.load_image(alpha_path, "gray")
is_unknown = np.logical_and(alpha > 0, alpha < 1)
fg_methods = os.listdir(f"{directory}/fg_methods")
for fg_method in sorted(fg_methods):
alpha_methods = os.listdir(f"{directory}/fg_methods/{fg_method}")
for alpha_method in sorted(alpha_methods):
path = f"{directory}/fg_methods/{fg_method}/{alpha_method}/{name}.bmp"
estimated_foreground = util.load_image(path)
for error_name, calculate_error in [
("SAD", util.calculate_sad_error),
("MSE", util.calculate_mse_error),
("GRAD", util.calculate_gradient_error),
]:
error = calculate_error(
estimated_foreground, true_foreground, is_unknown, alpha
)
print(name, fg_method, alpha_method, error_name, error)
keys = [fg_method, alpha_method, error_name]
d = errors
for key in keys:
d = d.setdefault(key, {})
d[name] = error
# Remove "continue" statement to look at images if you want to
continue
import matplotlib.pyplot as plt
for i, img in enumerate(
[estimated_foreground, true_foreground, alpha, is_unknown,]
):
plt.subplot(2, 2, 1 + i)
plt.imshow(img, cmap="gray")
plt.axis("off")
plt.show()
with open(errors_path, "w") as f:
json.dump(errors, f, indent=4)
if __name__ == "__main__":
compute_errors(util.find_data_directory())
```
#### File: foreground-estimation-evaluation/scripts/convert_lrgb_to_srgb.py
```python
import os, json, util
import numpy as np
def convert_lrgb_to_srgb(directory, gamma=2.0):
with open(os.path.join(directory, "whitepoint_matrices.json")) as f:
matrices = json.load(f)
def transform(image, matrix):
return (matrix @ image.reshape(-1, 3).T).T.reshape(image.shape)
for index in range(1, 28):
print("image", index, "of", 27)
path = os.path.join(directory, "input_with_gt_fgd/input/GT%02d.tif" % index)
lrgb = util.load_image(path)
lrgb = transform(lrgb, np.float64(matrices[str(index)]).reshape(3, 3))
lrgb = np.maximum(0, lrgb)
srgb = util.lrgb_to_srgb(lrgb, gamma)
srgb = np.clip(srgb, 0, 1)
image = srgb
path = os.path.join(directory, "input_with_gt_fgd/fgd/GT%02d.tif" % index)
lrgb = util.load_image(path)
lrgb = transform(lrgb, np.float64(matrices[str(index)]).reshape(3, 3))
lrgb = np.maximum(0, lrgb)
srgb = util.lrgb_to_srgb(lrgb, gamma)
srgb = np.clip(srgb, 0, 1)
foreground = srgb
path = os.path.join(directory, "converted/image/GT%02d.bmp" % index)
util.save_image(path, image)
path = os.path.join(directory, "converted/foreground/GT%02d.bmp" % index)
util.save_image(path, foreground)
if __name__ == "__main__":
convert_lrgb_to_srgb(util.find_data_directory())
```
#### File: foreground-estimation-evaluation/scripts/estimate_foreground.py
```python
import util
import numpy as np
def estimate_foreground_naive(image, alpha):
# Not the smartest of foreground estimation methods,
# but a good starting point to implement your own.
return image
def estimate_foreground_multilevel(image, alpha):
import pymatting
return pymatting.estimate_foreground_ml(
image,
alpha,
gradient_weight=0.1,
regularization=5e-3,
n_small_iterations=10,
# n_big_iterations=4 decreases error by a few percent, but will increase runtime
n_big_iterations=2,
)
def estimate_foregrounds(directory):
from pymatting import estimate_foreground_ml
# Add your own method here (method name, estimate_foreground function)
fg_methods = [
("multilevel", estimate_foreground_multilevel),
#("naive", estimate_foreground_naive),
]
alpha_methods = [
"gt",
"cf",
"idx",
"ifm",
"knn",
]
print("Running foreground estimation")
for index in range(1, 28):
name = "GT%02d" % index
path = f"{directory}/converted/image/{name}.bmp"
image = util.load_image(path)
for alpha_method in alpha_methods:
path = f"{directory}/alpha/{alpha_method}/{name}.png"
alpha = util.load_image(path, "gray")
for fg_method, estimate_foreground in fg_methods:
foreground = estimate_foreground(image, alpha)
print(
f'Processing image {name} with foreground estimation '
f'method {fg_method:10} and alpha matte {alpha_method:3}')
path = f"{directory}/fg_methods/{fg_method}/{alpha_method}/{name}.bmp"
util.save_image(path, foreground)
if __name__ == "__main__":
estimate_foregrounds(util.find_data_directory())
```
#### File: foreground-estimation-evaluation/scripts/fit_whitepoint_matrices.py
```python
import numpy as np
import os, json, util
def fit_whitepoint_matrices(directory, gamma=2.0):
output_path = os.path.join(directory, "whitepoint_matrices.json")
matrices = {}
print("Computing whitepoint transform matrices")
# fit matrix M to transform from have_lrgb to want_lrgb in least square sense
for index in range(1, 28):
print("image", index, "of", 27)
path = os.path.join(directory, "input_with_gt_fgd/input/GT%02d.tif" % index)
have_lrgb = util.load_image(path)
path = os.path.join(directory, "input_training_highres/GT%02d.png" % index)
want_srgb = util.load_image(path)
assert have_lrgb.shape[2] == 3
assert want_srgb.shape[2] == 3
want_lrgb = util.srgb_to_lrgb(want_srgb, gamma)
V = have_lrgb.reshape(-1, 3)
W = want_lrgb.reshape(-1, 3)
# minimize error function for M
# i.e. find 3-by-3 matrix M such that
# want_lrgb and have_lrgb are close
M = (W.T @ V) @ np.linalg.inv(V.T @ V)
# convert matrix entries to float so json.dump can handle them
matrices[index] = [[float(x) for x in row] for row in M]
# error function
error = np.mean(np.square(M @ V.T - W.T))
print("mean squared error: %f" % error)
# Remove "continue" statement to see differences between images
continue
import matplotlib.pyplot as plt
lrgb = (M @ V.T).T.reshape(want_lrgb.shape)
lrgb = np.maximum(0, lrgb)
srgb = util.lrgb_to_srgb(lrgb, gamma)
srgb = np.clip(srgb, 0, 1)
have_srgb = srgb
difference = np.abs(have_srgb - want_srgb)
nx = 2
ny = 3
plt.subplot(ny, nx, 1)
plt.title("have")
plt.imshow(have_srgb, vmin=0, vmax=1)
plt.axis("off")
plt.subplot(ny, nx, 2)
plt.title("want")
plt.imshow(want_srgb, vmin=0, vmax=1)
plt.axis("off")
plt.subplot(ny, nx, 3)
plt.title("clip(10*|difference|, 0, 1)")
plt.imshow(np.clip(10 * difference, 0, 1), cmap="gray", vmin=0, vmax=1)
plt.axis("off")
for channel, name in enumerate(["red", "green", "blue"]):
plt.subplot(ny, nx, 4 + channel)
plt.title(name + " channel histogram")
bins = np.linspace(0, 1, 256)
values = want_srgb[:, :, channel].flatten()
plt.hist(values, bins=bins, label="want", alpha=0.5)
values = have_srgb[:, :, channel].flatten()
plt.hist(values, bins=bins, label="have", alpha=0.5)
plt.legend()
plt.show()
with open(output_path, "w") as f:
json.dump(matrices, f, indent=4)
if __name__ == "__main__":
fit_whitepoint_matrices(util.find_data_directory())
```
#### File: foreground-estimation-evaluation/scripts/util.py
```python
from PIL import Image
import numpy as np
import os
from read_tiff import read_tiff
from scipy.ndimage import gaussian_filter, correlate
def find_data_directory():
if os.path.split(os.getcwd())[-1] == "scripts":
return "../data"
return "data"
def calculate_sad_error(image, true_image, mask, weights):
difference = weights[:, :, np.newaxis] * np.abs(image - true_image)
return np.sum(difference[mask])
def calculate_mse_error(image, true_image, mask, weights):
difference = weights[:, :, np.newaxis] * np.square(image - true_image)
return np.mean(difference[mask])
def calculate_gradient(image, sigma):
assert len(image.shape) == 2
r = int(3 * sigma)
x = np.linspace(-r, r, 2 * r + 1)
g = np.exp(-0.5 * np.square(x) / (sigma * sigma)) / (sigma * np.sqrt(2 * np.pi))
dg = -1.0 / sigma ** 2 * x * g
g /= np.linalg.norm(g)
dg /= np.linalg.norm(dg)
dx = correlate(correlate(image, dg.reshape(1, -1)), g.reshape(-1, 1))
dy = correlate(correlate(image, dg.reshape(-1, 1)), g.reshape(1, -1))
return np.sqrt(dx * dx + dy * dy)
def calculate_gradient_error(image, true_image, mask, weights, sigma=1.4):
result = 0.0
for channel in range(image.shape[2]):
g1 = calculate_gradient(image[:, :, channel], sigma)
g2 = calculate_gradient(true_image[:, :, channel], sigma)
difference = weights * np.square(g1 - g2)
result += np.sum(difference[mask])
return result
def load_image(path, mode=None):
if path.lower().rsplit(".", 1)[-1] in {"tif", "tiff"}:
image = read_tiff(path) / 65535.0
else:
image = np.array(Image.open(path))
if image.dtype == np.uint8:
image = image / 255.0
else:
image = image / 65535.0
if mode == "gray" and len(image.shape) == 3:
image = image[:, :, 0]
return image
def save_image(path, image, make_directory=True):
assert image.dtype in [np.uint8, np.float32, np.float64]
if image.dtype in [np.float32, np.float64]:
image = np.clip(image * 255, 0, 255).astype(np.uint8)
if make_directory:
directory, _ = os.path.split(path)
if len(directory) > 0:
os.makedirs(directory, exist_ok=True)
image = Image.fromarray(image)
image.save(path)
def lrgb_to_srgb(image, gamma):
threshold = 0.0031308
mask = image <= threshold
linear_term = 12.92 * image
exponential_term = 1.055 * image ** (1.0 / gamma) - 0.055
return linear_term * mask + (1 - mask) * exponential_term
def srgb_to_lrgb(image, gamma):
threshold = 0.04045
mask = image <= threshold
linear_term = (1.0 / 12.92) * image
exponential_term = ((image + 0.055) / 1.055) ** gamma
return linear_term * mask + (1 - mask) * exponential_term
``` |
{
"source": "99991/ParallelZipFile",
"score": 2
} |
#### File: 99991/ParallelZipFile/patch_zipfile.py
```python
import zipfile
class PatchedSharedFile(zipfile._SharedFile):
"""
Credits and thanks to <NAME> for this patch.
https://bugs.python.org/issue42369#msg396792
"""
def __init__(self, *args) -> None:
super().__init__(*args)
self.tell = lambda: self._pos
zipfile._SharedFile = PatchedSharedFile
```
#### File: 99991/ParallelZipFile/plot_benchmark.py
```python
import json
from collections import defaultdict
import matplotlib.pyplot as plt
def groupby(values, keyfunc):
"""Group values by key returned by keyfunc."""
groups = defaultdict(list)
for value in values:
key = keyfunc(value)
groups[key].append(value)
return groups
def main() -> None:
"""Plot benchmark results."""
with open("benchmark_results.json", encoding="utf-8") as f:
results = json.load(f)
def keyfunc(result):
return (result["zipfile"], result["threadcount"])
for (zipfile, threadcount), results in groupby(results, keyfunc).items():
results.sort(key=lambda result: result["filesize"])
filesizes = []
timings = []
for result in results:
filesizes.append(result["filesize"])
timings.append(1000 * sum(result["timings"]) / len(result["timings"]))
plt.loglog(
filesizes,
timings,
label=f"{zipfile} - {threadcount} Thread{'s'[:threadcount-1]}",
)
plt.legend()
plt.xlabel("File size [bytes]")
plt.ylabel("Milliseconds to process a 10 MB zip file (lower is better)")
plt.tight_layout()
plt.savefig("benchmark.png")
plt.show()
if __name__ == "__main__":
main()
``` |
{
"source": "99991/SimpleTextureAtlas",
"score": 3
} |
#### File: 99991/SimpleTextureAtlas/example_atlas_from_random_images.py
```python
from SimpleTextureAtlas import make_atlas
from PIL import Image
import random
# In this example, random images are created and packed into an atlas.
def make_images(n_images):
images = []
for _ in range(n_images):
# random color
r = random.randint(0, 255)
g = random.randint(0, 255)
b = random.randint(0, 255)
# random size
height = random.randint(20, 50)
width = random.randint(20, 50)
# image of random size and color
image = Image.new('RGB', (width, height), (r, g, b))
images.append(image)
return images
# make random images
images = make_images(500)
# pack them into atlas
atlas, offsets = make_atlas(images)
# print info
for i in range(len(images)):
x,y = offsets[i]
image = images[i]
print("place image %d of size %dx%d at (%d, %d)"
%(i, image.width, image.height, x, y))
atlas.show()
``` |
{
"source": "9999years/brandeis-classes",
"score": 3
} |
#### File: 9999years/brandeis-classes/course_science.py
```python
import itertools
import os.path
from collections import Counter
from glob import glob
from typing import List, Mapping
import brandeis
COURSES = {}
def all_courses() -> Mapping[str, List[brandeis.Course]]:
global COURSES
if COURSES:
return COURSES
else:
COURSES = read_all()
return COURSES
def read(fname: str) -> List[brandeis.Course]:
"""for initializing COURSES"""
with open(fname, "r") as f:
return brandeis.load_courses(f)
def read_all(outdir: str = "out") -> List[brandeis.Course]:
"""for initializing COURSES"""
pat = os.path.join(outdir, "*-*.json")
ret = {}
# theyre numbered so this works
for fname in sorted(glob(pat)):
base, *_ = os.path.basename(fname).split(os.path.extsep)
year, semester = base.split("-")
if semester == "1":
# january
# semester = '01'
pass
elif semester == "2":
# skip summer
continue
elif semester == "3":
# september
# semester = '09'
pass
else:
raise ValueError("Invalid semester number " + semester)
ret[f"{year}-{semester}"] = read(fname)
return ret
def display_semester(sem) -> str:
yr, sem = sem.split("-")
sem = {"1": "Spring", "3": "Fall",}[sem]
return f"{yr} {sem}"
def total_courses_per_subject():
ret = {}
for courses in all_courses().values():
for course in courses:
if course.subject not in ret:
ret[course.subject] = 0
ret[course.subject] += 1
return ret
def courses_per_subject():
ret = {}
for sem, courses in all_courses().items():
ret[sem] = Counter(map(lambda c: c.subject, courses))
return ret
def courses_per_semester(subj=None) -> List[int]:
ret = {}
for sem, courses in all_courses().items():
if subj is not None:
courses = list(filter(lambda c: c.subject == subj, courses))
ret[sem] = len(courses)
return ret
def students_per_semester(subj=None) -> List[int]:
ret = {}
for sem, courses in all_courses().items():
if subj is not None:
courses = list(filter(lambda c: c.subject == subj, courses))
ret[sem] = sum(map(lambda c: c.enrolled, courses))
return ret
def students_per_class():
total_courses = []
for sem, courses in all_courses().items():
total_courses.extend(courses)
ret = {}
for subj in brandeis.constants.SUBJECTS:
subj_courses = list(
filter(
lambda e: e > 0,
map(
lambda c: c.enrolled,
filter(lambda c: c.subject == subj, total_courses),
),
)
)
if subj_courses:
ret[subj] = sum(subj_courses) / len(subj_courses)
return ret
def students_per_class_total():
total_courses = []
for sem, courses in all_courses().items():
total_courses.extend(courses)
courses = list(filter(lambda e: e > 0, map(lambda c: c.enrolled, total_courses)))
return sum(courses) / len(courses)
def student_enrollments():
ret = {}
for sem, courses in all_courses().items():
ret[sem] = {}
for subj in brandeis.constants.SUBJECTS:
ret[sem][subj] = sum(
map(lambda c: c.enrolled, filter(lambda c: c.subject == subj, courses))
)
return ret
def sorted_dict(d):
return [(k, d[k]) for k in sorted(d, key=d.get, reverse=True)]
def printdict(d):
i = 0
print("[")
for sem, dat in d.items():
i += 1
sem = format(repr(display_semester(sem)), "13")
print("[", sem, ",", dat, "],")
print("]")
def main():
# corr = courses_per_semester()
# for sem, dat in courses_per_semester('COSI').items():
# corr[sem] = dat / corr[sem]
# print(*map(lambda x: f'{x[0]} | {x[1]}],', students_per_class().items()), sep='\n')
printdict(student_enrollments())
# print(*sorted_dict(students_per_class()['2018-3']), sep='\n')
# print(sorted(set(map(lambda c: c.subject, itertools.chain(*all_courses().values())))))
# subjects = total_courses_per_subject()
# subjects = [(k, subjects[k]) for k in sorted(subjects, key=subjects.get, reverse=True)]
# print(*[s[0] for s in subjects if s[1] > 500], sep='\n')
# for sem, courses in courses_per_subject().items():
# print(sem, ':', courses.most_common(5))
if __name__ == "__main__":
main()
```
#### File: brandeis-classes/test/test_brandeis.py
```python
from bs4 import BeautifulSoup
from brandeis_classes import brandeis
def read(fname, mode="r", encoding="utf-8"):
with open(fname, mode, encoding=encoding) as f:
return f.read()
def tr_to_soup(html):
return BeautifulSoup(html, "html.parser").find("tr")
def test_tr_to_course():
tr = tr_to_soup(read("test-data/cosi_119a_1.html"))
crs = brandeis.tr_to_course(tr, request_description=False)
assert crs.friendly_number == "COSI 119A_1"
assert crs.uni_reqs_str == "[sn]"
assert crs.name == "Autonomous Robotics Lab"
assert crs.class_number == 16905
assert crs.subject == "COSI"
assert crs.number == 119
assert crs.group == "A"
assert crs.section == "1"
assert crs.schedule == [
brandeis.CourseTime(
block="S3",
times="W 2:00 PM–4:50 PM",
location="Carl J. Shapiro ScienceCtrLL16",
info=None,
),
brandeis.CourseTime(
block="X3",
times="W 6:30 PM–9:20 PM",
location="Carl J. Shapiro ScienceCtrLL16",
info="Mandatory:",
),
]
assert crs.enrolled == 4
assert crs.limit == 10
assert crs.waiting == 0
assert crs.enrollment_status == "Open Consent Req."
assert (
crs.syllabus
== "https://moodle2.brandeis.edu/syllabus/public/0eedb7b65c693257c8d4d24ae46ba227.pdf"
)
assert crs.instructors == [
brandeis.Instructor(
name="<NAME>", id="69957fcf6528db656418863916878ea0e4046b09"
)
]
assert crs.uni_reqs == ["sn"]
assert crs.semester == None
assert crs.year == None
``` |
{
"source": "9999years/dotfiles",
"score": 2
} |
#### File: scripts/src/actions.py
```python
from __future__ import annotations
import contextlib
import enum
import os
import shlex
import shutil
import subprocess
import sys
import tempfile
from dataclasses import dataclass
from datetime import datetime
from enum import Enum
from pathlib import Path
from typing import Callable, Optional, Union
from humanize import naturalsize as fmt_bytes
from . import color as co
from . import log
from .schema import PrettyPath, ResolvedDotfile, ResolvedDotfilesJson
from .table import Align, Table
from .util import has_cmd
class ActionResult(Enum):
"""The result of a user action on a dotfile.
E.g. after diffing, we might want to ask again.
"""
# We fixed the dotfile. It's good now, and we did work.
OK = enum.auto()
# We skipped this dotfile, or otherwise didn't do work. It'll probably
# still need attention in the future, unless manually fixed.
SKIPPED = enum.auto()
# Ask the user what to do again, after an informative action like diffing
# the installed and repository files.
ASK_AGAIN = enum.auto()
# A dotfile-fixing action.
Action = Callable[[ResolvedDotfile], ActionResult]
# An action for scanning for new dotfiles.
ScanAction = Callable[[PrettyPath, ResolvedDotfilesJson], ActionResult]
def diff(dotfile: ResolvedDotfile) -> ActionResult:
"""
:returns: True if there were changes, else False
:raises CalledProcessException: if problems calling diff
"""
if has_cmd("delta"):
files = [
shlex.quote(str(name)) for name in [dotfile.installed.abs, dotfile.repo.abs]
]
proc = subprocess.run(
f"diff --unified {' '.join(files)} | delta", shell=True, check=False,
)
else:
proc = subprocess.run(
[
"diff",
"--unified",
"--color=always",
dotfile.installed.abs,
dotfile.repo.abs,
],
check=False,
)
if proc.returncode not in [0, 1]:
if has_cmd("delta"):
log.error(f"diff or delta exited with code {proc.returncode}")
else:
log.error(f"diff exited with code {proc.returncode}")
return ActionResult.ASK_AGAIN
SAME_MARKER = co.GRAY + co.DIM + "[same]" + co.RESET
def _pretty_iso(dt: datetime) -> str:
return dt.date().isoformat() + " " + co.GRAY + co.DIM + dt.strftime("%T") + co.RESET
def files_summary(dotfile: ResolvedDotfile) -> str:
"""Summarize basic differences between files.
"""
installed_stat = os.stat(dotfile.installed.abs)
repo_stat = os.stat(dotfile.repo.abs)
table = Table([Align.RIGHT, Align.LEFT, Align.LEFT,])
data = [["", dotfile.installed.disp, dotfile.repo.disp]]
if installed_stat.st_size == repo_stat.st_size:
data.append(["size", fmt_bytes(installed_stat.st_size), SAME_MARKER])
else:
installed_bigger = installed_stat.st_size > repo_stat.st_size
data.append(
[
"size",
(co.GREEN if installed_bigger else "")
+ fmt_bytes(installed_stat.st_size)
+ (co.RESET if installed_bigger else ""),
(co.GREEN if not installed_bigger else "")
+ fmt_bytes(repo_stat.st_size)
+ (co.RESET if not installed_bigger else ""),
]
)
if installed_stat.st_mtime == repo_stat.st_mtime:
mtime = datetime.fromtimestamp(installed_stat.st_mtime)
data.append(
["last modified", mtime.isoformat(), SAME_MARKER,]
)
else:
repo_dt = datetime.fromtimestamp(repo_stat.st_mtime)
installed_dt = datetime.fromtimestamp(installed_stat.st_mtime)
installed_newer = installed_dt > repo_dt
repo_date = repo_dt.date()
installed_date = installed_dt.date()
if repo_date == installed_date:
# Same date, different times
data.append(
[
"last modified",
(co.GREEN if installed_newer else "")
+ installed_date.isoformat()
+ " "
+ installed_dt.strftime("%T")
+ (co.RESET if installed_newer else ""),
SAME_MARKER
+ " "
+ (co.GREEN if not installed_newer else "")
+ repo_dt.strftime("%T")
+ (co.RESET if not installed_newer else ""),
]
)
else:
# Different dates and times
data.append(
[
"last modified",
(co.GREEN if installed_newer else "")
+ _pretty_iso(installed_dt)
+ (co.RESET if installed_newer else ""),
(co.GREEN if not installed_newer else "")
+ _pretty_iso(repo_dt)
+ (co.RESET if not installed_newer else ""),
]
)
return table.render(data)
@dataclass
class EditAction(contextlib.AbstractContextManager):
"""Action which merges installed and repo dotfiles together.
"""
dotfile: ResolvedDotfile
def _changed_group_format(left: str, right: str) -> str:
"""Get a ``--changed-group-format`` diff(1) option.
Style mimics diff3(1) output.
"""
newline = r"%c'\012'"
return (
f"<<<<<<< {left}{newline}"
+ "%<" # lines from left
+ f"======={newline}"
+ "%>" # lines from right
+ f">>>>>>> {right}{newline}"
)
def edit(dotfile: ResolvedDotfile) -> ActionResult:
"""Action which merges installed and repo dotfiles together.
"""
installed_backup = get_backup_path(dotfile.installed.abs)
if installed_backup is None:
return ActionResult.ASK_AGAIN
os.rename(dotfile.installed.abs, installed_backup)
installed_basename = os.path.basename(dotfile.installed.abs)
repo_basename = os.path.basename(dotfile.repo.abs)
with tempfile.TemporaryDirectory() as tmpdir:
os.mkdir(os.path.join(tmpdir, "installed"))
installed_tmp = os.path.join(tmpdir, "installed", installed_basename)
shutil.copyfile(dotfile.installed.abs, installed_tmp)
os.mkdir(os.path.join(tmpdir, "repository"))
repo_tmp = os.path.join(tmpdir, "repository", repo_basename)
shutil.copyfile(dotfile.repo.abs, repo_tmp)
os.mkdir(os.path.join(tmpdir, "merged"))
merged_tmp = os.path.join(tmpdir, "merged", repo_basename)
proc = subprocess.run(
[
"diff",
"--changed-group-format="
+ _changed_group_format(dotfile.repo.disp, dotfile.installed.disp),
dotfile.repo.abs,
dotfile.installed.abs,
],
capture_output=True,
check=False,
)
if proc.returncode not in [0, 1]:
log.error(
"While preparing files for merging, `diff` exited abnormally: "
+ proc.stderr.decode("utf-8")
)
log.error("stdout: " + proc.stdout.decode("utf-8"))
return ActionResult.ASK_AGAIN
old_merged_tmp = proc.stdout
with open(merged_tmp, "wb") as f:
f.write(proc.stdout)
subprocess.run(
[
"nvim" if has_cmd("nvim") else "vim",
"-d",
installed_tmp,
merged_tmp,
repo_tmp,
],
check=False,
)
with open(merged_tmp, "rb") as f:
new_merged_tmp = f.read()
if old_merged_tmp == new_merged_tmp:
log.warn("Merged file wasn't changed; not copying into repo.")
return ActionResult.ASK_AGAIN
print(f"Writing changes to {log.path(dotfile.repo.disp)}")
with open(dotfile.repo.abs, "wb") as f:
f.write(new_merged_tmp)
return fix(dotfile)
def mklink(from_path: Path, to_path: Path) -> None:
"""Create a symlink at ``from_path`` pointing to ``to_path``.
"""
from_dir = os.path.dirname(from_path)
if not os.path.exists(from_dir):
os.makedirs(os.path.abspath(from_dir))
os.symlink(to_path, from_path)
def fix(dotfile: ResolvedDotfile) -> ActionResult:
"""Action: fix an incorrect dotfile link.
"""
if os.path.lexists(dotfile.installed.abs):
os.remove(dotfile.installed.abs)
mklink(dotfile.installed.abs, dotfile.link_dest)
print(log.created_link(dotfile))
return ActionResult.OK
def fix_delete(dotfile: ResolvedDotfile) -> ActionResult:
"""Action: Delete the old link destination, then ``fix``.
"""
old_dest = os.path.join(
os.path.dirname(dotfile.installed.abs), os.readlink(dotfile.installed.abs)
)
os.remove(old_dest)
return fix(dotfile)
def replace_from_repo(dotfile: ResolvedDotfile) -> ActionResult:
"""Action: Replace installed dotfile with link to repo.
"""
return fix(dotfile)
def overwrite_in_repo(dotfile: ResolvedDotfile) -> ActionResult:
"""Action: Replace dotfile in repo with file on disk, then make link.
"""
shutil.copyfile(dotfile.installed.abs, dotfile.repo.abs)
return fix(dotfile)
def get_backup_path(p: Path) -> Optional[Path]:
"""Gets the backup path for a given path.
If the path we come up with already exists (highly unlikely), returns
``None``.
"""
basename = p.name
# e.g. "2020-10-17T18_21_41"
# Colons aren't allowed in Windows paths, so we can't quite use ISO 8601.
now = datetime.now().strftime("%FT%H_%M_%S")
backup_path = p.parent / f"{basename}-{now}"
if os.path.exists(backup_path):
# Improbable, but possible!
log.error(
"While creating backup path for "
+ log.path(p)
+ ", we tried "
+ log.path(backup_path)
+ ", but that path already exists"
)
return None
return backup_path
def backup(dotfile: ResolvedDotfile) -> ActionResult:
"""Action: Backup the current destination, then link.
"""
installed_backup = get_backup_path(dotfile.installed.abs)
if installed_backup is None:
return ActionResult.ASK_AGAIN
installed_backup_pretty = PrettyPath.from_path(installed_backup).disp
log.info(f"Moving {log.path(dotfile.installed.disp)} to {installed_backup_pretty}")
os.rename(dotfile.installed.abs, installed_backup)
mklink(dotfile.installed.abs, dotfile.link_dest)
return ActionResult.OK
def skip(
_dotfile: Union[ResolvedDotfile, PrettyPath],
_resolved: Optional[ResolvedDotfilesJson] = None,
) -> ActionResult:
"""No-op action.
"""
return ActionResult.SKIPPED
def quit_(_dotfile: ResolvedDotfile) -> ActionResult:
"""Action: Quit the entire program.
"""
sys.exit(1)
def scan_ignore(path: PrettyPath, resolved: ResolvedDotfilesJson) -> ActionResult:
"""Scan action: Ignore this dotfile.
"""
def scan_add(path: PrettyPath, resolved: ResolvedDotfilesJson) -> ActionResult:
"""Scan action: Add this dotfile to the repo.
"""
def scan_recurse(path: PrettyPath, _resolved: ResolvedDotfilesJson) -> ActionResult:
"""Scan action: Recurse into this directory for more dotfiles.
"""
def scan_cat(path: PrettyPath, _resolved: ResolvedDotfilesJson) -> ActionResult:
"""Scan action: Cat this file.
"""
```
#### File: scripts/src/__main__.py
```python
from __future__ import annotations
import argparse
import os
import subprocess
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Optional
from . import log
from .link import Linker
from .resolver import Resolver
from .scan import Scanner
from .schema import DotfilesJson, PrettyPath
def main() -> None:
"""Entry point.
"""
args = Args.parse_args()
if args.dotfiles is None:
repo_root = _get_repo_root()
dotfiles_fh = open(repo_root / "dotfiles.json")
else:
repo_root = args.dotfiles.parent.absolute()
dotfiles_fh = args.dotfiles.open()
dotfiles = DotfilesJson.load_from_file(dotfiles_fh)
dotfiles_fh.close()
link_root = Path.home() if args.link_root is None else args.link_root
resolver = Resolver(
repo_root=repo_root, link_root=link_root, relative=not args.absolute
)
resolved = resolver.resolve_all(dotfiles)
if args.scan:
log.warn("Scanning for dotfiles is an experimental feature.")
scanner = Scanner(link_root, resolved.ignored, resolved.dotfiles)
for p in scanner.find_dotfiles():
# TODO: Fill in scanner processing.
# Actions:
# - skip
# - quit
# - ignore the path
# - move it to dotfiles
# - if it's a directory, recurse
# - if it's a file, cat it / display its stat
#
# Should also note if it's a directory or file.
p_disp = str(PrettyPath.from_path(p).disp)
if p.is_dir():
log.info("📁 " + p_disp)
else:
log.info(p_disp)
# TODO: Offer to commit new files...?
else:
linker = Linker(verbose=args.verbose,)
linker.link_all(resolved.dotfiles)
@dataclass
class Args:
"""Command-line arguments; see ``_argparser``.
"""
dotfiles: Optional[Path]
link_root: Optional[Path]
absolute: bool
scan: bool
verbose: bool
@classmethod
def parse_args(cls) -> Args:
"""Parse args from ``sys.argv``.
"""
args = _argparser().parse_args()
return cls(
dotfiles=args.dotfiles,
link_root=args.link_root,
absolute=args.absolute,
scan=args.scan,
verbose=args.verbose,
)
def _argparser() -> argparse.ArgumentParser:
"""Command-line argument parser.
"""
parser = argparse.ArgumentParser(description="links dotfiles")
parser.add_argument(
"-d", "--dotfiles", type=Path, help="The dotfiles.json file to load",
)
parser.add_argument(
"-l",
"--link-root",
type=Path,
help="Where to create links from; defaults to your home directory",
)
parser.add_argument(
"-a",
"--absolute",
action="store_true",
help="Create absolute links, rather than relative ones",
)
parser.add_argument(
"-s", "--scan", action="store_true", help="Scan for untracked dotfiles",
)
parser.add_argument(
"-v", "--verbose", action="store_true", help="Make output more verbose",
)
return parser
def _get_repo_root() -> Path:
try:
proc = subprocess.run(
["git", "rev-parse", "--show-toplevel"],
capture_output=True,
text=True,
check=False,
)
except FileNotFoundError:
log.fatal(
"Couldn't run `git` to determine repo root; pass --dotfiles explicitly."
)
sys.exit(1)
if proc.returncode != 0:
log.fatal("Couldn't get repo root from git; pass --dotfiles explicitly.")
sys.exit(1)
return Path(proc.stdout.strip()).absolute()
if __name__ == "__main__":
main()
``` |
{
"source": "9999years/juliaplotter",
"score": 3
} |
#### File: 9999years/juliaplotter/julia.py
```python
from datetime import datetime
# for unix timestamp filenames
import time
# floor mostly, some assorted stuff
import math
# misc for actually evaluating the julia equations
import cmath
# turning user input into an eval-able formula
import re
# file writing
import codecs
# args? i actually might not need this
import argparse
# warnings
import sys
# making directories, deleting the .ppm after conversion, resolving paths
import os
# so i can nicely format my help messages and not worry about weird
# formatting for the user (sorry!)
def desc(description):
if description[0] == '\n':
return description[1:].replace('\n', ' ')
else:
return description.replace('\n', ' ')
version = '1.0.0'
def parsecomplex(num):
num = num.replace(' ', '')
num = num.replace('i', 'j')
return complex(num)
def sign(x):
return math.copysign(1, x)
math.sign = sign
# printing complex numbers
def signstr(num):
if math.sign(num.real) == -1:
return '-'
else:
return '+'
def strcomplex(num):
return f'{num.real:8g} {signstr(num.imag)} {abs(num.imag):<8g}i'.strip()
def zero_warning(var, extra=''):
warn(var + ' is ZERO. Ignoring. ' + extra)
def neg_warning(var, extra=''):
warn(var + ' is NEGATIVE.'
+ 'This makes no sense, using absolute value instead. ' + extra)
# why arent these in math in the first place?
# we need them to make user formulae sensible
# maybe i should make a pull request...
def sec(x):
return 1 / math.cos(x)
def csc(x):
return 1 / math.sin(x)
def cot(x):
return 1 / math.tan(x)
math.sec = sec
math.csc = csc
math.cot = cot
# https://stackoverflow.com/a/14981125/5719760
# sys module for stderr
# import sys
# def error(*args, **kwargs):
# print('ERROR: ', *args, file=sys.stderr, **kwargs)
def warn(*args, **kwargs):
print('WARNING: ', *args, file=sys.stderr, **kwargs)
# evaluate user input formula, compiled to bytecode
def eval_fn(z, c):
global fncode
try:
return eval(fncode)
except (ArithmeticError, ValueError, OverflowError, ZeroDivisionError):
# negative number in a log or root probably
# probably a user error
return float('nan')
# linear map val∈[valmin, valmax] |→ out∈[outmin, outmax]
def scale(val, valmin, valmax, outmin, outmax):
return (
(val - valmin) / (valmax - valmin)
* (outmax - outmin) + outmin
)
# linear map val∈[0, valmax] |→ out∈[outmin, outmax]
def zeroscale(val, valmax, outmin, outmax):
return (val / valmax) * (outmax - outmin) + outmin
# screen coords to graph coords
def stgX(x):
global graph, colwidth
return zeroscale(x % colwidth, colwidth,
graph['x']['min'], graph['x']['max'])
def stgY(y):
global graph, rowheight
return zeroscale(y % rowheight, rowheight,
graph['y']['max'], graph['y']['min'])
def clamp(v, lo, hi):
return max(min(v, hi), lo)
#something like 0.0 - 3.2i
def process_fn(fn):
global orig_fn
if fn.lower() == 'random':
# general case:
# https://gist.github.com/9999years/7d9430d08cba96c928b5631293dde33e
import random
def get_coef(imag=True):
max_coef = 20
coef = (random.random() - 0.5) * max_coef
if imag:
coef += get_coef(imag=False) * 1j
return coef
def term(deg, variables, consts, imag):
deg = random.randint(0, deg)
ret = '('
var = 'z'
coef = get_coef(imag)
if deg != 0:
ret += f'{var}'
if deg > 1:
ret += f'^{deg} + '
else:
ret += ' + '
ret += f'({coef:.3f}){random.choice(consts)})'
return (deg, ret)
def poly(deg, variables, consts, imag):
ret = ''
i = 0
while i < random.randrange(1, deg):
(degtmp, rtmp) = term(deg, variables, consts, imag)
i += degtmp
ret += rtmp
return ret
def rational(deg, variables, consts, imag):
ret = poly(deg, variables, consts, imag)
if random.random() > 0.3:
ret += f'/({poly(deg * 2, variables, consts, imag)})'
return ret
degree = 3
variables = ['z']
consts = ['c', '']
imag = True
fn = orig_fn = rational(degree, variables, consts, imag)
orig_fn = fn.replace('j', 'i')
print(f'f(z, c) = {orig_fn}')
fn = fn.replace('^', '**')
fn = re.sub(r'([zc)])([zc(])', r'\1 * \2', fn)
return fn
# abstraction for ppm writing
def write_pixel(r, g, b, f):
f.write(bytes([r, g, b]))
# formatting time-deltas in reasonable strings (why isn't this easier /
# built-in????)
def strtimedelta(time):
return (f'{math.floor(time.seconds / 3600):02d}:'
f'{math.floor((time.seconds % 3600) / 60):02d}:'
f'{time.seconds % 60:02d}.{math.floor(time.microseconds / 1000):03d}')
def main():
# set up arguments
parser = argparse.ArgumentParser(
description='Render an arbitrary Julia set or a grid of Julia sets'
'with differing constants c from a user-entered equation.',
prog='julia.py'
)
parser.add_argument('--fn', '-f', metavar='zₙ₊₁', type=str,
default=None, help=desc('''
The Julia set's function for iteration. Enter `random` to generate a random
complex rational function P(z)/Q(z), where P(z) and Q(z) are complex polynomials
of maximum degree 3 and 6, respectively.'''))
parser.add_argument('-c', '--constant', metavar='constant', type=str,
default=None, help=desc('''
The constant c for the function zₙ₊₁(z, c). Enter `random` to select a random
value for c. Default: 0 + 0i'''))
parser.add_argument('-a', '--aspect', metavar='aspect', type=float,
default=1.0, help=desc('''
The output image's w/h aspect ratio. Ex.: -a 2 implies an image twice as wide
as it is tall. Default: 1.0'''))
parser.add_argument('-w', '--width', metavar='width', type=int,
default='500', help='''The output image\'s width.''')
parser.add_argument('-i', '--iterations', metavar='iterations', type=int,
default=32, help='The iterations to calculate the set to.')
parser.add_argument('-r', '--c-range', metavar='c-range', type=float,
default=1.5, help=desc('''
The range of c values to use --- only relevant if the cell count option is used
to render a grid of sets; the c values for each sets will range from (c_r -
crange, c_i - crange·i) to (c_r + crange, c_i + crange·i), where c_r and c_i
are the real and imaginary components of the constant supplied with -c. Default:
1.5'''))
parser.add_argument('-n', '--cell-count', metavar='cell count', type=int,
default=1, help=desc('''
The number of rows and columns to render. A cell count of 1 will render a
single set, and other values will render grids of Julia sets. The different
values of c are determined by --c-range or -r. Default: 1'''))
parser.add_argument('-e', '--center', metavar='center', type=float,
default=[0, 0], nargs=2, help=desc('''
The coordinate the graph is centered around, entered as two floats separated by
a space. (Not a comma! No parenthesis! It's technically two separate arguments
consumed by one option.) Default: 0 0'''))
parser.add_argument('-z', '--zoom', metavar='zoom', type=float,
default=1, help=desc('''
How zoomed in the render is. The distance between the center-point and the top
/ bottom of the rendered area is 1 / zoom. Larger values of will produce a more
zoomed-in image, smaller values (<1) will produce a more zoomed-out image.
Default: 1'''))
parser.add_argument('-g', '--gradient', metavar='gradient speed', type=float,
default=1, help=desc('''
The plotter colors images by smoothly interpolating the orbit escape times for
each value of z₀ in the, governed by a sine function. This option adds a
multiplier within the sine function to increase the oscillation speed, which
may help to enhance details in lightly colored images. Default: 1.0'''))
parser.add_argument('-u', '--cutoff', '--escape-radius',
metavar='escape', type=float, default=30, help=desc('''
The orbit escape radius --- how large |zₙ| must be before it's considered to
have diverged. Usually ≈ 30 for Julia sets, 2 for the Mandelbrot set. Default:
30.0'''))
parser.add_argument('-o', '--output', metavar='directory', type=str,
default='./output/', help=desc('''
Output directory to write images to. Default: ./output/'''))
parser.add_argument('--info-dir',
metavar='directory', type=str, default='./info/', help=desc('''
Directory to write information files to, relative to the output directory. If
it’s not a first-level directory within the output directory, HTML output will
look funny. Default: ./info/'''))
parser.add_argument('--no-info', action='store_false',
help='''Don't write the HTML info file.''')
parser.add_argument('--no-render', action='store_true', help=desc('''
Generates appropriate HTML information files but doesn't render an
image (useful with `--filename` if the info for an image has been lost to
the sands of time...)'''))
parser.add_argument('--no-progress', action='store_false', help=desc('''
Don't output progress percentage and finish ETA. May increase
performance.'''))
parser.add_argument('--filename', metavar='pathspec', type=str, help=desc('''
Filename base for the output image. Relative to the output directory. Shouldn't
include extensions. Defaults: The current Unix timestamp'''))
parser.add_argument('--no-convert', action='store_false', help=desc('''
Don't shell out to `magick` to convert the .ppm to a .png after rendering.'''))
parser.add_argument('--no-open', action='store_false', help=desc('''
Don't open HTML output in a browser after completing rendering.'''))
parser.add_argument('-s', '--silent', action='store_true', help=desc('''
Don't log info, show progress, convert the .ppm to a .png, or open the file when
finished rendering. Equivalent to `--no-open --no-convert --no-progress
--no-info`.'''))
parser.add_argument('--license', action='store_true',
help='Print license information (MIT) and exit.')
parser.add_argument('-v', '--version', action='version',
version=f'%(prog)s {version}')
# parse arguments, extract variables
args = parser.parse_args()
if args.license:
print('''Copyright (c) 2017 <NAME>
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the “Software”), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.''')
exit()
aspect = args.aspect
c = args.constant
crange = args.c_range
cellcount = args.cell_count
center = args.center
cutoff = args.cutoff
fn = args.fn
iterations = args.iterations
# correct coloring for iterations so that coloring is same at different
# iterations. stumbled upon this fix by accident (guessing), no clue why it
# works honestly
colorscale = args.gradient * iterations / 32
width = args.width
zoom = args.zoom
info_dir = args.info_dir
out_dir = args.output
no_render = args.no_render
fname = args.filename
show_prog = args.no_progress
write_info = args.no_info
convert = args.no_convert
open_html = args.no_open
if args.silent:
show_prog = write_info = convert = open_html = False
# validate arguments to prevent weird nonsense / errors
if aspect == 0:
zero_warning('aspect')
aspect = 1
elif aspect < 0:
neg_warning('aspect')
aspect = abs(aspect)
if crange == 0:
zero_warning('c range', extra='Rendering only one cell.')
crange = 1
cellcount = 1
elif crange < 0:
neg_warning('c range')
crange = abs(crange)
if cellcount == 0:
zero_warning('cell count')
cellcount = 1
elif cellcount < 0:
neg_warning('cell count')
cellcount = abs(cellcount)
if cutoff == 0:
zero_warning('escape radius')
cutoff = 30
elif cutoff < 0:
neg_warning('escape radius')
cutoff = abs(cutoff)
if iterations == 0:
zero_warning('iterations')
iterations = 1
elif iterations < 0:
neg_warning('iterations')
iterations = abs(iterations)
if colorscale == 0:
zero_warning('gradient scale')
colorscale = iterations / 32
elif colorscale < 0:
neg_warning('gradient scale')
colorscale = abs(colorscale)
if zoom == 0:
zero_warning('zoom')
zoom = 1
elif zoom < 0:
neg_warning('zoom')
zoom = abs(zoom)
if c is None and fn is None:
fn = 'z^2 + c'
c = 'random'
elif c is None:
c = '0 + 0i'
elif fn is None:
fn = 'z^2 + c'
# if the user wants a random c, generate one and tell them about it
if c.lower() == 'random':
from random import random
c = 2 * random() - 1 + 2j * random() - 1j
print('c = {}'.format(strcomplex(c)))
else:
# otherwise, parse the user's c and store in `c`
c = parsecomplex(c)
# aspect = width / height ⇒ height = width / aspect
# should be an int so the iteration stuff doesn't explode
height = int(width / aspect)
# more accuracy if we don't int-ify these (probably)
rowheight = height / cellcount
colwidth = width / cellcount
# two args for center variables
c_x = center[0]
c_y = center[1]
# so that a higher zoom = a smaller graph
spread = 1 / zoom
graph = {
'x': {
# make sure the graph isn't stretched
'min': c_x - spread * aspect,
'max': c_x + spread * aspect,
'c': c_x
},
'y': {
'min': c_y - spread,
'max': c_y + spread,
'c': c_y
}
}
# keys are addressed as cgrid[x][y] (cgrid[col][row] if you prefer)
# the else clause avoids a divide by zero
# tick values range from c - crange to c + crange
# y axis is inverted so imag and real components arent the same
cgrid = [[
c.real - crange + 2 * crange * col / (cellcount - 1)
+ (c.imag + crange - 2 * crange * row / (cellcount - 1))*1j
for row in range(cellcount)]
for col in range(cellcount)] if cellcount is not 1 else [[c]]
# when we should step the row / col counters
yticks = [int((y + 1) * rowheight) for y in range(cellcount - 1)]
xticks = [int((x + 1) * colwidth ) for x in range(cellcount - 1)]
# bunch of setup before processing user function
# imaginary numbers are j
fn = re.sub(r'(\d|\b)i\b', r'\1j', fn)
# ln = log
fn = fn.replace('ln', 'log')
# when you type (x + 2)(x - 2) you probably meant to multiply them right?
fn = re.sub(r'\)\s*\(', r')*(', fn)
fn = fn.replace('π', 'pi')
fn = re.sub(r'(?<!cmath\.)\b(pi|e|tau|inf|infj|nan|nanj)\b',
r'cmath.\1', fn)
# sinz, sin z, cos c, etc.
fn = re.sub(r'''(?<!cmath\.)(?:(?<=\d)|(?<=\b))(phase|polar|exp|log10|sqrt|
|acos|asin|atan| |cos|sin|tan|acosh|asinh|atanh|cosh|sinh|tanh|isfinite|
|isinf|isnan|log|rect)\s*([zc])\b''', r'cmath.\1(\2)', fn)
# sin(z) ...
fn = re.sub(r'''(?<!cmath\.)(?:(?<=\d)|(?<=\b))(phase|polar|exp|log10|sqrt|acos|asin|atan|
|cos|sin|tan|acosh|asinh|atanh|cosh|sinh|tanh|isfinite|isinf|isnan|log|
|rect|isclose)\(''', r'cmath.\1(', fn)
# replace stuff like 2tan(4x) with 2*tan(4*x)
# (?=j\b) excludes imaginary numbers
fn = re.sub(r'(\d+)(?!j\b)\s*([a-zA-Z]+)', r'\1 * \2', fn)
# 3 z c, 2.5c z
fn = re.sub(r'([zc])\s+([zc])', r'\1 * \2', fn)
# so stuff like x(x - 3) works as expected
fn = re.sub(r'([zc])\s+\(', r'\1 * (', fn)
# so stuff like log(x)sin(x) works as expected
fn = re.sub(r'\)\s*(\w)', r') * \1', fn)
# replace ^ with **
fn = fn.replace('^', '**')
z = 0
c = 0
try:
eval(fn)
except (ArithmeticError, ValueError):
warn('Evaluation of function fails at z = 0, c = 0! This might be a '
'symptom of a larger problem, or simply a harmless asymptote. '
'Continuing execution.')
except NameError:
warn('Uh-oh, something is pretty seriously wrong in the function '
'you gave me. Continuing execution, but this is *probably* '
'going to explode in a moment.')
print(f'Processed function: {fn}')
return fn
# save original function, process to be usable and compile
orig_fn = fn
if orig_fn.lower() == 'random':
c = 'random'
fn = process_fn(fn)
try:
fncode = compile(fn, '<string>', 'eval')
except (SyntaxError, ValueError):
raise Exception('Invalid function. This might be my fault or yours.\n'
f'Processed equation: {fn}')
exit()
# unix timestamp is the base filename
fname = fname or str(int(time.time()))
# output it for future reference (if needed)
print('the time is ' + fname)
# make sure the directories we want to write to exist
# i know i said the info dir has to be in the output dir but if you
# really wanna be mean and fuck it up that's fine (the css and js links are
# gonna break though unless you modify starttemplate.html and
# endtemplate.html)
if not os.path.exists(f'./{out_dir}/'):
os.makedirs(f'./{out_dir}/')
if not os.path.exists(f'./{out_dir}/{info_dir}/'):
os.makedirs(f'./{out_dir}/{info_dir}/')
# write html if requested
# perhaps interestingly, we do this before actually generating the image
if write_info:
# we're going to need to output render commands a lot --- abstract it
# we need to vary the given c and toggle showing the cell count, so
# introduce options for that
def generateCLIinvocation(c, showcells=False):
global orig_fn, iterations, width, aspect, args, \
zoom, colorscale, cutoff, cellcount
return ('./julia.py '
f'-f "{orig_fn}" -c "{strcomplex(c)}" '
f'-i {iterations} -w {width} -a {aspect} '
f'-e {args.center[0]} {args.center[1]} -z {zoom} '
f'-g {colorscale} -u {cutoff}'
+ (f' -r {crange:g} -n {cellcount}' if showcells else ''))
# get template information. js and css are just linked to, although they
# rely on writing the html two directories below this directory (usually
# in ./output/info)
with open('./starttemplate.html', encoding='utf-8') as template_start, \
open('./endtemplate.html', encoding='utf-8') as template_end, \
open(out_dir + '/' + info_dir + '/' + fname + '.html',
'w', encoding='utf-8') as out:
# targets is a string containing info to replicate the render or
# parts of the render. it contains <div>s for each row / col wrapped
# in a div.targets if cellcount > 1 with the cli invocation, or just
# one not in a div.targets if cellcount = 1
targets = ''
end_script = ''
out.write(template_start.read())
if cellcount > 1:
out.write('<map name="juliagrid" id="juliamap">')
targets += '<div class="targets">'
for row in range(cellcount):
for col in range(cellcount):
# write an image map with an area for each row/col. then
# when clicked, the relevant info from targets is shown
# (displayed in a :target css selector, hidden by
# default)
out.write(
'<area shape="rect" coords="' + ','.join(
[str(int(colwidth * col)) #top left
,str(int(rowheight * row))
,str(int(colwidth * (col + 1))) #bottom right
,str(int(rowheight * (row + 1)))])
+ f'" href="#{col + 1}-{row + 1}">\n'
)
targets += (
f'<div id="{col + 1}-{row + 1}">column {col + 1}, '
f'row {row + 1}: c = {strcomplex(cgrid[col][row])}'
'<p><code>'
+ generateCLIinvocation(cgrid[col][row])
+ '</code></div>\n'
)
out.write('</map>\n<img usemap="#juliagrid" ')
targets += ('</div><p>click on a cell to see the constant and '
'the command-line invocation used to render it!<p>to '
'recreate the entire image, use <p><code id="invocation"> '
+ generateCLIinvocation(c, showcells=True)
+ '</code>')
else:
out.write('<img ')
targets = (
'<p><code id="invocation">'
+ generateCLIinvocation(c, showcells=True)
+ '</code>\n<p>click on the render to update the command '
'with a new center (<code>-e</code>)'
)
# if there's only one cell, make clicking on the image update the
# code#invocation tag with new coordinates centered on the click
# location in the image
end_script = ('\n<script>\n'
f'let xmin = {graph["x"]["min"]},\n'
f'dx = {graph["x"]["max"] - graph["x"]["min"]},\n'
f'ymax = {graph["y"]["max"]},\n'
f'dy = {graph["y"]["max"] - graph["y"]["min"]};')
end_script += '''
(() => {
let $ = e => document.getElementById(e),
j = $('julia'),
o = $('invocation');
j.onclick = e => {
let x = xmin + dx * e.offsetX / j.clientWidth;
let y = ymax - dy * e.offsetY / j.clientHeight;
o.innerHTML = o.innerHTML.replace(
/-e (-?(\d|\.)+ ){2}/g, '-e '
+ x.toPrecision(4) + ' ' + y.toPrecision(4) + ' ');
};
})();
</script>\n'''
def tr(one, two):
return f'<tr><td>{one}</td><td>{two}</td></tr>'
# table with general render info
out.write(
f'src="../{fname}.png" id="julia">\n'
+ '<div id="container"><div id="contents">\n'
+ targets
+ '<table class="render-info">\n'
+ tr('z<sub>n + 1</sub>(z, c) =', orig_fn)
+ tr('c =', strcomplex(c))
+ tr('rendered area',
f'({graph["x"]["min"]}, {graph["y"]["min"]}i) '
f'to ({graph["x"]["max"]}, {graph["y"]["max"]}i)')
+ tr('center', f'({graph["x"]["c"]}, {graph["y"]["c"]}i)')
+ tr('zoom', f'{zoom}×')
+ tr('gradient speed', colorscale)
+ tr('escape radius', cutoff)
+ tr('iterations', iterations)
+ tr('c range', f'{crange:g}')
+ '</table>'
+ template_end.read()
+ end_script)
# if we're just regenerating the info, we're done
if no_render:
exit()
with open(out_dir + '/' + fname + '.ppm', 'wb') as out:
# magic numbers, etc
out.write(bytes(f'P6\n{width} {height}\n255\n', encoding='ascii'))
# initialize relevant variables
z: complex
z_p: complex
color: float
graphy: float
i: int
row: int = 0
col: int = 0
# for eta and total elapsed time estimation
start = datetime.now()
# iterate top to bottom
for y in range(0, height):
# if eta / % info requested, show it!
if show_prog:
# eta prediction, % done
now = datetime.now()
# Δt / % done = est. total time
# ETT - Δt = est. time left
doneamt = y / height
if y != 0:
eta = (now - start) * (1 / doneamt - 1)
print('{: <76}'.format(
f'{100 * doneamt: >6.3f}% done, eta ≈ {strtimedelta(eta)}'
), end='\r')
# y component is the same for every x-coord, so we pre-calculate it
graphy = stgY(y) * 1j
# increment row if necessary, excepting moving past the edge of the
# image
if row != cellcount - 1 and y == yticks[row]:
row += 1
# we only *increment* the col index, so we have to reset it each row
col = 0
for x in range(0, width):
if col != cellcount - 1 and x == xticks[col]:
col += 1
# z_0 is based on x and y coords
# remember, stgX and stgY take columns and rows into account
z_p = z = stgX(x) + graphy
i = 0
# smooth coloring using exponents????
color = math.exp(-abs(z))
# iterate, breaking if we exceed the orbit threshold
for i in range(0, iterations):
z = eval_fn(z, cgrid[col][row])
if cmath.isnan(z) or not cmath.isfinite(z):
# oh no
# i can blame this on the user right?
z = z_p
break
elif abs(z) > cutoff:
break
z_p = z
color += math.exp(-abs(z))
# color is in the range of [0, iterations], so we have to
# normalize it
color /= iterations
# we have way more magnitude info than can be expressed with 255
# discrete values, so we oscillate light and dark as magnitude
# increases, for a variety of colors. by scaling the blue
# oscillator slightly longer and the red slightly shorter, we
# get a nice rainbow!
write_pixel(
int(255 * math.sin(color * colorscale * 9 ) ** 2),
int(255 * math.sin(color * colorscale * 10) ** 2),
int(255 * math.sin(color * colorscale * 11) ** 2),
out
)
# time elapsed
end = datetime.now()
print(f'Done! Completed in {strtimedelta(end - start)}')
if convert:
# convert ppm to png (if requested, by default on)
# don't load these libraries unless needed
from subprocess import run
print(f'Converting {fname}.ppm to {fname}.png')
run(['magick', 'mogrify', '-format', 'png', f'{out_dir}/{fname}.ppm'])
os.remove(f'{out_dir}/{fname}.ppm')
if open_html:
# this works very smoothly, which is nice! thanks python!
import webbrowser
from urllib.request import pathname2url
# only used once but boy oh boy does it make the code nicer
def abspath(filename):
return 'file:' + pathname2url(os.path.abspath(filename))
webbrowser.open(abspath(f'{out_dir}/{info_dir}/{fname}.html'))
if __name__ == '__main__':
main()
``` |
{
"source": "9999years/pycorpora",
"score": 2
} |
#### File: pycorpora/pycorpora/__init__.py
```python
import sys
from pkg_resources import resource_stream, resource_exists, resource_isdir, \
resource_listdir
import json
import re
__version__ = '0.1.2'
cache = dict()
def fetch_resource(name):
if name not in cache:
cache[name] = json.loads(resource_stream(
__name__, name).read().decode('utf-8'))
return cache[name]
def get_categories(category=None):
if category is None:
return resource_listdir(__name__, "data")
else:
return [item for item
in resource_listdir(__name__, "data/" + category)
if resource_isdir(__name__, "data/" + category + "/" + item)]
def get_files(category):
return [re.sub(r"\.json$", "", item) for item
in resource_listdir(__name__, "data/" + category)
if not resource_isdir(__name__, "data/" + category + "/" + item)]
def get_file(*components):
return fetch_resource("/".join(["data"] + list(components)) + ".json")
class CorpusLoader(object):
def __init__(self, directory):
self.directory = directory
def __getitem__(self, key):
return self.__getattr__(key)
def __getattr__(self, attr):
file_loc = "data/" + self.directory + "/" + attr + ".json"
dir_loc = "data/" + self.directory + "/" + attr
if resource_exists(__name__, file_loc):
return fetch_resource(file_loc)
elif resource_exists(__name__, dir_loc) and \
resource_isdir(__name__, dir_loc):
return CorpusLoader(self.directory + "/" + attr)
else:
raise AttributeError("no resource named " + attr)
def get_categories(self):
return get_categories(self.directory)
def get_files(self):
return get_files(self.directory)
def get_file(self, *components):
return get_file(self.directory, *components)
module = sys.modules[__name__]
for directory in resource_listdir(__name__, "data"):
setattr(module, directory.replace("-", "_"), CorpusLoader(directory))
``` |
{
"source": "9999years/pytumblr",
"score": 3
} |
#### File: pytumblr/pytumblr/request.py
```python
import urllib.parse
from dataclasses import dataclass
from typing import Dict, Union, Tuple, List
import requests
from requests.exceptions import TooManyRedirects, HTTPError
from requests_oauthlib import OAuth1
@dataclass
class Reason:
title: str
code: int
@dataclass
class TumblrError:
# the HTTP status code, e.g. 200
status: int
# the HTTP status message, e.g. 'OK'
msg: str
# any response data, as a dictionary
response: Dict = None
# any errors
errors: List[Reason] = None
TumblrResponse = Union[TumblrError, Dict]
Status = Tuple[bool, TumblrError]
def ok(response: TumblrResponse) -> Status:
"""
A predicate determining if the response has a non-200 status code
:return: True if response.status == 200, False otherwise
"""
return not isinstance(response, TumblrError), response
def created(response: TumblrError) -> Status:
return response.status == 201, response
class TumblrRequest:
"""
A simple request object that lets us query the Tumblr API
"""
__version = "0.0.8"
def __init__(self, consumer_key, consumer_secret="", oauth_token="", oauth_secret="",
host="https://api.tumblr.com", version=2):
self.host = '{}/v{}'.format(host, version)
self.oauth = OAuth1(
consumer_key,
client_secret=consumer_secret,
resource_owner_key=oauth_token,
resource_owner_secret=oauth_secret
)
self.consumer_key = consumer_key
self.headers = {
"User-Agent": "pytumblr/" + self.__version,
}
def get(self, url, params) -> TumblrResponse:
"""
Issues a GET request against the API, properly formatting the params
:param url: a string, the url you are requesting
:param params: a dict, the key-value of all the paramaters needed
in the request
:returns: either a dict of the returned response or a TumblrError in case of failure
"""
url = self.host + url
if params:
url += "?" + urllib.parse.urlencode(params)
try:
resp = requests.get(url, allow_redirects=False, headers=self.headers, auth=self.oauth)
except TooManyRedirects as e:
resp = e.response
return self.json_parse(resp)
def post(self, url, params={}, files=[]) -> TumblrResponse:
"""
Issues a POST request against the API, allows for multipart data uploads
:param url: a string, the url you are requesting
:param params: a dict, the key-value of all the parameters needed
in the request
:param files: a list, the list of tuples of files
:returns: a dict parsed of the JSON response
"""
url = self.host + url
try:
if files:
return self.post_multipart(url, params, files)
else:
data = urllib.parse.urlencode(params)
resp = requests.post(url, data=data, headers=self.headers, auth=self.oauth)
return self.json_parse(resp)
except HTTPError as e:
return self.json_parse(e.response)
def json_parse(self, response) -> TumblrResponse:
"""
Wraps and abstracts response validation and JSON parsing
to make sure the user gets the correct response.
:param response: The response returned to us from the request
:returns: a dict of the json response
"""
try:
data = response.json()
except ValueError:
data = {'meta': {'status': 500, 'msg': 'Server Error'},
'response': {"error": "Malformed JSON or HTML was returned."}}
# We only really care about the response if we succeed
# and the error if we fail
if data['meta']['status'] == 200:
return data['response']
else:
return TumblrError(data['meta']['status'],
data['meta']['msg'],
data['response'])
def post_multipart(self, url, params, files) -> TumblrResponse:
"""
Generates and issues a multipart request for data files
:param url: a string, the url you are requesting
:param params: a dict, a key-value of all the parameters
:param files: a dict, matching the form '{name: file descriptor}'
:returns: a dict parsed from the JSON response
"""
resp = requests.post(
url,
data=params,
params=params,
files=files,
headers=self.headers,
allow_redirects=False,
auth=self.oauth
)
return self.json_parse(resp)
```
#### File: pytumblr/pytumblr/types.py
```python
from collections import UserList
from dataclasses import dataclass, field
from datetime import datetime
from typing import List, Dict, Any, Optional, Type
DATE_FORMAT = '%Y-%m-%d %H:%M:%S %Z'
def parse_date(tumblr_date: str) -> datetime:
return datetime.strptime(tumblr_date, DATE_FORMAT)
@dataclass
class Link:
"""
An objects in a _links hash
"""
href: str
type: str
@dataclass
class NavigationLink(Link):
pass
@dataclass
class ActionLink(Link):
method: str
query_params: Dict[str, Any]
_link_classes = {'navigation': NavigationLink,
'action': ActionLink}
@dataclass
class Tag:
tag: str
is_tracked: bool
featured: bool
thumb_url: Optional[str] = None
@dataclass
class BaseBlog:
name: str
updated: int
title: str
description: str
@dataclass
class Blog(BaseBlog):
url: str
@dataclass
class BlogInfo(BaseBlog):
posts: int
ask: bool
ask_anon: bool
likes: int
is_blocked_from_primary: bool
@dataclass
class UserBlogInfo:
url: str
title: str
primary: bool
followers: int
tweet: str
facebook: str
type: str
@dataclass
class UserInfo:
following: int
default_post_format: str
name: str
likes: int
blogs: List[UserBlogInfo]
def __post_init__(self):
self.blogs = [UserBlogInfo(**blog) for blog in self.blogs]
@dataclass
class Avatar:
avatar_url: str
@dataclass
class Post:
id: int
type: str
blog_name: str
post_url: str
timestamp: int
date: datetime
format: str
reblog_key: str
tags: List[str]
total_posts: int
blog: Optional[BlogInfo] = None
bookmarks: Optional[bool] = None
mobile: Optional[bool] = None
source_url: Optional[str] = None
source_title: Optional[str] = None
liked: Optional[bool] = None
state: Optional[str] = None
is_blocks_post_format: Optional[bool] = None
def __new__(cls, *args, **kwargs):
if 'blog_name' in kwargs and 'blog' not in kwargs:
return DashboardPost(*args, **kwargs)
else:
return POST_CLASSES[kwargs['type']](*args, **kwargs)
def __eq__(self, other):
return self.id == other.id
def __hash__(self):
return hash(self.id)
def __post_init__(self):
self.date = parse_date(self.date)
self.blog = BlogInfo(**self.blog)
@dataclass
class DashboardPost(Post):
blog: None = None
@dataclass
class Submission(Post):
slug: str = None
short_url: str = None
post_author: Optional[str] = None
is_submission: Optional[bool] = True
anonymous_name: Optional[str] = None
anonymous_email: Optional[str] = None
state: Optional[str] = 'submission'
@dataclass
class LegacyTextPost(Post):
title: Optional[str] = None
body: Optional[str] = None
@dataclass
class ImageSize:
width: int
height: int
url: str
@dataclass
class Photo:
caption: str
alt_sizes: List[ImageSize]
def __post_init__(self):
self.alt_sizes = [ImageSize(**size) for size in self.alt_sizes]
@dataclass
class VerbosePhoto(Photo):
original_size: ImageSize
width: int
height: int
url: str
def __post_init__(self):
self.original_size = ImageSize(**self.original_size)
@dataclass
class LegacyPhotoPost(Post):
"""
A photo or photoset post
"""
caption: Optional[str] = None
width: Optional[int] = None
height: Optional[int] = None
photos: List[Photo] = field(default_factory=list)
def __post_init__(self):
self.photos = [Photo(**photo) for photo in self.photos]
@dataclass
class LegacyQuotePost(Post):
text: Optional[str] = None
# HTML source, not an attribution
source: Optional[str] = None
@dataclass
class LegacyLinkPost(Post):
title: Optional[str] = None
description: Optional[str] = None
url: Optional[str] = None
author: Optional[str] = None
excerpt: Optional[str] = None
publisher: Optional[str] = None
photos: List[VerbosePhoto] = field(default_factory=list)
def __post_init__(self):
self.photos = [VerbosePhoto(**photo) for photo in self.photos]
@dataclass
class ChatLine:
name: str
label: str
phrase: str
@dataclass
class LegacyChatPost(Post):
title: Optional[str] = None
body: Optional[str] = None
dialogue: List[ChatLine] = field(default_factory=list)
def __post_init__(self):
self.dialogue = [ChatLine(**line) for line in self.dialogue]
@dataclass
class LegacyAudioPost(Post):
caption: Optional[str] = None
player: Optional[str] = None
plays: Optional[int] = None
album_art: Optional[str] = None
artist: Optional[str] = None
album: Optional[str] = None
track_name: Optional[str] = None
track_number: Optional[int] = None
year: Optional[int] = None
@dataclass
class VideoPlayer:
width: int
embed_code: str
@dataclass
class LegacyVideoPost(Post):
caption: Optional[str] = None
player: List[Any] = field(default_factory=[])
@dataclass
class LegacyAnswerPost(Post):
asking_name: Optional[str] = None
asking_url: Optional[str] = None
question: Optional[str] = None
answer: Optional[str] = None
# a type -> class dict
POST_CLASSES: Dict[str, Type] = {
'photo': LegacyPhotoPost,
'quote': LegacyQuotePost,
'link': LegacyLinkPost,
'chat': LegacyChatPost,
'audio': LegacyAudioPost,
'video': LegacyVideoPost,
'answer': LegacyAnswerPost,
}
@dataclass
class Likes:
liked_posts: List[Post]
liked_count: int
def __post_init__(self):
self.liked_posts = [Post(**post) for post in self.liked_posts]
@dataclass
class Following:
blogs: List[BlogInfo]
total_blogs: int
def __post_init__(self):
self.blogs = [BlogInfo(**blog) for blog in self.blogs]
@dataclass
class Follower:
name: str
following: bool
url: str
updated: int
@dataclass
class Followers:
total_users: int
users: List[Follower]
def __post_init__(self):
self.users = [Follower(**user) for user in self.users]
@dataclass
class Reblog:
comment: str
tree_html: str
@dataclass
class Dashboard:
posts: List[DashboardPost]
def __post_init__(self):
self.posts = [DashboardPost(**post) for post in self.posts]
@dataclass
class Posts:
posts: List[Post]
def __post_init__(self):
self.posts = [Post(**post) for post in self.posts]
@dataclass
class BlogPosts(Posts):
blog: BlogInfo
def __post_init__(self):
self.blog = BlogInfo(**self.blog)
``` |
{
"source": "9999years/spdx-tool",
"score": 3
} |
#### File: 9999years/spdx-tool/gen-short-license-list.py
```python
import argparse
import json
from typing import List, Optional, Iterable
from dataclasses import dataclass
@dataclass
class License:
reference: str
isDeprecatedLicenseId: bool
detailsUrl: str
referenceNumber: str
name: str
licenseId: str
seeAlso: List[str]
isOsiApproved: bool
isFsfLibre: Optional[bool] = None
def pad(s: str, width: int) -> str:
delta = width - len(s)
if delta > 0:
return s + " " * delta
else:
return s
def table(data: List[List[str]], sep: str = " ") -> str:
if not data:
return ""
col_widths = [-1] * len(data[0])
for row in data:
for width, (i, cell) in zip(col_widths, enumerate(row[:-1])):
if len(cell) > width:
col_widths[i] = len(cell)
return "\n".join(
sep.join(
pad(cell, width) if width != -1 else cell
for cell, width in zip(row, col_widths)
)
for row in data
)
def argparser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(description="spdx tool build script")
parser.add_argument("LICENSE_DATA")
return parser
def main():
args = argparser().parse_args()
with open(args.LICENSE_DATA) as f:
data = json.load(f)
licenses = [License(**l) for l in data["licenses"]]
table_data = [
[l.licenseId, l.name] for l in licenses if not l.isDeprecatedLicenseId
]
print(table(table_data))
if __name__ == "__main__":
main()
``` |
{
"source": "9999years/tox-poetry-installer",
"score": 2
} |
#### File: tox-poetry-installer/tests/test_installer.py
```python
import time
import tox.venv
from poetry.factory import Factory
from .fixtures import mock_poetry_factory
from .fixtures import mock_venv
from tox_poetry_installer import datatypes
from tox_poetry_installer import installer
def test_deduplication(mock_venv, mock_poetry_factory):
"""Test that the installer does not install duplicate dependencies"""
poetry = Factory().create_poetry(None)
packages: datatypes.PackageMap = {
item.name: item for item in poetry.locker.locked_repository(False).packages
}
venv = tox.venv.VirtualEnv()
to_install = [packages["toml"], packages["toml"]]
installer.install(poetry, venv, to_install)
assert len(set(to_install)) == len(venv.installed) # pylint: disable=no-member
def test_parallelization(mock_venv, mock_poetry_factory):
"""Test that behavior is consistent between parallel and non-parallel usage"""
poetry = Factory().create_poetry(None)
packages: datatypes.PackageMap = {
item.name: item for item in poetry.locker.locked_repository(False).packages
}
to_install = [
packages["toml"],
packages["toml"],
packages["tox"],
packages["requests"],
packages["python-dateutil"],
packages["attrs"],
]
venv_sequential = tox.venv.VirtualEnv()
start_sequential = time.time()
installer.install(poetry, venv_sequential, to_install, 0)
sequential = time.time() - start_sequential
venv_parallel = tox.venv.VirtualEnv()
start_parallel = time.time()
installer.install(poetry, venv_parallel, to_install, 5)
parallel = time.time() - start_parallel
# The mock delay during package install is static (one second) so these values should all
# be within microseconds of each other
assert parallel < sequential
assert round(parallel * 5) == round(sequential)
assert round(sequential) == len(set(to_install))
assert round(parallel * 5) == len(set(to_install))
```
#### File: tox-poetry-installer/tests/test_transients.py
```python
import poetry.factory
import poetry.utils.env
import pytest
from poetry.puzzle.provider import Provider
from .fixtures import mock_poetry_factory
from .fixtures import mock_venv
from tox_poetry_installer import constants
from tox_poetry_installer import datatypes
from tox_poetry_installer import exceptions
from tox_poetry_installer import utilities
def test_exclude_unsafe():
"""Test that the unsafe packages are properly excluded
Also ensure that the internal constant matches the value from Poetry
"""
assert Provider.UNSAFE_PACKAGES == constants.UNSAFE_PACKAGES
for dep in constants.UNSAFE_PACKAGES:
assert utilities.identify_transients(dep, dict(), None) == []
def test_allow_missing():
"""Test that the ``allow_missing`` parameter works as expected"""
with pytest.raises(exceptions.LockedDepNotFoundError):
utilities.identify_transients("luke-skywalker", dict(), None)
assert (
utilities.identify_transients(
"darth-vader", dict(), None, allow_missing=["darth-vader"]
)
== []
)
def test_exclude_pep508():
"""Test that dependencies specified in PEP508 format are properly excluded"""
for version in [
"foo==1.0",
"foo==1",
"foo>2.0.0",
"foo<=9.3.4.7.8",
"foo>999,<=4.6",
"foo>1234 || foo<2021.01.01",
"foo!=7",
"foo~=0.8",
"foo!=9,==7",
"=>foo",
]:
with pytest.raises(exceptions.LockedDepVersionConflictError):
utilities.identify_transients(version, dict(), None)
def test_functional(mock_poetry_factory, mock_venv):
"""Integration tests for the :func:`identify_transients` function
Trivially test that it resolves dependencies properly and that the parent package
is always the last in the returned list.
"""
pypoetry = poetry.factory.Factory().create_poetry(None)
packages: datatypes.PackageMap = {
item.name: item for item in pypoetry.locker.locked_repository(False).packages
}
venv = poetry.utils.env.VirtualEnv() # pylint: disable=no-value-for-parameter
requests_requires = [
packages["certifi"],
packages["chardet"],
packages["idna"],
packages["urllib3"],
packages["requests"],
]
transients = utilities.identify_transients("requests", packages, venv)
assert all((item in requests_requires) for item in transients)
assert all((item in transients) for item in requests_requires)
for package in [packages["requests"], packages["tox"], packages["flask"]]:
transients = utilities.identify_transients(package, packages, venv)
assert transients[-1] == package
assert len(transients) == len(set(transients))
``` |
{
"source": "999LV/MiPowPlayBulb",
"score": 2
} |
#### File: 999LV/MiPowPlayBulb/plugin.py
```python
import Domoticz
import json
from datetime import datetime, timedelta
import time
import MiPowPlayBulbAPI as API
import threading
import queue
_icons = {"mipowplaybulbfull": "mipowplaybulbfull icons.zip",
"mipowplaybulbok": "mipowplaybulbok icons.zip",
"mipowplaybulblow": "mipowplaybulblow icons.zip",
"mipowplaybulbempty": "mipowplaybulbempty icons.zip"}
_battery_check_timer_when_on = 30 # minutes
class BasePlugin:
def __init__(self):
self.lamp = None
self.levelWhite = 0
self.levelRed = 0
self.levelGreen = 0
self.levelBlue = 0
self.effect = 255 # effects are Off)
self.speed = 1 # fastest effects speed
self.battery = 255
self.nextpoll = datetime.now() # battery polling heartbeat counter
self.lastpoll = self.nextpoll # baseline used when heartbeat poll changes as lamp is on or off
self.tasksQueue = queue.Queue()
self.tasksThread = threading.Thread(name="QueueThread", target=BasePlugin.handleTasks, args=(self,))
def onStart(self):
Domoticz.Debugging(int(Parameters["Mode6"]))
self.tasksThread.start()
# load custom battery images
for key, value in _icons.items():
if key not in Images:
Domoticz.Status("Icon with key '{}' does not exist... Creating".format(key))
Domoticz.Image(value).Create()
else:
Domoticz.Debug("Icon {} - {} with key '{}' already exists".format(
Images[key].ID, Images[key].Name, key))
# set up the devices for the plugin
if 1 not in Devices:
Domoticz.Device(Name="Switch", Unit=1, Type=241, Subtype=1, Switchtype=7, Used=1).Create()
else:
Domoticz.Debug(
"Color dictionnary = {}, LastLevel = {}".format(Devices[1].Color, Devices[1].LastLevel))
try:
ColorDict = json.loads(Devices[1].Color)
self.levelWhite = int(ColorDict["cw"] * Devices[1].LastLevel / 100)
self.levelRed = int(ColorDict["r"] * Devices[1].LastLevel / 100)
self.levelGreen = int(ColorDict["g"] * Devices[1].LastLevel / 100)
self.levelBlue = int(ColorDict["b"] * Devices[1].LastLevel / 100)
except:
Domoticz.Error("Warning: No color data in Switch device")
if 2 not in Devices:
Options = {"LevelActions": "|||||",
"LevelNames": "Off|Flash|Pulse|Hard|Soft|Candle",
"LevelOffHidden": "false",
"SelectorStyle": "0"}
Domoticz.Device(Name="Effects", Unit=2, TypeName="Selector Switch", Switchtype=18, Image=14,
Options=Options, Used=1).Create()
else:
self.effect = 255 if Devices[2].sValue == "" else int(float(Devices[2].sValue) / 10) - 1
if 3 not in Devices:
Domoticz.Device(Name="Speed", Unit=3, Type=244, Subtype=73, Switchtype=7, Image=14, Used=1).Create()
else:
self.speed = max(int((100 - Devices[3].LastLevel) / 100 * 255), 1) # speed 1 = Fastest, speed 255 = Slowest
self.lamp = API.MiPowLamp(int(Parameters["Port"]), Parameters["Address"], int(Parameters["Mode6"]))
self.tasksQueue.put({"Action": "Init"})
if Parameters["Mode2"] == "1":
if 4 not in Devices:
Domoticz.Device(Name="Battery", Unit=4, TypeName="Custom", Options={"Custom": "1;%"}).Create()
else:
if 4 in Devices: # delete existing device as it is no longer wanted
Devices[4].Delete()
def onStop(self):
Domoticz.Log("onStop - Plugin is stopping.")
# signal queue thread to exit
self.tasksQueue.put(None)
Domoticz.Status("Clearing tasks queue...")
self.tasksQueue.join()
# Wait until queue thread has exited
Domoticz.Status("Threads still active: " + str(threading.active_count()) + ", should be 1.")
while threading.active_count() > 1:
for thread in threading.enumerate():
if thread.name != threading.current_thread().name:
Domoticz.Status(
"'" + thread.name + "' is still running, waiting otherwise Domoticz will abort on plugin exit.")
time.sleep(1.0)
def onCommand(self, Unit, Command, Level, Color):
Domoticz.Debug(
"onCommand called for Unit {}: Command '{}', Level: {}, Color: {}".format(Unit, Command, Level, Color))
if Unit == 1: # Main switch
if Command == "On":
self.nextpoll = self.lastpoll + timedelta(minutes=_battery_check_timer_when_on)
self.tasksQueue.put({"Action": "On"})
elif Command == "Off":
self.nextpoll = self.lastpoll + timedelta(hours=int(Parameters["Mode1"]))
self.tasksQueue.put({"Action": "Off"})
elif Command == "Set Color":
self.tasksQueue.put({"Action": "SetColor", "Color": Color, "Level": Level})
elif Command == "Set Level":
self.tasksQueue.put({"Action": "SetLevel", "Color": Color, "Level": Level})
else:
Domoticz.Error("Device {} has sent an unknown command: {}".format(Devices[Unit].Name, Command))
elif Unit == 2: # Effects selector switch
self.effect = 255 if Level == 0 else int(float(Level) / 10) - 1
self.tasksQueue.put({"Action": "SetEffect"})
elif Unit == 3: # Speed dimmer switch
self.speed = max(int((100 - Level) / 100 * 255), 1)
self.tasksQueue.put({"Action": "SetSpeed", "Level": Level})
def onHeartbeat(self):
now = datetime.now()
if self.lamp.reconnected: # if the device just reconnected, force an immediate reload of battery level
self.lamp.reconnected = False
self.nextpoll = now
if self.nextpoll <= now:
self.lastpoll = now
if Devices[1].nValue == 1:
self.nextpoll = now + timedelta(minutes=_battery_check_timer_when_on)
else:
self.nextpoll = now + timedelta(hours=int(Parameters["Mode1"]))
Domoticz.Debug("next poll will be{}".format(self.nextpoll))
self.tasksQueue.put({"Action": "GetBattery"})
def handleTasks(self):
try:
Domoticz.Debug("Entering tasks handler")
while True:
task = self.tasksQueue.get(block=True)
if task is None:
Domoticz.Debug("Exiting task handler")
try:
self.lamp.disconnect()
except AttributeError:
pass
self.tasksQueue.task_done()
break
Domoticz.Debug("handling task: '" + task["Action"] + "'.")
if task["Action"] == "Init":
if self.lamp:
self.lamp.timeout = 5 # we set 5 seconds for first discovery of the bluetooth device
self.lamp.connect()
self.lamp.strict_check = True if Parameters["Mode3"] == "1" else False
if self.lamp.connected:
self.lamp.timeout = 2 # connect went well so we can afford a shorter timeout (to be tested)
self._ResetLamp()
else:
Domoticz.Error("Unable to create bluetooth lamp object ! Plugin will not be functional")
elif task["Action"] == "On":
if self.lamp.set_rgbw(self.levelRed, self.levelGreen, self.levelBlue, self.levelWhite):
self._updateDevice(1, nValue=1, TimedOut=0)
# resend effect and speed as these are lost when lamp is switched off
time.sleep(1)
self.lamp.set_effect(self.effect)
self.lamp.set_speed(self.speed)
else:
self._updateDevice(1, TimedOut=1)
elif task["Action"] == "Off":
if self.lamp.off():
self._updateDevice(1, nValue=0, TimedOut=0)
else:
self._updateDevice(1, TimedOut=1)
elif task["Action"] == "SetColor":
ColorDict = json.loads(task["Color"])
Level = int(task["Level"])
Domoticz.Debug(
"Color dictionnary = {}, LastLevel = {}".format(Devices[1].Color, Devices[1].LastLevel))
if ColorDict["m"] == 1 or ColorDict["m"] == 3:
self.levelRed = int(ColorDict["r"] * Level / 100)
self.levelGreen = int(ColorDict["g"] * Level / 100)
self.levelBlue = int(ColorDict["b"] * Level / 100)
self.levelWhite = int(ColorDict["ww"] * Level / 100)
if self.lamp.set_rgbw(self.levelRed, self.levelGreen, self.levelBlue, self.levelWhite):
self._updateDevice(1, nValue=1, sValue=str(Level), Color=task["Color"], TimedOut=0)
else:
self._updateDevice(1, TimedOut=1)
else:
Domoticz.Error("Invalid 'Set Color' m-value: {}".format(ColorDict["m"]))
elif task["Action"] == "SetLevel":
Level = int(task["Level"])
LastLevel = 100 if Devices[1].LastLevel == 0 else Devices[1].LastLevel
self.levelRed = int(self.levelRed / LastLevel * Level)
self.levelGreen = int(self.levelGreen / LastLevel * Level)
self.levelBlue = int(self.levelBlue / LastLevel * Level)
self.levelWhite = int(self.levelWhite / LastLevel * Level)
if self.lamp.set_rgbw(self.levelRed, self.levelGreen, self.levelBlue, self.levelWhite):
self._updateDevice(1, nValue=1, sValue=str(Level), Color=task["Color"], TimedOut=0)
else:
self._updateDevice(1, TimedOut=1)
elif task["Action"] == "SetEffect":
if self.lamp.set_effect(self.effect):
self._updateDevice(2,
nValue=0 if self.effect == 255 else 1,
sValue="" if self.effect == 255 else str((self.effect + 1) * 10),
TimedOut=0)
else:
self._updateDevice(2, TimedOut=1)
elif task["Action"] == "SetSpeed":
Level = int(task["Level"])
if self.lamp.set_speed(self.speed):
self._updateDevice(3, nValue=0 if self.speed == 0 else 1, sValue=str(Level), TimedOut=0)
else:
self._updateDevice(3, TimedOut=1)
elif task["Action"] == "GetBattery":
if self.lamp.get_state():
self.battery = int(self.lamp.battery)
self._updateDevice(1, BatteryLevel=self.battery, Forced=True, TimedOut=0)
# we update the battery level device if the user wants to see it
if Parameters["Mode2"] == "1" and not self.battery == 255:
if self.battery >= 75:
icon = "mipowplaybulbfull"
elif self.battery >= 50:
icon = "mipowplaybulbok"
elif self.battery >= 25:
icon = "mipowplaybulblow"
else:
icon = "mipowplaybulbempty"
try:
self._updateDevice(4, nValue=0, sValue=str(self.battery), Image=Images[icon].ID,
TimedOut=0)
except Exception as error:
Domoticz.Error("Failed to update battery level device due to: {}".format(error))
else:
self._updateDevice(1, TimedOut=1)
if 4 in Devices:
self._updateDevice(4, TimedOut=1)
else:
Domoticz.Error("task handler: unknown action code '{}'".format(task["Action"]))
self.tasksQueue.task_done()
Domoticz.Debug("finished handling task: '" + task["Action"] + "'.")
except Exception as err:
Domoticz.Error("handletask: " + str(err))
@staticmethod
def _updateDevice(Unit, **kwargs):
if Unit in Devices:
# check if kwargs contain an update for nValue or sValue... if not, use the existing one(s)
if "nValue" in kwargs:
nValue = kwargs["nValue"]
else:
nValue = Devices[Unit].nValue
if "sValue" in kwargs:
sValue = kwargs["sValue"]
else:
sValue = Devices[Unit].sValue
# build the arguments for the call to Device.Update
update_args = {"nValue": nValue, "sValue": sValue}
change = False
if nValue != Devices[Unit].nValue or sValue != Devices[Unit].sValue:
change = True
for arg in kwargs:
if arg == "TimedOut":
if kwargs[arg] != Devices[Unit].TimedOut:
change = True
update_args[arg] = kwargs[arg]
Domoticz.Debug("TimedOut = {}".format(kwargs[arg]))
if arg == "BatteryLevel":
if kwargs[arg] != Devices[Unit].BatteryLevel:
change = True
update_args[arg] = kwargs[arg]
Domoticz.Debug("BatteryLevel = {}".format(kwargs[arg]))
if arg == "Color":
try:
if kwargs[arg] != Devices[Unit].Color:
change = True
except:
change = True
finally:
if change:
update_args[arg] = kwargs[arg]
Domoticz.Debug("Color = {}".format(kwargs[arg]))
if arg == "Image":
if kwargs[arg] != Devices[Unit].Image:
change = True
update_args[arg] = kwargs[arg]
if arg == "Forced":
change = change or kwargs[arg]
Domoticz.Debug("Change in device {} = {}".format(Unit, change))
if change:
Devices[Unit].Update(**update_args)
def _ResetLamp(self):
# switch what needs to be switched
# update effects
self.lamp.set_effect(self.effect)
# update speed
self.lamp.set_speed(self.speed)
if Devices[1].nValue == 1: # lamp should be on
self.lamp.set_rgbw(self.levelRed, self.levelGreen, self.levelBlue, self.levelWhite)
else:
self.lamp.off()
# get battery level
self.lamp.get_state()
self.battery = int(self.lamp.battery)
global _plugin
_plugin = BasePlugin()
def onStart():
global _plugin
_plugin.onStart()
def onStop():
global _plugin
_plugin.onStop()
def onCommand(Unit, Command, Level, Color):
global _plugin
_plugin.onCommand(Unit, Command, Level, Color)
def onHeartbeat():
global _plugin
_plugin.onHeartbeat()
``` |
{
"source": "999wwx/mindgo_quantitative_investment",
"score": 2
} |
#### File: 999wwx/mindgo_quantitative_investment/Quantitative_investment.py
```python
def init(context):
# 设置基准收益：沪深300指数
set_benchmark('000300.SH')
# 打印日志
log.info('策略开始运行,初始化函数全局只运行一次')
# 设置股票每笔交易的手续费为万分之二(手续费在买卖成交后扣除,不包括税费,税费在卖出成交后扣除)
set_commission(PerShare(type='stock',cost=0.0002))
# 设置股票交易滑点0.5%,表示买入价为实际价格乘1.005,卖出价为实际价格乘0.995
set_slippage(PriceSlippage(0.005))
# 设置日级最大成交比例25%,分钟级最大成交比例50%
# 日频运行时，下单数量超过当天真实成交量25%,则全部不成交
# 分钟频运行时，下单数量超过当前分钟真实成交量50%,则全部不成交
set_volume_limit(0.25,0.5)
context.buy_temp_time = {}
context.buy_temp_price = {}
context.temp_time = 19
# 设置要操作的股票
context.security = get_index_stocks('000300.SH')
# n1为模型买入启动或卖出启动形态形成时的价格比较滞后期数
# n2为模型买入启动或卖出启动形态形成的价格关系单向连续个数
# n3为模型计数阶段的最终信号发出所需的计数值。
# n4为计算止损点的ATR系数
# n5为计算第一次加仓价的ATR系数
# n6为计算止盈点的ATR系数
# n7为计算第二次加仓价的ATR系数
context.n1 = 3
context.n2 = 3
context.n3 = 2
context.n4 = 1.5
context.n5 = 0.4
context.n6 = 2.5
context.n7 = 0.4
# 回测区间、初始资金、运行频率请在右上方设置
# 计数期间最高价与最低价
#每日开盘前9:00被调用一次,用于储存自定义参数、全局变量,执行盘前选股等
def before_trading(context):
# 获取日期
date = get_datetime().strftime('%Y-%m-%d %H:%M:%S')
# 打印日期
log.info('{} 盘前运行'.format(date))
#因子数据缺失填补函数
def fill_ndarray(t1):
import numpy as np
for i in range(t1.shape[1]): # 遍历每一列（每一列中的nan替换成该列的均值）
temp_col = t1[:, i] # 当前的一列
nan_num = np.count_nonzero(temp_col != temp_col)
if nan_num != 0: # 不为0，说明当前这一列中有nan
temp_not_nan_col = temp_col[temp_col == temp_col] # 去掉nan的ndarray
# 选中当前为nan的位置，把值赋值为不为nan的均值
temp_col[np.isnan(temp_col)] = temp_not_nan_col.mean() # mean()表示求均值。
return t1
## 开盘时运行函数
def handle_bar(context, bar_dict):
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.metrics import accuracy_score
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.decomposition import PCA
import time
import datetime
import math
print(len(context.security))
context.temp_time += 1
if context.temp_time == 20:
context.temp_time = 0
# 获取股票代码
print('获取股票代码')
stock_list = get_index_stocks('000300.SH')
#剔除回测当日前6个月内上市的股票
time1 = get_datetime()-datetime.timedelta(days=180)
time1 = time1.strftime('%Y-%m-%d')
for s in stock_list:
info = get_security_info(s)
# print(str(info.start_date)[0:10])
if str(info.start_date)[0:10] > time1:
print(time1 + ' ' + str(info.start_date)[0:10])
stock_list.remove(s)
# 设置训练时间
train_time = 60
# 设置获取数据截止的时间
train_date_end = '20200530'
# 获取回测前一天时间
predict_date = get_datetime()-datetime.timedelta(days=1)
predict_date = predict_date.strftime('%Y%m%d')
# 获取股票信息，以字典形式保存
print('获取股票信息，以字典形式保存')
b = get_candle_stick(stock_list, end_date=predict_date, fre_step='1d', fields=['close'], skip_paused=False, fq='pre', bar_count=train_time, is_panel=1)
c = get_candle_stick(stock_list, end_date=predict_date, fre_step='1d', fields=['close'], skip_paused=False, fq='pre', bar_count=1, is_panel=1)
result = {} # key为股票名，value为index为到设定时间60天有有效数据的时间，columns为收盘价的dataframe
all_stocks = {} # key为股票名，value为index为预测涨跌的时间，columns为收盘价的dataframe
for item in stock_list:
temp = b.minor_xs(item).loc[:,['close']]
temp1 = c.minor_xs(item).loc[:,['close']]
result[item] = temp
all_stocks[item] = temp1
# 获取开始训练的时间
train_date_start = str(result[item].index[0])[0:10]
train_date_start = datetime.datetime.strptime(train_date_start, '%Y-%m-%d').strftime('%Y%m%d')
# 获取结束训练的时间
train_date_end = str(result[item].index[int(train_time/2)-1])[0:10]
train_date_end = datetime.datetime.strptime(train_date_end, '%Y-%m-%d').strftime('%Y%m%d')
#剔除股票池中在训练和预测期间停牌股票和ST股
judge=get_price(stock_list,train_date_start,predict_date,'1d',['is_paused','is_st'])
for s in stock_list:
stock_spare=stock_list
for row in judge[s].iterrows():
if row[1].loc['is_paused']==1 or row[1].loc['is_st']==1:
stock_spare.remove(s)
break
stock_list=stock_spare
#重新获取股票信息
result = {} # key为股票名，value为index为到设定时间60天有有效数据的时间，columns为收盘价的dataframe
all_stocks = {} # key为股票名，value为index为预测涨跌的时间，columns为收盘价的dataframe
for item in stock_list:
temp = b.minor_xs(item).loc[:,['close']]
temp1 = c.minor_xs(item).loc[:,['close']]
result[item] = temp
all_stocks[item] = temp1
# 添加label（一个月收益率）
print('添加label（一个月收益率）')
for key in result:
temp = result[key]
list_temp_time = list(temp.index)
temp['label'] = np.nan
for i in range(int(train_time/2)):
temp['label'][list_temp_time[i]] = (temp['close'][list_temp_time[i+30]]-temp['close'][list_temp_time[i]])/temp['close'][list_temp_time[i]]
temp.dropna(axis=0, how='any', inplace=True)
#获取对应股票因子,归一化处理
print('获取对应股票因子,归一化处理')
factor_list = ['bbi','ma','expma','dbcd','wad','obv','bbiboll','boll','cdp','env','vstd','micd','pb','pcf_cash_flow_ttm','ps','ps_ttm']
for key in list(result.keys()):
result_spare=result
train = result[key] # 对应股票的日期及其收盘价和未来一个月收益率
test = all_stocks[key] # 需要预测股票回测日收盘价
# 获取对应股票在训练期间内的因子数据
dict_train = get_sfactor_data(start_date=train_date_start,end_date=train_date_end,stocks=[key],factor_names=factor_list)
#剔除训练期间因子数据缺失的股票
train_nan=0
for i in range(16):
if math.isnan(dict_train[factor_list[i]].iloc[0,0]) or math.isinf(dict_train[factor_list[i]].iloc[0,0]):
train_nan=train_nan+1
if train_nan!=0:
del result_spare[key]
stock_list.remove(key)
print('训练时间剔除',key)
continue
# 获取对应股票在预测日期的因子数据
temp_i = 1
while 1:
try:
dict_test = get_sfactor_data(start_date=predict_date,end_date=predict_date,stocks=[key],factor_names=factor_list)
except IndexError:
temp_i += 1
predict_date = get_datetime()-datetime.timedelta(days=temp_i)
predict_date = predict_date.strftime('%Y%m%d')
else:
break
#剔除回测前一天因子数据缺失的股票
predict_nan=0
for i in range(16):
if math.isnan(dict_test[factor_list[i]].iloc[0,0]) or math.isinf(dict_test[factor_list[i]].iloc[0,0]):
predict_nan=predict_nan+1
if predict_nan!=0:
del result_spare[key]
stock_list.remove(key)
print('回测时间剔除',key)
continue
#数据归一化处理
for key1 in dict_train:
train[key1] = dict_train[key1].values.T
test[key1] = dict_test[key1].values.T
MIN = train.loc[:,key1].min()
MAX = train.loc[:,key1].max()
if MAX-MIN!=0:
train.loc[:,key1] = (train.loc[:,key1]-MIN)/(MAX-MIN)
test.loc[:,key1] = (test.loc[:,key1]-MIN)/(MAX-MIN)
train.drop(['close'],axis=1,inplace=True)
test.drop(['close'],axis=1,inplace=True)
print('完成因子数据归一化操作')
result=result_spare
# 生成训练集和测试集
print('准备生成训练集和测试机')
train_label = np.zeros((2,1))
train_data = np.zeros((2,16)) #根据因子数变动
test_data = np.zeros((2,16))
for key in result:
train = result[key]
test = all_stocks[key]
temp1 = train.loc[:,'label'].values
temp1 = np.reshape(temp1,(30,1))
temp2 = train.loc[:,factor_list].values #根据因子数变动
temp3 = test.loc[:,factor_list].values
train_label = np.concatenate((train_label,temp1),axis=0)
train_data = np.concatenate((train_data,temp2),axis=0)
test_data = np.concatenate((test_data,temp3),axis=0)
train_label = np.delete(train_label,(0,1),axis=0)
train_label = np.reshape(train_label,(len(stock_list)*30))
train_data = np.delete(train_data,(0,1),axis=0)
test_data = np.delete(test_data,(0,1),axis=0)
# 因子数据缺失填补
print('因子数据缺失值填补')
train_data = fill_ndarray(train_data)
# 开始训练和预测
print('开始训练和预测')
pca = PCA(n_components=10,copy=True,whiten=False)
pca.fit(train_data)
new_train_data = pca.transform(train_data)
new_test_data = pca.transform(test_data)
Ada1 = AdaBoostClassifier(DecisionTreeClassifier(criterion='entropy'),n_estimators=15,algorithm="SAMME.R",learning_rate=0.2)
train_label = train_label * 100
Ada1.fit(new_train_data,train_label.astype(int))
test_predict = Ada1.predict(new_test_data)
select_stocks = []
stocks_dict={}
for i in range(len(test_predict)):
stocks_dict[stock_list[i]] = test_predict[i]
stocks_dict = sorted(stocks_dict.items(), key=lambda d: d[1], reverse=True)
for i in range(30):
if stocks_dict[i][1]>0:
select_stocks.append(stocks_dict[i][0])
print(select_stocks)
context.security = select_stocks
# 获取时间
time = get_datetime().strftime('%Y-%m-%d %H:%M:%S')
# 打印时间
log.info('{} 盘中运行'.format(time))
for symbol in context.security:
# 获取股票过去20天的收盘价数据
closeprice = history(context.security, ['close'], 20, '1d', False, 'pre', is_panel=1)
highprice = history(context.security, ['high'], 20, '1d', False, 'pre', is_panel=1)
lowprice = history(context.security, ['low'], 20, '1d', False, 'pre', is_panel=1)
count_highest_price = 0
count_minimum_price = 999999999999
# 获取账户持仓股票列表
stocklist = list(context.portfolio.stock_account.positions)
if symbol in stocklist:
ud = get_ud(symbol, closeprice, context.n1)
flag, start = sell_out_start_count(symbol, ud, 0, context.n2)
if flag == 1:
sell_out_time = sell_out_signal_count(symbol, start, ud, closeprice, highprice, lowprice, context.n3)
if sell_out_time != -1:
# 得到卖出信号，卖出所有本只股票,使这只股票的最终持有量为0
order_target(symbol, 0)
log.info('得到卖出信号，卖出股票：%s' % symbol)
else:
ud = get_ud(symbol, closeprice, context.n1)
flag, start = buy_start_count(symbol, ud, 0, context.n2)
if flag == 1:
buy_time = buy_signal_count(symbol, start, ud, closeprice, highprice, lowprice, context.n3)
if buy_time != -1:
# 按金额下单,异常处理
try:
id = order_value(symbol, 400000, price=None, style=None)
log.info('得到买入信号，买入股票：%s' % symbol)
context.buy_temp_price[symbol] = get_order(id).avg_price
except AttributeError:
continue
else:
context.buy_temp_time[symbol] = time
log.info('{} 盘中运行完成'.format(time))
## 收盘后运行函数,用于储存自定义参数、全局变量,执行盘后选股等
def after_trading(context):
# 获取时间
time = get_datetime().strftime('%Y-%m-%d %H:%M:%S')
# 打印时间
log.info('{} 盘后运行'.format(time))
log.info('一天结束')
def get_ud(symbol, price_close, n1=4):
# 获得指定股票ud序列
ud = []
for i in range(n1,len(price_close['close'])):
if price_close['close'][symbol][i]-price_close['close'][symbol][i-n1] > 0:
ud.append(1)
elif price_close['close'][symbol][i]-price_close['close'][symbol][i-n1] < 0:
ud.append(-1)
else:
ud.append(0)
return ud
def sell_out_start_count(symbol, ud, start, n2=4):
#卖出_启动计数
count = ud[0]
for i in range(start, len(ud)):
if ud[i] != ud[i-1]:
count = ud[i]
else:
count += ud[i]
if count == n2:
# 返回flag 1为卖出启动，i为卖出启动时间
return 1, i
return 0, 0
def buy_start_count(symbol, ud, start, n2=4):
#买入_启动计数
count = ud[0]
for i in range(start, len(ud)):
if ud[i] != ud[i-1]:
count = ud[i]
else:
count += ud[i]
if count == -n2:
# 返回flag 1为卖入启动，i为卖入启动时间
return 1, i
return 0, 0
def buy_signal_count(symbol, start, ud, price_close, price_high, price_low, n3=4):
#买入信号_计数
global count_minimum_price
flag,end = buy_start_count(symbol, ud, start)
first_temp = -1
temp = 0
if flag == 1:
count_minimum_price = min(tuple(price_low['low'][symbol][start:end]))
while True:
for i in range(start,end):
if price_close['close'][symbol][i] >= price_high['high'][symbol][start+1]:
if price_high['high'][symbol][i] > price_high['high'][symbol][i-1]:
first_temp = i
temp = 1
break;
break
if first_temp == -1:
return -1
for i in range(first_temp, end):
if price_close['close'][symbol][i] >= price_high['high'][symbol][start+1]:
if price_high['high'][symbol][i] > price_high['high'][symbol][i-1]:
if price_close['close'][symbol][i] > price_close['close'][symbol][first_temp]:
temp += 1
if temp == n3:
return i
return -1
elif flag == 0:
count_minimum_price = min(tuple(price_low['low'][symbol]))
while True:
for i in range(start,len(price_close)):
if price_close['close'][symbol][i] >= price_high['high'][symbol][start+1]:
if price_high['high'][symbol][i] > price_high['high'][symbol][i-1]:
first_temp = i
temp = 1
break;
break
if first_temp == -1:
return -1
for i in range(first_temp, end):
if price_close['close'][symbol][i] >= price_high['high'][symbol][start+1]:
if price_high['high'][symbol][i] > price_high['high'][symbol][i-1]:
if price_close['close'][symbol][i] > price_close['close'][symbol][first_temp]:
temp += 1
if temp == n3:
return i
return -1
def sell_out_signal_count(symbol, start, ud, price_close, price_high, price_low, n3=4):
#卖出信号_计数
global count_highest_price
flag, end = sell_out_start_count(symbol, ud, start)
first_temp = -1
temp = 0
if flag == 1:
count_highest_price = max(tuple(price_high['high'][symbol][start:end]))
while True:
for i in range(start,end):
if price_close['close'][symbol][i] <= price_low['low'][symbol][start+1]:
if price_low['low'][symbol][i] < price_low['low'][symbol][i-1]:
temp = 1
first_temp = i
break;
break
if first_temp == -1:
return -1
for i in range(first_temp, end):
if price_close['close'][symbol][i] <= price_low['low'][symbol][start+1]:
if price_low['low'][symbol][i] < price_low['low'][symbol][i-1]:
if price_close['close'][symbol][i] < price_close['close'][symbol][first_temp]:
temp += 1
if temp == n3:
return i
return -1
elif flag == 0:
count_highest_price = max(tuple(price_high['high'][symbol]))
while True:
for i in range(start,len(price_close)):
if price_close['close'][symbol][i] <= price_low['low'][symbol][start+1]:
if price_low['low'][symbol][i] < price_low['low'][symbol][i-1]:
first_temp = i
temp = 1
break;
break
if first_temp == -1:
return -1
for i in range(first_temp, end):
if price_close['close'][symbol][i] <= price_low['low'][symbol][start+1]:
if price_low['low'][symbol][i] < price_low['low'][symbol][i-1]:
if price_close['close'][symbol][i] < price_close['close'][symbol][first_temp]:
temp += 1
if remp == n3:
return i
return -1
``` |
{
"source": "99co/mongoengine",
"score": 3
} |
#### File: 99co/mongoengine/benchmark.py
```python
import timeit
def cprofile_main():
from pymongo import Connection
connection = Connection()
connection.drop_database('timeit_test')
connection.disconnect()
from mongoengine import Document, DictField, connect
connect("timeit_test")
class Noddy(Document):
fields = DictField()
for i in xrange(1):
noddy = Noddy()
for j in range(20):
noddy.fields["key" + str(j)] = "value " + str(j)
noddy.save()
def main():
"""
0.4 Performance Figures ...
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - Pymongo
3.86744189262
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine
6.23374891281
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, safe=False, validate=False
5.33027005196
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, safe=False, validate=False, cascade=False
pass - No Cascade
0.5.X
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - Pymongo
3.89597702026
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine
21.7735359669
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, safe=False, validate=False
19.8670389652
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, safe=False, validate=False, cascade=False
pass - No Cascade
0.6.X
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - Pymongo
3.81559205055
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine
10.0446798801
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, safe=False, validate=False
9.51354718208
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, safe=False, validate=False, cascade=False
9.02567505836
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, force=True
8.44933390617
0.7.X
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - Pymongo
3.78801012039
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine
9.73050498962
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, safe=False, validate=False
8.33456707001
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, safe=False, validate=False, cascade=False
8.37778115273
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, force=True
8.36906409264
0.8.X
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - Pymongo
3.69964408875
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - Pymongo write_concern={"w": 0}
3.5526599884
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine
7.00959801674
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries without continual assign - MongoEngine
5.60943293571
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine - write_concern={"w": 0}, cascade=True
6.715102911
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, write_concern={"w": 0}, validate=False, cascade=True
5.50644683838
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, write_concern={"w": 0}, validate=False
4.69851183891
----------------------------------------------------------------------------------------------------
Creating 10000 dictionaries - MongoEngine, force_insert=True, write_concern={"w": 0}, validate=False
4.68946313858
----------------------------------------------------------------------------------------------------
"""
setup = """
from pymongo import MongoClient
connection = MongoClient()
connection.drop_database('timeit_test')
"""
stmt = """
from pymongo import MongoClient
connection = MongoClient()
db = connection.timeit_test
noddy = db.noddy
for i in xrange(10000):
example = {'fields': {}}
for j in range(20):
example['fields']["key"+str(j)] = "value "+str(j)
noddy.save(example)
myNoddys = noddy.find()
[n for n in myNoddys] # iterate
"""
print "-" * 100
print """Creating 10000 dictionaries - Pymongo"""
t = timeit.Timer(stmt=stmt, setup=setup)
print t.timeit(1)
stmt = """
from pymongo import MongoClient
connection = MongoClient()
db = connection.timeit_test
noddy = db.noddy
for i in xrange(10000):
example = {'fields': {}}
for j in range(20):
example['fields']["key"+str(j)] = "value "+str(j)
noddy.save(example, write_concern={"w": 0})
myNoddys = noddy.find()
[n for n in myNoddys] # iterate
"""
print "-" * 100
print """Creating 10000 dictionaries - Pymongo write_concern={"w": 0}"""
t = timeit.Timer(stmt=stmt, setup=setup)
print t.timeit(1)
setup = """
from pymongo import MongoClient
connection = MongoClient()
connection.drop_database('timeit_test')
connection.disconnect()
from mongoengine import Document, DictField, connect
connect("timeit_test")
class Noddy(Document):
fields = DictField()
"""
stmt = """
for i in xrange(10000):
noddy = Noddy()
for j in range(20):
noddy.fields["key"+str(j)] = "value "+str(j)
noddy.save()
myNoddys = Noddy.objects()
[n for n in myNoddys] # iterate
"""
print "-" * 100
print """Creating 10000 dictionaries - MongoEngine"""
t = timeit.Timer(stmt=stmt, setup=setup)
print t.timeit(1)
stmt = """
for i in xrange(10000):
noddy = Noddy()
fields = {}
for j in range(20):
fields["key"+str(j)] = "value "+str(j)
noddy.fields = fields
noddy.save()
myNoddys = Noddy.objects()
[n for n in myNoddys] # iterate
"""
print "-" * 100
print """Creating 10000 dictionaries without continual assign - MongoEngine"""
t = timeit.Timer(stmt=stmt, setup=setup)
print t.timeit(1)
stmt = """
for i in xrange(10000):
noddy = Noddy()
for j in range(20):
noddy.fields["key"+str(j)] = "value "+str(j)
noddy.save(write_concern={"w": 0}, cascade=True)
myNoddys = Noddy.objects()
[n for n in myNoddys] # iterate
"""
print "-" * 100
print """Creating 10000 dictionaries - MongoEngine - write_concern={"w": 0}, cascade = True"""
t = timeit.Timer(stmt=stmt, setup=setup)
print t.timeit(1)
stmt = """
for i in xrange(10000):
noddy = Noddy()
for j in range(20):
noddy.fields["key"+str(j)] = "value "+str(j)
noddy.save(write_concern={"w": 0}, validate=False, cascade=True)
myNoddys = Noddy.objects()
[n for n in myNoddys] # iterate
"""
print "-" * 100
print """Creating 10000 dictionaries - MongoEngine, write_concern={"w": 0}, validate=False, cascade=True"""
t = timeit.Timer(stmt=stmt, setup=setup)
print t.timeit(1)
stmt = """
for i in xrange(10000):
noddy = Noddy()
for j in range(20):
noddy.fields["key"+str(j)] = "value "+str(j)
noddy.save(validate=False, write_concern={"w": 0})
myNoddys = Noddy.objects()
[n for n in myNoddys] # iterate
"""
print "-" * 100
print """Creating 10000 dictionaries - MongoEngine, write_concern={"w": 0}, validate=False"""
t = timeit.Timer(stmt=stmt, setup=setup)
print t.timeit(1)
stmt = """
for i in xrange(10000):
noddy = Noddy()
for j in range(20):
noddy.fields["key"+str(j)] = "value "+str(j)
noddy.save(force_insert=True, write_concern={"w": 0}, validate=False)
myNoddys = Noddy.objects()
[n for n in myNoddys] # iterate
"""
print "-" * 100
print """Creating 10000 dictionaries - MongoEngine, force_insert=True, write_concern={"w": 0}, validate=False"""
t = timeit.Timer(stmt=stmt, setup=setup)
print t.timeit(1)
if __name__ == "__main__":
main()
``` |
{
"source": "99hats/humbletray",
"score": 2
} |
#### File: humbletray/humbletray/systray.py
```python
from typing import List
from pystray import MenuItem, Menu
import pystray, sys, os
from PIL import Image
import time
from multiprocessing import Process, freeze_support, Queue
import justpy as jp
from humbletray import chromeapp
from dataclasses import dataclass
from loguru import logger
q = Queue()
fig_name = "leaf.png"
@dataclass
class Notification:
title: str
message: str
def resource_path(relative_path):
""" Get absolute path to resource, works for dev and for PyInstaller """
try:
# PyInstaller creates a temp folder and stores path in _MEIPASS
base_path = sys._MEIPASS
except Exception:
if getattr(sys, "frozen", False):
application_path = os.path.dirname(sys.executable)
else:
try:
app_full_path = os.path.realpath(__file__)
application_path = os.path.dirname(app_full_path)
except NameError:
application_path = os.getcwd()
return os.path.join(application_path, relative_path)
fig_full_path = resource_path(fig_name)
class SystrayIconMenu:
def __init__(self, icon, menu=[], exit=None, schedule=None):
self.icon = pystray.Icon("mon")
self.icon.title = "Tooltip"
self.icon.icon = Image.open(icon)
self.schedule = schedule
menu.append(("Exit", lambda: self.exit()))
menu_items = []
for name, action in menu:
menu_items.append(MenuItem(name, action))
self.icon.menu = Menu(*menu_items)
if exit:
self.exit = exit
def action(self):
print("action")
def exit(self):
self.icon.visible = False
self.icon.stop()
def setup(self, icon):
icon.visible = True
i = 0
while icon.visible:
# Some payload code
if self.schedule:
self.schedule.run_pending()
print(i)
i += 1
if not q.empty():
print("q not empty")
msg = q.get()
print(msg)
if type(msg) == Notification:
self.icon.notify(msg.message, msg.title)
time.sleep(5)
def run(self):
self.icon.run(self.setup)
class SystrayApp(object):
def __init__(self, start_server, menu, icon, schedule=None):
self.start_server = start_server
self.menu = menu
self.fig = icon
self.schedule = schedule
def run(self):
freeze_support()
server = Process(target=self.start_server, args=(q,))
server.daemon = True
server.start()
def action():
print("gui action")
import atexit
def clean_exit():
logger.debug("clean exit")
app.exit()
atexit.register(clean_exit)
app = chromeapp.ChromeApp("http://localhost:8000", "humbletray", (800, 600), lockPort=None, chromeargs=[])
menu = [("Open App", action)]
icon = SystrayIconMenu(self.fig, menu, schedule=self.schedule)
icon.run()
server.terminate()
server.join(timeout=1.0)
def run_gui(start_server, menu=None, fig=fig_full_path, schedule=None):
app = SystrayApp(start_server, menu, fig, schedule)
app.run()
``` |
{
"source": "99/httpolice",
"score": 2
} |
#### File: httpolice/httpolice/codings.py
```python
import gzip
import io
import zlib
import brotli
def decode_gzip(data):
return gzip.GzipFile(fileobj=io.BytesIO(data)).read()
def decode_deflate(data):
return zlib.decompress(data)
def decode_brotli(data):
return brotli.decompress(data)
```
#### File: httpolice/httpolice/structure.py
```python
from collections import namedtuple
import six
from httpolice.util.text import force_bytes, force_unicode
###############################################################################
# Commonly useful structures
@six.python_2_unicode_compatible
class Unavailable(object):
"""A wrapper for a value that has no useful representation in context.
This is used to represent failures to decode or parse a string. In this
case, the underlying string (byte- or Unicode) is to be passed to
the constructor.
This is also used to represent values that are known to be present but
whose value could not be obtained, and there is no underlying string that
is available. In this case, nothing should be passed to the constructor.
"""
__slots__ = ('inner',)
def __init__(self, inner=None):
self.inner = inner
def __repr__(self):
return 'Unavailable(%r)' % self.inner
def __str__(self): # pragma: no cover
if self.inner is None:
return u'(?)'
else:
return force_unicode(self.inner)
def __eq__(self, other):
# It's questionable whether an `Unavailable` should ever compare equal
# to another `Unavailable`, seeing as they might be failures in
# different contexts (e.g. trying to parse the same string as two
# different grammar symbols). But in practice, this behavior is useful.
# See ``test/combined_data/1286_2`` for an example.
return isinstance(other, Unavailable) and \
self.inner is not None and self.inner == other.inner
def __hash__(self):
return hash(self.inner)
def okay(x):
return (x is not None) and not isinstance(x, Unavailable)
class Parametrized(namedtuple('Parametrized', ('item', 'param'))):
"""Anything that consists of some "item" + some parameters to that item."""
__slots__ = ()
def __eq__(self, other):
if isinstance(other, tuple):
return super(Parametrized, self).__eq__(other)
else:
return self.item == other
def __ne__(self, other):
if isinstance(other, tuple):
return super(Parametrized, self).__ne__(other)
else:
return self.item != other
def __hash__(self): # pragma: no cover
return hash(self.item)
class MultiDict(object):
"""A bunch of key-value pairs where keys are not unique."""
__slots__ = ('sequence',)
def __init__(self, sequence=None):
if sequence is None:
sequence = []
self.sequence = sequence
@property
def dictionary(self):
# This is generated on the fly every time,
# because `self.sequence` can be mutated,
# e.g. in :class:`httpolice.header.AltSvcView`.
r = {}
for k, v in self.sequence:
r.setdefault(k, []).append(v)
return r
def __repr__(self):
return 'MultiDict(%r)' % self.sequence
def __eq__(self, other):
if isinstance(other, MultiDict):
return self.sequence == other.sequence
return NotImplemented # pragma: no cover
def __ne__(self, other): # pragma: no cover
return not (self == other)
def __getitem__(self, name):
return self.dictionary[name][0]
def __contains__(self, name):
return name in self.dictionary
def __iter__(self):
return iter(self.dictionary)
def __len__(self):
return len(self.sequence)
def get(self, name, default=None):
return self[name] if name in self else default
def getall(self, name):
return self.dictionary.get(name, [])
def duplicates(self):
return [k for k, v in self.dictionary.items() if len(v) > 1]
def index(self, name):
return [k for k, _ in self.sequence].index(name)
@six.python_2_unicode_compatible
class Versioned(namedtuple('Versioned', ('item', 'version'))):
"""Anything that consists of some "item" + a version of that item."""
__slots__ = ()
def __str__(self):
if self.version:
return u'%s/%s' % self
else:
return six.text_type(self.item)
class ProtocolString(six.text_type):
"""Base class for various constant strings used in HTTP."""
__slots__ = ()
def __repr__(self):
return '%s(%s)' % (self.__class__.__name__,
six.text_type.__repr__(self))
class CaseInsensitive(ProtocolString):
__slots__ = ()
def __eq__(self, other):
if isinstance(other, six.text_type):
return self.lower() == other.lower()
return NotImplemented
def __ne__(self, other):
return not (self == other)
def __hash__(self):
return hash(self.lower())
def startswith(self, other):
return self.lower().startswith(other.lower())
def endswith(self, other):
return self.lower().endswith(other.lower())
###############################################################################
# Representations of specific protocol elements
class HTTPVersion(ProtocolString):
__slots__ = ()
http10 = HTTPVersion(u'HTTP/1.0')
http11 = HTTPVersion(u'HTTP/1.1')
http2 = HTTPVersion(u'HTTP/2')
class Method(ProtocolString):
__slots__ = ()
class StatusCode(int):
__slots__ = ()
def __repr__(self):
return 'StatusCode(%d)' % self
informational = property(lambda self: 100 <= self <= 199)
successful = property(lambda self: 200 <= self <= 299)
redirection = property(lambda self: 300 <= self <= 399)
client_error = property(lambda self: 400 <= self <= 499)
server_error = property(lambda self: 500 <= self <= 599)
class HeaderEntry(namedtuple('HeaderEntry', ('name', 'value'))):
"""A single header field from the message's headers or trailers.
A message can have more than one header entry with the same :attr:`name`.
Contrast with :class:`httpolice.header.HeaderView`.
"""
__slots__ = ()
def __new__(cls, name, value):
return super(HeaderEntry, cls).__new__(cls,
FieldName(force_unicode(name)),
force_bytes(value))
def __repr__(self):
return '<HeaderEntry %s>' % self.name
class FieldName(CaseInsensitive):
__slots__ = ()
class TransferCoding(CaseInsensitive):
__slots__ = ()
class ContentCoding(CaseInsensitive):
__slots__ = ()
class ConnectionOption(CaseInsensitive):
"""A connection option (RFC 7230 Section 6.1)."""
__slots__ = ()
class MediaType(CaseInsensitive):
"""A media type.
Although in RFC 7231 a ``media-type`` includes parameters,
what's mainly interesting for HTTPolice is the media type itself,
i.e. the ``type/subtype`` pair.
We could represent it as a tuple, but that's a hopeless rabbit hole,
because then we would branch out to structured suffixes (like ``+xml``),
facet prefixes (like ``vnd.``), and so on.
Instead we have a single string that can be picked apart
by functions in :mod:`httpolice.known.media_type`.
"""
__slots__ = ()
class UpgradeToken(ProtocolString):
"""A protocol name for the ``Upgrade`` header (RFC 7230 Section 6.7).
It is case-sensitive; see https://github.com/httpwg/http11bis/issues/8 .
"""
__slots__ = ()
class LanguageTag(CaseInsensitive):
"""A language tag (RFC 5646)."""
__slots__ = ()
class ProductName(ProtocolString):
"""A product name (RFC 7231 Section 5.5.3, 7.4.2)."""
__slots__ = ()
class Charset(CaseInsensitive):
__slots__ = ()
class EntityTag(namedtuple('EntityTag', ('weak', 'opaque_tag'))):
__slots__ = ()
def weak_equiv(self, other):
"""Weak comparison of entity tags (RFC 7232 Section 2.3.2)."""
return self.opaque_tag == other.opaque_tag
def strong_equiv(self, other):
"""Strong comparison of entity tags (RFC 7232 Section 2.3.2)."""
return not self.weak and not other.weak and \
self.opaque_tag == other.opaque_tag
class RangeUnit(CaseInsensitive):
"""A range unit (RFC 7233 Section 2)."""
__slots__ = ()
class RangeSpecifier(namedtuple('RangeSpecifier', ('unit', 'ranges'))):
"""A request range specifier (RFC 7233 Section 3.1)."""
__slots__ = ()
class ContentRange(namedtuple('ContentRange', ('unit', 'range'))):
"""A response content range (RFC 7233 Section 4.2)."""
__slots__ = ()
class CacheDirective(CaseInsensitive):
"""A cache directive name (RFC 7234 Section 5.2)."""
__slots__ = ()
class WarningValue(namedtuple('WarningValue',
('code', 'agent', 'text', 'date'))):
"""A value from a ``Warning`` header (RFC 7234 Section 5.5)."""
__slots__ = ()
# Allow comparing directly to warn codes
# so that we can do stuff like ``299 in msg.headers.warning``
# (like with :class:`Parametrized`).
def __eq__(self, other):
if isinstance(other, tuple):
return super(WarningValue, self).__eq__(other)
else:
return self.code == other
def __ne__(self, other): # pragma: no cover
return not (self == other)
def __hash__(self): # pragma: no cover
return hash(self.code)
class WarnCode(int):
"""A warn code (RFC 7234 Section 5.5)."""
__slots__ = ()
def __repr__(self):
return 'WarnCode(%d)' % self
class AuthScheme(CaseInsensitive):
__slots__ = ()
class HSTSDirective(CaseInsensitive):
__slots__ = ()
class RelationType(CaseInsensitive):
"""A registered link relation type (RFC 5988 Section 4)."""
__slots__ = ()
class ExtValue(namedtuple('ExtValue', ('charset', 'language', 'value_bytes'))):
"""An ``ext-value`` (RFC 5987)."""
__slots__ = ()
class AltSvcParam(ProtocolString):
"""An ``Alt-Svc`` parameter name (RFC 7838 Section 3)."""
__slots__ = ()
class Preference(CaseInsensitive):
"""An HTTP preference token (RFC 7240 Section 2)."""
__slots__ = ()
class ForwardedParam(CaseInsensitive):
"""A parameter for the Forwarded header (RFC 7239)."""
__slots__ = ()
``` |
{
"source": "99kaits/textbound",
"score": 3
} |
#### File: 99kaits/textbound/bot.py
```python
import discord
from generate import gentext
client = discord.Client()
token = open('token.txt').read()
@client.event
async def on_ready():
print('logged in as {0.user}'.format(client))
@client.event
async def on_message(message):
if message.author == client.user:
return
if message.content.startswith('s!ping'):
await message.channel.send('peng :^)')
if message.content.startswith('s!spit'):
await message.channel.send(gentext())
if message.content.startswith('s!help'):
await message.channel.send("use s!spit to generate text, thats literally it lmao. oh and s!github for github link :sunglasses:")
if message.content.startswith('s!github'):
await message.channel.send("https://github.com/99kaits/textbound")
client.run(token)
```
#### File: 99kaits/textbound/main.py
```python
from flask import Flask, render_template, send_from_directory
from generate import gentext
app = Flask(__name__)
@app.route("/")
def web():
return render_template('index.html', text=gentext())
if __name__ == "__main__":
app.run(threaded=True)
``` |
{
"source": "99Kies/allura",
"score": 2
} |
#### File: ext/admin/widgets.py
```python
from __future__ import unicode_literals
from __future__ import absolute_import
from tg import tmpl_context as c
import ew as ew_core
from ew import jinja2_ew as ew
import formencode
from formencode import validators as fev
from allura import model as M
from allura.lib import validators as V
from allura.lib.widgets import forms as ff
from allura.lib.widgets import form_fields as ffw
from bson import ObjectId
class CardField(ew._Jinja2Widget):
template = 'jinja:allura.ext.admin:templates/admin_widgets/card_field.html'
sort_key = None
defaults = dict(
ew_core.Widget.defaults,
id=None,
name='Deck',
icon_name='group',
items=None,
roles=[],
settings_href=None)
def item_display(self, item):
return repr(item)
def item_id(self, item):
return repr(item)
def resources(self):
yield ew.CSSScript('''.deck li input, .deck li select {
margin: 2px 0 2px 3px;
width: 148px;
}''')
yield ew.JSScript('''$(function() {
$('.active-card').each(function() {
var newitem = $('.new-item', this);
var adder = $('.adder', this);
var deleters = $('.deleter', this);
newitem.remove();
newitem.removeClass('new-item');
deleters.click(function(evt) {
evt.stopPropagation();
evt.preventDefault();
var $this = $(this);
$this.closest('li').remove();
});
adder.click(function(evt) {
evt.stopPropagation();
evt.preventDefault();
newitem.clone().insertBefore(adder.closest('li'));
});
});
});''')
class GroupCard(CardField):
new_item = ew.InputField(
field_type='text', attrs=dict(placeholder='type a username'))
sort_key = 'user.username'
def item_display(self, item):
return item.user.username
def item_id(self, item):
return item.user._id
def role_name(self, role_id):
return M.ProjectRole.query.get(_id=ObjectId(role_id)).name
class _GroupSelect(ew.SingleSelectField):
def options(self):
auth_role = M.ProjectRole.authenticated()
anon_role = M.ProjectRole.anonymous()
options = [
ew.Option(py_value=role._id, label=role.name)
for role in c.project.named_roles]
options.append(ew.Option(py_value=auth_role._id, label=auth_role.name))
options.append(ew.Option(py_value=anon_role._id, label=anon_role.name))
return options
class PermissionCard(CardField):
new_item = _GroupSelect()
sort_key = 'name'
def item_display(self, role):
return role.name
def item_id(self, role):
return role._id
class NewGroupSettings(ff.AdminFormResponsive):
submit_text = 'Save'
class fields(ew_core.NameList):
name = ew.InputField(label='Name')
class ScreenshotAdmin(ff.ForgeFormResponsive):
defaults = dict(
ff.ForgeForm.defaults,
enctype='multipart/form-data',
submit_text='Upload',
)
@property
def fields(self):
fields = [
ew.InputField(name='screenshot', field_type='file',
label='New Screenshot',
attrs={
'accept': 'image/*',
'required': 'true',
}),
ew.InputField(name='caption',
field_type="text",
label='Caption',
attrs={
'title': "Reuse your project name in screenshot file names and create a caption to briefly describe each screenshot.",
'class': 'm-tooltip',
}
)
]
return fields
class FeaturesField(ew.CompoundField):
template = 'jinja:allura.ext.admin:templates/admin_widgets/features_field.html'
fields = [ew.TextField(name='feature', attrs={'style': 'width:89%'})]
def resources(self):
yield ew.JSLink('allura/js/jquery-ui.min.js', location='body_top_js')
yield ew.CSSLink('allura/css/smoothness/jquery-ui.min.css', compress=False) # compress will also serve from a different location, breaking image refs
class MetadataAdmin(ff.AdminForm):
template = 'jinja:allura.ext.admin:templates/admin_widgets/metadata_admin.html'
defaults = dict(
ff.AdminForm.defaults,
enctype='multipart/form-data')
class fields(ew_core.NameList):
name = ew.InputField(field_type='text',
label='Name',
validator=formencode.All(
fev.UnicodeString(not_empty=True, max=40),
V.MaxBytesValidator(max=40)),
attrs={'maxlength': 40,
'title': "This is the publicly viewable name of the project, and will appear on project listings. It should be what you want to see as the project title in search listing.",
'class': 'tooltip',
})
summary = ew.InputField(field_type="text", label='Short Summary',
validator=formencode.All(
fev.UnicodeString(max=70),
V.MaxBytesValidator(max=70)),
attrs={'maxlength': 70,
'title': 'Briefly state what your project is and what it does without repeating the project name. This summary appears in Google search results beneath the project name.',
'class': 'tooltip',
})
short_description = ew.TextArea(label='Full Description',
validator=formencode.All(
fev.UnicodeString(max=1000),
V.MaxBytesValidator(max=1000)),
attrs={
'title': 'Describe the full functionality of your project using related keywords. The first sentence has the most impact on search. Provide unique content that calls out keywords and describes the merits of your project.',
'class': 'tooltip'
})
# Apparently, child field must be CompoundField with custom template
# for SortableRepeatedField to work properly, that's why FeaturesField
# is not just ew.TextField
features = ffw.SortableRepeatedField(
label='Features',
show_msg=False,
show_button=False,
append_to='bottom',
extra_field_on_focus_name='feature',
field=FeaturesField())
icon = ew.FileField(label='Icon', attrs={'accept': 'image/*'},
validator=V.IconValidator())
external_homepage = ew.InputField(field_type="text", label='Homepage',
validator=fev.URL(add_http=True))
video_url = ew.InputField(field_type="text", label="Video (YouTube)",
validator=V.YouTubeConverter())
support_page = ew.InputField(field_type="text", label='Support Page')
support_page_url = ew.InputField(
field_type="text", label='Support Page URL',
validator=fev.URL(add_http=True, if_empty=''))
removal = ew.InputField(field_type="text", label='Removal')
moved_to_url = ew.InputField(
field_type="text", label='Moved Project to URL',
validator=fev.URL(add_http=True, if_empty=''))
delete = ew.InputField(field_type="hidden", label='Delete')
delete_icon = ew.InputField(field_type="hidden", label='Delete Icon')
undelete = ew.InputField(field_type="hidden", label='Undelete')
tracking_id = ew.InputField(
field_type="text", label="Google Analytics ID",
attrs=(dict(placeholder='UA-123456-0', pattern='UA-[0-9]+-[0-9]+')))
twitter_handle = ew.InputField(
field_type="text", label='<NAME>')
facebook_page = ew.InputField(field_type="text", label='Facebook page',
validator=fev.URL(add_http=True))
class AuditLog(ew_core.Widget):
template = 'jinja:allura.ext.admin:templates/widgets/audit.html'
defaults = dict(
ew_core.Widget.defaults,
entries=None,
limit=None,
page=0,
count=0)
class fields(ew_core.NameList):
page_list = ffw.PageList()
page_size = ffw.PageSize()
def resources(self):
for f in self.fields:
for r in f.resources():
yield r
class BlockUser(ffw.Lightbox):
defaults = dict(
ffw.Lightbox.defaults,
name='block-user-modal',
trigger='a.block-user',
content_template='allura.ext.admin:templates/widgets/block_user.html')
class BlockList(ffw.Lightbox):
defaults = dict(
ffw.Lightbox.defaults,
name='block-list-modal',
trigger='a.block-list',
content_template='allura.ext.admin:templates/widgets/block_list.html')
```
#### File: allura/model/neighborhood.py
```python
from __future__ import unicode_literals
from __future__ import absolute_import
import re
import json
import logging
from collections import OrderedDict
from ming import schema as S
from ming.orm import FieldProperty, RelationProperty
from ming.orm.declarative import MappedClass
from ming.utils import LazyProperty
from tg import request
from tg import tmpl_context as c, app_globals as g
from allura.lib import plugin
from .session import main_orm_session
from .filesystem import File
from .types import MarkdownCache
log = logging.getLogger(__name__)
class NeighborhoodFile(File):
class __mongometa__:
session = main_orm_session
indexes = ['neighborhood_id']
neighborhood_id = FieldProperty(S.ObjectId)
re_picker_css_type = re.compile('^/\*(.+)\*/')
re_font_project_title = re.compile('font-family:(.+);\}')
re_color_project_title = re.compile('color:(.+);\}')
re_bgcolor_barontop = re.compile('background\-color:([^;}]+);')
re_bgcolor_titlebar = re.compile('background\-color:([^;}]+);')
re_color_titlebar = re.compile('color:([^;}]+);')
class Neighborhood(MappedClass):
'''Provide a grouping of related projects.
url_prefix - location of neighborhood (may include scheme and/or host)
css - block of CSS text to add to all neighborhood pages
'''
class __mongometa__:
session = main_orm_session
name = str('neighborhood')
unique_indexes = ['url_prefix']
_id = FieldProperty(S.ObjectId)
name = FieldProperty(str)
# e.g. http://adobe.openforge.com/ or projects/
url_prefix = FieldProperty(str)
shortname_prefix = FieldProperty(str, if_missing='')
css = FieldProperty(str, if_missing='')
homepage = FieldProperty(str, if_missing='')
homepage_cache = FieldProperty(MarkdownCache)
redirect = FieldProperty(str, if_missing='')
projects = RelationProperty('Project')
allow_browse = FieldProperty(bool, if_missing=True)
show_title = FieldProperty(bool, if_missing=True)
site_specific_html = FieldProperty(str, if_missing='')
project_template = FieldProperty(str, if_missing='')
tracking_id = FieldProperty(str, if_missing='')
project_list_url = FieldProperty(str, if_missing='')
level = FieldProperty(S.Deprecated)
allow_private = FieldProperty(S.Deprecated)
features = FieldProperty(dict(
private_projects=bool,
max_projects=S.Int,
css=str,
google_analytics=bool))
anchored_tools = FieldProperty(str, if_missing='')
prohibited_tools = FieldProperty(str, if_missing='')
use_wiki_page_as_root = FieldProperty(bool, if_missing=False)
def parent_security_context(self):
return None
@LazyProperty
def neighborhood_project(self):
from .project import Project
p = Project.query.get(
neighborhood_id=self._id,
is_nbhd_project=True)
assert p
return p
@property
def acl(self):
return self.neighborhood_project.acl
@property
def shortname(self):
return self.url_prefix.strip('/')
def url(self):
url = self.url_prefix
if url.startswith('//'):
try:
return request.scheme + ':' + url
except TypeError: # pragma no cover
return 'http:' + url
else:
return url
@LazyProperty
def projects_count(self):
from allura import model as M
from allura.lib import helpers as h
q = dict(
deleted=False,
is_nbhd_project=False,
neighborhood_id=self._id)
total = 0
for p in M.Project.query.find(q):
if h.has_access(p, 'read')():
total = total + 1
if total == 100:
return total
return total
def register_project(self, shortname, user=None, project_name=None, user_project=False, private_project=False, apps=None):
'''Register a new project in the neighborhood. The given user will
become the project's superuser. If no user is specified, c.user is used.
'''
provider = plugin.ProjectRegistrationProvider.get()
if project_name is None:
project_name = shortname
return provider.register_project(
self, shortname, project_name, user or getattr(c, 'user', None), user_project, private_project, apps)
def get_custom_css(self):
if self.allow_custom_css:
return self.css
return ""
@property
def has_home_tool(self):
return (self.neighborhood_project
.app_config_by_tool_type('home') is not None)
@property
def icon(self):
# New icon storage uses the neighborhood_project object, so Project.icon* methods can be shared
if self.neighborhood_project.get_tool_data('allura', 'icon_original_size'):
icon = self.neighborhood_project.icon
else:
# fallback to older storage location
icon = NeighborhoodFile.query.get(neighborhood_id=self._id)
return icon
@property
def allow_custom_css(self):
return self.features['css'] == 'custom' or self.features['css'] == 'picker'
def get_project_template(self):
if self.project_template:
return json.loads(self.project_template)
return {}
def get_max_projects(self):
return self.features['max_projects']
def get_css_for_picker(self):
projecttitlefont = {'label': 'Project title, font',
'name': 'projecttitlefont', 'value': '', 'type': 'font'}
projecttitlecolor = {'label': 'Project title, color',
'name': 'projecttitlecolor', 'value': '', 'type': 'color'}
barontop = {'label': 'Bar on top', 'name':
'barontop', 'value': '', 'type': 'color'}
titlebarbackground = {'label': 'Title bar, background',
'name': 'titlebarbackground', 'value': '', 'type': 'color'}
titlebarcolor = {
'label': 'Title bar, foreground', 'name': 'titlebarcolor', 'value': '', 'type': 'color'}
if self.css is not None:
for css_line in self.css.split('\n'):
m = re_picker_css_type.search(css_line)
if not m:
continue
css_type = m.group(1)
if css_type == "projecttitlefont":
m = re_font_project_title.search(css_line)
if m:
projecttitlefont['value'] = m.group(1)
elif css_type == "projecttitlecolor":
m = re_color_project_title.search(css_line)
if m:
projecttitlecolor['value'] = m.group(1)
elif css_type == "barontop":
m = re_bgcolor_barontop.search(css_line)
if m:
barontop['value'] = m.group(1)
elif css_type == "titlebarbackground":
m = re_bgcolor_titlebar.search(css_line)
if m:
titlebarbackground['value'] = m.group(1)
elif css_type == "titlebarcolor":
m = re_color_titlebar.search(css_line)
if m:
titlebarcolor['value'] = m.group(1)
styles_list = []
styles_list.append(projecttitlefont)
styles_list.append(projecttitlecolor)
styles_list.append(barontop)
styles_list.append(titlebarbackground)
styles_list.append(titlebarcolor)
return styles_list
@staticmethod
def compile_css_for_picker(css_form_dict):
# Check css values
for key in css_form_dict.keys():
if ';' in css_form_dict[key] or '}' in css_form_dict[key]:
css_form_dict[key] = ''
css_text = ""
if 'projecttitlefont' in css_form_dict and css_form_dict['projecttitlefont'] != '':
css_text += "/*projecttitlefont*/.project_title{font-family:%s;}\n" % (
css_form_dict['projecttitlefont'])
if 'projecttitlecolor' in css_form_dict and css_form_dict['projecttitlecolor'] != '':
css_text += "/*projecttitlecolor*/.project_title{color:%s;}\n" % (
css_form_dict['projecttitlecolor'])
if 'barontop' in css_form_dict and css_form_dict['barontop'] != '':
css_text += "/*barontop*/.pad h2.colored {background-color:%(bgcolor)s; background-image: none;}\n" % \
{'bgcolor': css_form_dict['barontop']}
if 'titlebarbackground' in css_form_dict and css_form_dict['titlebarbackground'] != '':
css_text += "/*titlebarbackground*/.pad h2.title{background-color:%(bgcolor)s; background-image: none;}\n" % \
{'bgcolor': css_form_dict['titlebarbackground']}
if 'titlebarcolor' in css_form_dict and css_form_dict['titlebarcolor'] != '':
css_text += "/*titlebarcolor*/.pad h2.title, .pad h2.title small a {color:%s;}\n" % (
css_form_dict['titlebarcolor'])
return css_text
def migrate_css_for_picker(self):
self.css = ""
def get_anchored_tools(self):
if not self.anchored_tools:
return dict()
try:
anchored_tools = [at.strip()
for at in self.anchored_tools.split(',')]
return OrderedDict((tool.split(':')[0].lower(), tool.split(':')[1]) for tool in anchored_tools)
except Exception:
log.warning("anchored_tools isn't valid", exc_info=True)
return dict()
def get_prohibited_tools(self):
prohibited_tools = []
if self.prohibited_tools:
prohibited_tools = [tool.lower().strip() for tool in self.prohibited_tools.split(',')]
return prohibited_tools
```
#### File: allura/tasks/export_tasks.py
```python
from __future__ import unicode_literals
from __future__ import absolute_import
import os
import os.path
import logging
import shutil
import codecs
import tg
from tg import app_globals as g, tmpl_context as c
from allura.tasks import mail_tasks
from allura.lib.decorators import task
from allura.lib import helpers as h
from allura.model.repository import zipdir
log = logging.getLogger(__name__)
@task
def bulk_export(tools, filename=None, send_email=True, with_attachments=False):
'''
Export the current project data. Send notification to current user.
:param list tools: list of mount_points to export
:param str filename: optional filename to use
'''
# it's very handy to use c.* within a @task,
# but let's be explicit and keep it separate from the main code
return BulkExport().process(c.project, tools, c.user, filename, send_email, with_attachments)
class BulkExport(object):
def process(self, project, tools, user, filename=None, send_email=True, with_attachments=False):
export_filename = filename or project.bulk_export_filename()
tmp_path = os.path.join(
project.bulk_export_path(rootdir=tg.config.get('bulk_export_tmpdir', tg.config['bulk_export_path'])),
os.path.splitext(export_filename)[0], # e.g. test-backup-2018-06-26-210524 without the .zip
)
export_path = project.bulk_export_path(rootdir=tg.config['bulk_export_path'])
export_fullpath = os.path.join(export_path, export_filename)
if not os.path.exists(tmp_path):
os.makedirs(tmp_path)
if not os.path.exists(export_path):
os.makedirs(export_path)
apps = [project.app_instance(tool) for tool in tools]
exportable = self.filter_exportable(apps)
results = [self.export(tmp_path, app, with_attachments) for app in exportable]
exported = self.filter_successful(results)
if exported:
zipdir(tmp_path, export_fullpath)
shutil.rmtree(tmp_path.encode('utf8')) # must encode into bytes or it'll fail on non-ascii filenames
if not user:
log.info('No user. Skipping notification.')
return
if not send_email:
return
tmpl = g.jinja2_env.get_template('allura:templates/mail/bulk_export.html')
instructions = tg.config.get('bulk_export_download_instructions', '')
instructions = instructions.format(
project=project.shortname,
filename=export_filename,
c=c,
)
exported_names = [a.config.options.mount_point for a in exported]
tmpl_context = {
'instructions': instructions,
'project': project,
'tools': exported_names,
'not_exported_tools': list(set(tools) - set(exported_names)),
}
mail_tasks.send_system_mail_to_user(user,
'Bulk export for project %s completed' % project.shortname,
tmpl.render(tmpl_context))
def filter_exportable(self, apps):
return [app for app in apps if app and app.exportable]
def export(self, export_path, app, with_attachments=False):
tool = app.config.options.mount_point
json_file = os.path.join(export_path, '%s.json' % tool)
try:
with codecs.open(json_file, 'w', encoding='utf-8') as f:
app.bulk_export(f, export_path, with_attachments)
except Exception:
log.error('Error exporting: %s on %s', tool,
app.project.shortname, exc_info=True)
try:
os.remove(json_file)
except:
pass
return None
else:
return app
def filter_successful(self, results):
return [result for result in results if result is not None]
```
#### File: allura/tasks/mail_tasks.py
```python
from __future__ import unicode_literals
from __future__ import absolute_import
import logging
import six.moves.html_parser
import re
from tg import tmpl_context as c, app_globals as g, config
from bson import ObjectId
import markupsafe
from allura.lib import helpers as h
from allura.lib.decorators import task
from allura.lib import mail_util
from allura.lib import exceptions as exc
import six
log = logging.getLogger(__name__)
smtp_client = mail_util.SMTPClient()
def mail_meta_content(metalink):
'''
Helper function used to include a view action button in your email client
https://developers.google.com/gmail/markup/reference/go-to-action#view_action
:param metalink: url to the page the action button links to
'''
return markupsafe.Markup("""\
<div itemscope itemtype="http://schema.org/EmailMessage">
<div itemprop="action" itemscope itemtype="http://schema.org/ViewAction">
<link itemprop="url" href="%s"></link>
<meta itemprop="name" content="View"></meta>
</div>
<meta itemprop="description" content="View"></meta>
</div>""" % metalink)
@task
def route_email(
peer, mailfrom, rcpttos, data):
'''
Route messages according to their destination:
<topic>@<mount_point>.<subproj2>.<subproj1>.<project>.projects.domain.net
gets sent to c.app.handle_message(topic, message)
'''
try:
msg = mail_util.parse_message(data)
except Exception: # pragma no cover
log.exception('Parse Error: (%r,%r,%r)', peer, mailfrom, rcpttos)
return
if mail_util.is_autoreply(msg):
log.info('Skipping autoreply message: %s', msg['headers'])
return
mail_user = mail_util.identify_sender(peer, mailfrom, msg['headers'], msg)
with h.push_config(c, user=mail_user):
log.info('Received email from %s', c.user.username)
# For each of the addrs, determine the project/app and route
# appropriately
for addr in rcpttos:
try:
userpart, project, app = mail_util.parse_address(addr)
with h.push_config(c, project=project, app=app):
if not app.has_access(c.user, userpart):
log.info('Access denied for %s to mailbox %s',
c.user, userpart)
elif not c.app.config.options.get('AllowEmailPosting', True):
log.info("Posting from email is not enabled")
else:
if msg['multipart']:
msg_hdrs = msg['headers']
for part in msg['parts']:
if part.get('content_type', '').startswith('multipart/'):
continue
msg = dict(
headers=dict(msg_hdrs, **part['headers']),
message_id=part['message_id'],
in_reply_to=part['in_reply_to'],
references=part['references'],
filename=part['filename'],
content_type=part['content_type'],
payload=part['payload'])
c.app.handle_message(userpart, msg)
else:
c.app.handle_message(userpart, msg)
except exc.MailError as e:
log.error('Error routing email to %s: %s', addr, e)
except:
log.exception('Error routing mail to %s', addr)
def create_multipart_msg(text, metalink=None):
"""
Convert Markdown text to plaintext & HTML, combine into a multipart email Message
:param text:
:param metalink:
:return:
"""
def replace_html(matchobj):
text_within_div = matchobj.group(1)
text_within_div = text_within_div.replace('</p>', '\n')
text_within_div = markupsafe._striptags_re.sub('', text_within_div)
return text_within_div
plain_text = text
plain_text = re.sub(r'<div class="markdown_content">(.*)</div>', # strip HTML from markdown generated blocks
replace_html,
plain_text,
flags=re.DOTALL, # match newlines too
)
plain_text = six.moves.html_parser.HTMLParser().unescape(plain_text) # put literal HTML tags back into plaintext
plain_msg = mail_util.encode_email_part(plain_text, 'plain')
html_text = g.forge_markdown(email=True).convert(text)
if metalink:
html_text = html_text + mail_meta_content(metalink)
html_msg = mail_util.encode_email_part(html_text, 'html')
multi_msg = mail_util.make_multipart_message(plain_msg, html_msg)
return multi_msg, plain_msg
@task
def sendmail(fromaddr, destinations, text, reply_to, subject,
message_id, in_reply_to=None, sender=None, references=None, metalink=None):
'''
Send an email to the specified list of destinations with respect to the preferred email format specified by user.
It is best for broadcast messages.
:param fromaddr: ObjectId or str(ObjectId) of user, or email address str
'''
from allura import model as M
addrs_plain = []
addrs_multi = []
if fromaddr is None:
fromaddr = g.noreply
elif not isinstance(fromaddr, six.string_types) or '@' not in fromaddr:
log.warning('Looking up user with fromaddr: %s', fromaddr)
user = M.User.query.get(_id=ObjectId(fromaddr), disabled=False, pending=False)
if not user:
log.warning('Cannot find user with ID: %s', fromaddr)
fromaddr = g.noreply
else:
fromaddr = user.email_address_header()
# Divide addresses based on preferred email formats
for addr in destinations:
if mail_util.isvalid(addr):
addrs_plain.append(addr)
else:
try:
user = M.User.query.get(_id=ObjectId(addr), disabled=False, pending=False)
if not user:
log.warning('Cannot find user with ID: %s', addr)
continue
except:
log.exception('Error looking up user with ID: %r' % addr)
continue
addr = user.email_address_header()
if not addr and user.email_addresses:
addr = user.email_addresses[0]
log.warning(
'User %s has not set primary email address, using %s',
user._id, addr)
if not addr:
log.error(
"User %s (%s) has not set any email address, can't deliver",
user._id, user.username)
continue
if user.get_pref('email_format') == 'plain':
addrs_plain.append(addr)
else:
addrs_multi.append(addr)
multi_msg, plain_msg = create_multipart_msg(text, metalink)
smtp_client.sendmail(
addrs_multi, fromaddr, reply_to, subject, message_id,
in_reply_to, multi_msg, sender=sender, references=references)
smtp_client.sendmail(
addrs_plain, fromaddr, reply_to, subject, message_id,
in_reply_to, plain_msg, sender=sender, references=references)
@task
def sendsimplemail(
fromaddr,
toaddr,
text,
reply_to,
subject,
message_id,
in_reply_to=None,
sender=None,
references=None,
cc=None):
'''
Send a single mail to the specified address.
It is best for single user notifications.
:param fromaddr: ObjectId or str(ObjectId) of user, or email address str
:param toaddr: ObjectId or str(ObjectId) of user, or email address str
'''
from allura import model as M
if fromaddr is None:
fromaddr = g.noreply
elif not isinstance(fromaddr, six.string_types) or '@' not in fromaddr:
log.warning('Looking up user with fromaddr: %s', fromaddr)
user = M.User.query.get(_id=ObjectId(fromaddr), disabled=False, pending=False)
if not user:
log.warning('Cannot find user with ID: %s', fromaddr)
fromaddr = g.noreply
else:
fromaddr = user.email_address_header()
if not isinstance(toaddr, six.string_types) or '@' not in toaddr:
log.warning('Looking up user with toaddr: %s', toaddr)
user = M.User.query.get(_id=ObjectId(toaddr), disabled=False, pending=False)
if not user:
log.warning('Cannot find user with ID: %s', toaddr)
toaddr = g.noreply
else:
toaddr = user.email_address_header()
multi_msg, plain_msg = create_multipart_msg(text)
smtp_client.sendmail(
[toaddr], fromaddr, reply_to, subject, message_id,
in_reply_to, multi_msg, sender=sender, references=references, cc=cc, to=toaddr)
def send_system_mail_to_user(user_or_emailaddr, subject, text):
'''
Sends a standard email from the Allura system itself, to a user.
This is a helper function around sendsimplemail() that generates a new task
:param user_or_emailaddr: an email address (str) or a User object
:param subject: subject of the email
:param text: text of the email (markdown)
'''
if isinstance(user_or_emailaddr, six.string_types):
toaddr = user_or_emailaddr
else:
toaddr = user_or_emailaddr._id
email = {
'toaddr': toaddr,
'fromaddr': '"{}" <{}>'.format(
config['site_name'],
config['forgemail.return_path']
),
'sender': six.text_type(config['forgemail.return_path']),
'reply_to': six.text_type(config['forgemail.return_path']),
'message_id': h.gen_message_id(),
'subject': subject,
'text': text,
}
sendsimplemail.post(**email)
```
#### File: tests/functional/test_auth.py
```python
from __future__ import unicode_literals
from __future__ import print_function
from __future__ import absolute_import
import calendar
from datetime import datetime, time, timedelta
from time import time as time_time
import json
from six.moves.urllib.parse import urlparse, parse_qs
from six.moves.urllib.parse import urlencode
from bson import ObjectId
import re
from ming.orm.ormsession import ThreadLocalORMSession, session
from tg import config, expose
from mock import patch, Mock
import mock
from nose.tools import (
assert_equal,
assert_not_equal,
assert_is_none,
assert_is_not_none,
assert_in,
assert_not_in,
assert_true,
assert_false,
)
from tg import tmpl_context as c, app_globals as g
import oauth2
from allura.tests import TestController
from allura.tests import decorators as td
from allura.tests.decorators import audits, out_audits
from alluratest.controller import setup_trove_categories
from allura import model as M
from allura.lib import plugin
from allura.lib import helpers as h
from allura.lib.multifactor import TotpService, RecoveryCodeService
import six
from six.moves import range
def unentity(s):
return s.replace('"', '"').replace('"', '"')
class TestAuth(TestController):
def test_login(self):
self.app.get('/auth/')
r = self.app.post('/auth/send_verification_link', params=dict(a='<EMAIL>',
_session_id=self.app.cookies['_session_id']))
email = M.User.query.get(username='test-admin').email_addresses[0]
r = self.app.post('/auth/send_verification_link', params=dict(a=email,
_session_id=self.app.cookies['_session_id']))
ThreadLocalORMSession.flush_all()
r = self.app.get('/auth/verify_addr', params=dict(a='foo'))
assert json.loads(self.webflash(r))['status'] == 'error', self.webflash(r)
ea = M.EmailAddress.find({'email': email}).first()
r = self.app.get('/auth/verify_addr', params=dict(a=ea.nonce))
assert json.loads(self.webflash(r))['status'] == 'ok', self.webflash(r)
r = self.app.get('/auth/logout')
with audits('Successful login', user=True):
r = self.app.post('/auth/do_login', params=dict(
username='test-user', password='<PASSWORD>',
_session_id=self.app.cookies['_session_id']),
antispam=True).follow()
assert_equal(r.headers['Location'], 'http://localhost/dashboard')
r = self.app.post('/auth/do_login', antispam=True, params=dict(
username='test-user', password='<PASSWORD>', honey1='robot', # bad honeypot value
_session_id=self.app.cookies['_session_id']),
extra_environ={'regular_antispam_err_handling_even_when_tests': str('true')},
status=302)
wf = json.loads(self.webflash(r))
assert_equal(wf['status'], 'error')
assert_equal(wf['message'], 'Spambot protection engaged')
with audits('Failed login', user=True):
r = self.app.post('/auth/do_login', antispam=True, params=dict(
username='test-user', password='<PASSWORD>',
_session_id=self.app.cookies['_session_id']))
assert 'Invalid login' in str(r), r.showbrowser()
r = self.app.post('/auth/do_login', antispam=True, params=dict(
username='test-usera', password='<PASSWORD>',
_session_id=self.app.cookies['_session_id']))
assert 'Invalid login' in str(r), r.showbrowser()
def test_login_invalid_username(self):
extra = {'username': str('*anonymous')}
r = self.app.get('/auth/', extra_environ=extra)
f = r.forms[0]
encoded = self.app.antispam_field_names(f)
f[encoded['username']] = '<EMAIL>'
f[encoded['password']] = '<PASSWORD>'
r = f.submit(extra_environ={'username': str('*anonymous')})
r.mustcontain('Usernames only include small letters, ')
def test_login_diff_ips_ok(self):
# exercises AntiSpam.validate methods
extra = {'username': str('*anonymous'), 'REMOTE_ADDR': str('11.22.33.44')}
r = self.app.get('/auth/', extra_environ=extra)
f = r.forms[0]
encoded = self.app.antispam_field_names(f)
f[encoded['username']] = 'test-user'
f[encoded['password']] = '<PASSWORD>'
with audits('Successful login', user=True):
r = f.submit(extra_environ={'username': str('*anonymous'), 'REMOTE_ADDR': str('11.22.33.99')})
def test_login_diff_ips_bad(self):
# exercises AntiSpam.validate methods
extra = {'username': str('*anonymous'), 'REMOTE_ADDR': str('2192.168.127.12')}
r = self.app.get('/auth/', extra_environ=extra)
f = r.forms[0]
encoded = self.app.antispam_field_names(f)
f[encoded['username']] = 'test-user'
f[encoded['password']] = '<PASSWORD>'
r = f.submit(extra_environ={'username': str('*anonymous'), 'REMOTE_ADDR': str('11.22.33.99'),
'regular_antispam_err_handling_even_when_tests': str('true')},
status=302)
wf = json.loads(self.webflash(r))
assert_equal(wf['status'], 'error')
assert_equal(wf['message'], 'Spambot protection engaged')
@patch('allura.lib.plugin.AuthenticationProvider.hibp_password_check_enabled', Mock(return_value=True))
@patch('allura.tasks.mail_tasks.sendsimplemail')
def test_login_hibp_compromised_password_untrusted_client(self, sendsimplemail):
# first & only login by this user, so won't have any trusted previous logins
self.app.extra_environ = {'disable_auth_magic': str('True')}
r = self.app.get('/auth/')
f = r.forms[0]
encoded = self.app.antispam_field_names(f)
f[encoded['username']] = 'test-user'
f[encoded['password']] = '<PASSWORD>'
with audits('Attempted login from untrusted location with password in HIBP breach database', user=True):
r = f.submit(status=200)
r.mustcontain('reset your password via email.')
r.mustcontain('reset your password via email.<br>\nPlease check your email')
args, kwargs = sendsimplemail.post.call_args
assert_equal(sendsimplemail.post.call_count, 1)
assert_equal(kwargs['subject'], 'Update your %s password' % config['site_name'])
assert_in('/auth/forgotten_password/', kwargs['text'])
assert_equal([], M.UserLoginDetails.query.find().all()) # no records created
@patch('allura.tasks.mail_tasks.sendsimplemail')
def test_login_hibp_compromised_password_trusted_client(self, sendsimplemail):
self.app.extra_environ = {'disable_auth_magic': str('True')}
# regular login first, so IP address will be recorded and then trusted
r = self.app.get('/auth/')
f = r.forms[0]
encoded = self.app.antispam_field_names(f)
f[encoded['username']] = 'test-user'
f[encoded['password']] = '<PASSWORD>'
with audits('Successful login', user=True):
f.submit(status=302)
self.app.get('/auth/logout')
# this login will get caught by HIBP check, but trusted due to IP address being same
with patch('allura.lib.plugin.AuthenticationProvider.hibp_password_check_enabled', Mock(return_value=True)):
r = self.app.get('/auth/')
f = r.forms[0]
encoded = self.app.antispam_field_names(f)
f[encoded['username']] = 'test-user'
f[encoded['password']] = '<PASSWORD>'
with audits(r'Successful login with password in HIBP breach database, from trusted source '
r'\(reason: exact ip\)', user=True):
r = f.submit(status=302)
assert r.session.get('pwd-expired')
assert_equal(r.session.get('expired-reason'), 'hibp')
assert_equal(r.location, 'http://localhost/auth/pwd_expired')
r = r.follow()
r.mustcontain('must be updated to be more secure')
# changing password covered in TestPasswordExpire
def test_login_disabled(self):
u = M.User.query.get(username='test-user')
u.disabled = True
r = self.app.get('/auth/', extra_environ={'username': str('*anonymous')})
f = r.forms[0]
encoded = self.app.antispam_field_names(f)
f[encoded['username']] = 'test-user'
f[encoded['password']] = '<PASSWORD>'
with audits('Failed login', user=True):
r = f.submit(extra_environ={'username': str('*anonymous')})
def test_login_pending(self):
u = M.User.query.get(username='test-user')
u.pending = True
r = self.app.get('/auth/', extra_environ={'username': str('*anonymous')})
f = r.forms[0]
encoded = self.app.antispam_field_names(f)
f[encoded['username']] = 'test-user'
f[encoded['password']] = '<PASSWORD>'
with audits('Failed login', user=True):
r = f.submit(extra_environ={'username': str('*anonymous')})
def test_login_overlay(self):
r = self.app.get('/auth/login_fragment/', extra_environ={'username': str('*anonymous')})
f = r.forms[0]
encoded = self.app.antispam_field_names(f)
f[encoded['username']] = 'test-user'
f[encoded['password']] = '<PASSWORD>'
with audits('Successful login', user=True):
r = f.submit(extra_environ={'username': str('*anonymous')})
def test_logout(self):
self.app.extra_environ = {'disable_auth_magic': str('True')}
nav_pattern = ('nav', {'class': 'nav-main'})
r = self.app.get('/auth/')
r = self.app.post('/auth/do_login', params=dict(
username='test-user', password='<PASSWORD>',
_session_id=self.app.cookies['_session_id']),
extra_environ={'REMOTE_ADDR': str('127.0.0.1')},
antispam=True).follow().follow()
logged_in_session = r.session['_id']
links = r.html.find(*nav_pattern).findAll('a')
assert_equal(links[-1].string, "Log Out")
r = self.app.get('/auth/logout').follow().follow()
logged_out_session = r.session['_id']
assert logged_in_session is not logged_out_session
links = r.html.find(*nav_pattern).findAll('a')
assert_equal(links[-1].string, 'Log In')
def test_track_login(self):
user = M.User.by_username('test-user')
assert_equal(user.last_access['login_date'], None)
assert_equal(user.last_access['login_ip'], None)
assert_equal(user.last_access['login_ua'], None)
self.app.get('/').follow() # establish session
self.app.post('/auth/do_login',
headers={str('User-Agent'): str('browser')},
extra_environ={'REMOTE_ADDR': str('127.0.0.1')},
params=dict(
username='test-user',
password='<PASSWORD>',
_session_id=self.app.cookies['_session_id'],
),
antispam=True,
)
user = M.User.by_username('test-user')
assert_not_equal(user.last_access['login_date'], None)
assert_equal(user.last_access['login_ip'], '127.0.0.1')
assert_equal(user.last_access['login_ua'], 'browser')
def test_rememberme(self):
username = M.User.query.get(username='test-user').username
r = self.app.get('/').follow() # establish session
# Login as test-user with remember me checkbox off
r = self.app.post('/auth/do_login', params=dict(
username='test-user', password='<PASSWORD>',
_session_id=self.app.cookies['_session_id'],
), antispam=True)
assert_equal(r.session['username'], username)
assert_equal(r.session['login_expires'], True)
for header, contents in r.headerlist:
if header == 'Set-cookie':
assert_not_in('expires', contents)
# Login as test-user with remember me checkbox on
r = self.app.post('/auth/do_login', params=dict(
username='test-user', password='<PASSWORD>', rememberme='on',
_session_id=self.app.cookies['_session_id'],
), antispam=True)
assert_equal(r.session['username'], username)
assert_not_equal(r.session['login_expires'], True)
for header, contents in r.headerlist:
if header == 'Set-cookie':
assert_in('expires', contents)
@td.with_user_project('test-admin')
def test_user_can_not_claim_duplicate_emails(self):
email_address = '<EMAIL>'
user = M.User.query.get(username='test-admin')
addresses_number = len(user.email_addresses)
self.app.get('/').follow() # establish session
self.app.post('/auth/preferences/update_emails',
params={
'new_addr.addr': email_address,
'new_addr.claim': 'Claim Address',
'primary_addr': '<EMAIL>',
'preferences.email_format': 'plain',
'password': '<PASSWORD>',
'_session_id': self.app.cookies['_session_id'],
},
extra_environ=dict(username=str('test-admin')))
assert M.EmailAddress.find(dict(email=email_address, claimed_by_user_id=user._id)).count() == 1
r = self.app.post('/auth/preferences/update_emails',
params={
'new_addr.addr': email_address,
'new_addr.claim': 'Claim Address',
'primary_addr': '<EMAIL>',
'preferences.email_format': 'plain',
'password': '<PASSWORD>',
'_session_id': self.app.cookies['_session_id'],
},
extra_environ=dict(username=str('test-admin')))
assert json.loads(self.webflash(r))['status'] == 'error', self.webflash(r)
assert M.EmailAddress.find(dict(email=email_address, claimed_by_user_id=user._id)).count() == 1
assert len(M.User.query.get(username='test-admin').email_addresses) == addresses_number + 1
@td.with_user_project('test-admin')
@patch('allura.tasks.mail_tasks.sendsimplemail')
@patch('allura.lib.helpers.gen_message_id')
def test_user_added_claimed_address_by_other_user_confirmed(self, gen_message_id, sendsimplemail):
self.app.get('/').follow() # establish session
email_address = '<EMAIL>'
# test-user claimed & confirmed email address
user = M.User.query.get(username='test-user')
user.claim_address(email_address)
email = M.EmailAddress.find(dict(email=email_address)).first()
email.confirmed = True
ThreadLocalORMSession.flush_all()
# Claiming the same email address by test-admin
# the email should be added to the email_addresses list but notifications should not be sent
admin = M.User.query.get(username='test-admin')
addresses_number = len(admin.email_addresses)
r = self.app.post('/auth/preferences/update_emails',
params={
'new_addr.addr': email_address,
'new_addr.claim': 'Claim Address',
'primary_addr': '<EMAIL>',
'preferences.email_format': 'plain',
'password': '<PASSWORD>',
'_session_id': self.app.cookies['_session_id'],
},
extra_environ=dict(username=str('test-admin')))
assert json.loads(self.webflash(r))['status'] == 'ok'
assert json.loads(self.webflash(r))['message'] == 'A verification email has been sent. ' \
'Please check your email and click to confirm.'
args, kwargs = sendsimplemail.post.call_args
assert sendsimplemail.post.call_count == 1
assert kwargs['toaddr'] == email_address
assert kwargs['subject'] == '%s - Email address claim attempt' % config['site_name']
assert "You tried to add %s to your Allura account, " \
"but it is already claimed by your %s account." % (email_address, user.username) in kwargs['text']
assert len(M.User.query.get(username='test-admin').email_addresses) == addresses_number + 1
assert len(M.EmailAddress.find(dict(email=email_address)).all()) == 2
@td.with_user_project('test-admin')
@patch('allura.tasks.mail_tasks.sendsimplemail')
@patch('allura.lib.helpers.gen_message_id')
def test_user_added_claimed_address_by_other_user_not_confirmed(self, gen_message_id, sendsimplemail):
email_address = '<EMAIL>'
# test-user claimed email address
user = M.User.query.get(username='test-user')
user.claim_address(email_address)
email = M.EmailAddress.find(dict(email=email_address)).first()
email.confirmed = False
ThreadLocalORMSession.flush_all()
# Claiming the same email address by test-admin
# the email should be added to the email_addresses list but notifications should not be sent
user1 = M.User.query.get(username='test-user-1')
addresses_number = len(user1.email_addresses)
self.app.get('/').follow() # establish session
r = self.app.post('/auth/preferences/update_emails',
params={
'new_addr.addr': email_address,
'new_addr.claim': 'Claim Address',
'primary_addr': '<EMAIL>',
'preferences.email_format': 'plain',
'password': '<PASSWORD>',
'_session_id': self.app.cookies['_session_id'],
},
extra_environ=dict(username=str('test-user-1')))
assert json.loads(self.webflash(r))['status'] == 'ok'
assert json.loads(self.webflash(r))['message'] == 'A verification email has been sent. ' \
'Please check your email and click to confirm.'
assert sendsimplemail.post.called
assert len(M.User.query.get(username='test-user-1').email_addresses) == addresses_number + 1
assert len(M.EmailAddress.find(dict(email=email_address)).all()) == 2
@td.with_user_project('test-admin')
@patch('allura.tasks.mail_tasks.sendsimplemail')
@patch('allura.lib.helpers.gen_message_id')
def test_user_cannot_claim_more_than_max_limit(self, gen_message_id, sendsimplemail):
with h.push_config(config, **{'user_prefs.maximum_claimed_emails': '2'}):
self.app.get('/').follow() # establish session
r = self.app.post('/auth/preferences/update_emails',
params={
'new_addr.addr': '<EMAIL>',
'new_addr.claim': 'Claim Address',
'primary_addr': '<EMAIL>-<EMAIL>',
'preferences.email_format': 'plain',
'password': '<PASSWORD>',
'_session_id': self.app.cookies['_session_id'],
},
extra_environ=dict(username=str('test-user-1')))
assert json.loads(self.webflash(r))['status'] == 'ok'
r = self.app.post('/auth/preferences/update_emails',
params={
'new_addr.addr': '<EMAIL>',
'new_addr.claim': 'Claim Address',
'primary_addr': '<EMAIL>-<EMAIL>',
'preferences.email_format': 'plain',
'password': '<PASSWORD>',
'_session_id': self.app.cookies['_session_id'],
},
extra_environ=dict(username=str('test-user-1')))
assert json.loads(self.webflash(r))['status'] == 'error'
assert json.loads(self.webflash(r))['message'] == 'You cannot claim more than 2 email addresses.'
@patch('allura.tasks.mail_tasks.sendsimplemail')
@patch('allura.lib.helpers.gen_message_id')
def test_verification_link_for_confirmed_email(self, gen_message_id, sendsimplemail):
self.app.get('/').follow() # establish session
email_address = '<EMAIL>'
# test-user claimed email address
user = M.User.query.get(username='test-user')
user.claim_address(email_address)
email = M.EmailAddress.find(dict(email=email_address, claimed_by_user_id=user._id)).first()
email.confirmed = True
user1 = M.User.query.get(username='test-user-1')
user1.claim_address(email_address)
email = M.EmailAddress.find(dict(email=email_address, claimed_by_user_id=user1._id)).first()
email.confirmed = False
ThreadLocalORMSession.flush_all()
r = self.app.post('/auth/send_verification_link',
params=dict(a=email_address, _session_id=self.app.cookies['_session_id']),
extra_environ=dict(username=str('test-user-1'), _session_id=self.app.cookies['_session_id']))
assert json.loads(self.webflash(r))['status'] == 'ok'
assert json.loads(self.webflash(r))['message'] == 'Verification link sent'
args, kwargs = sendsimplemail.post.call_args
assert sendsimplemail.post.call_count == 1
assert kwargs['toaddr'] == email_address
assert kwargs['subject'] == '%s - Email address claim attempt' % config['site_name']
assert "You tried to add %s to your Allura account, " \
"but it is already claimed by your %s account." % (email_address, user.username) in kwargs['text']
def test_invalidate_verification_link_if_email_was_confirmed(self):
self.app.get('/').follow() # establish session
email_address = '<EMAIL>'
# test-user claimed email address
user = M.User.query.get(username='test-user')
user.claim_address(email_address)
email = M.EmailAddress.find(dict(email=email_address, claimed_by_user_id=user._id)).first()
email.confirmed = False
ThreadLocalORMSession.flush_all()
self.app.post('/auth/send_verification_link',
params=dict(a=email_address,
_session_id=self.app.cookies['_session_id']),
extra_environ=dict(username=str('test-user')))
user1 = M.User.query.get(username='test-user-1')
user1.claim_address(email_address)
email1 = M.EmailAddress.find(dict(email=email_address, claimed_by_user_id=user1._id)).first()
email1.confirmed = True
ThreadLocalORMSession.flush_all()
# Verify first email with the verification link
r = self.app.get('/auth/verify_addr', params=dict(a=email.nonce),
extra_environ=dict(username=str('test-user')))
assert json.loads(self.webflash(r))['status'] == 'error'
email = M.EmailAddress.find(dict(email=email_address, claimed_by_user_id=user._id)).first()
assert not email.confirmed
def test_verify_addr_correct_session(self):
self.app.get('/').follow() # establish session
email_address = '<EMAIL>'
# test-user claimed email address
user = M.User.query.get(username='test-user')
user.claim_address(email_address)
email = M.EmailAddress.find(dict(email=email_address, claimed_by_user_id=user._id)).first()
email.confirmed = False
ThreadLocalORMSession.flush_all()
self.app.post('/auth/send_verification_link',
params=dict(a=email_address,
_session_id=self.app.cookies['_session_id']),
extra_environ=dict(username=str('test-user')))
# logged out, gets redirected to login page
r = self.app.get('/auth/verify_addr', params=dict(a=email.nonce),
extra_environ=dict(username=str('*anonymous')))
assert_in('/auth/?return_to=%2Fauth%2Fverify_addr', r.location)
# logged in as someone else
r = self.app.get('/auth/verify_addr', params=dict(a=email.nonce),
extra_environ=dict(username=str('test-admin')))
assert_in('/auth/?return_to=%2Fauth%2Fverify_addr', r.location)
assert_equal('You must be logged in to the correct account', json.loads(self.webflash(r))['message'])
assert_equal('warning', json.loads(self.webflash(r))['status'])
# logged in as correct user
r = self.app.get('/auth/verify_addr', params=dict(a=email.nonce),
extra_environ=dict(username=str('test-user')))
assert_in('confirmed', json.loads(self.webflash(r))['message'])
assert_equal('ok', json.loads(self.webflash(r))['status'])
@staticmethod
def _create_password_reset_hash():
""" Generates a password reset token for a given user.
:return: User object
:rtype: User
"""
# test-user claimed email address
user = M.User.by_username('test-admin')
user.set_tool_data('AuthPasswordReset',
hash="generated_hash_value",
hash_expiry="04-08-2020")
hash = user.get_tool_data('AuthPasswordReset', 'hash')
session(user).flush(user)
hash_expiry = user.get_tool_data('AuthPasswordReset', 'hash_expiry')
assert_equal(hash, 'generated_hash_value')
assert_equal(hash_expiry, '04-08-2020')
return user
def test_token_generator(self):
""" Generates new token invalidation tests.
The tests cover: changing, claiming, updating, removing email addresses.
:returns: email_change_invalidates_token
"""
_params = [{'new_addr.addr': '<EMAIL>', # Change primary address
'primary_addr': '<EMAIL>', },
{'new_addr.addr': '<EMAIL>', # Claim new address
'new_addr.claim': 'Claim Address',
'primary_addr': '<EMAIL>',
'password': '<PASSWORD>',
'preferences.email_format': 'plain'},
{'addr-1.ord': '1', # remove <EMAIL>
'addr-1.delete': 'on',
'addr-2.ord': '2',
'new_addr.addr': '',
'primary_addr': '<EMAIL>',
'password': '<PASSWORD>',
'preferences.email_format': 'plain'},
{'addr-1.ord': '1', # Remove email
'addr-2.ord': '2',
'addr-2.delete': 'on',
'new_addr.addr': '',
'primary_addr': '<EMAIL>'}]
for param in _params:
yield self.email_change_invalidates_token, param
def email_change_invalidates_token(self, change_params):
user = self._create_password_reset_hash()
session(user).flush(user)
self.app.get('/').follow() # establish session
change_params['_session_id'] = self.app.cookies['_session_id']
self.app.post('/auth/preferences/update_emails',
extra_environ=dict(username=str('test-admin')),
params=change_params)
u = M.User.by_username('test-admin')
print((u.get_tool_data('AuthPasswordReset', 'hash')))
assert_equal(u.get_tool_data('AuthPasswordReset', 'hash'), '')
assert_equal(u.get_tool_data('AuthPasswordReset', 'hash_expiry'), '')
@td.with_user_project('test-admin')
def test_change_password(self):
self.app.get('/').follow() # establish session
# Get and assert user with password reset token.
user = self._create_password_reset_hash()
old_pass = user.get_pref('password')
# Change password
with audits('Password changed', user=True):
self.app.post('/auth/preferences/change_password',
extra_environ=dict(username=str('test-admin')),
params={
'oldpw': 'foo',
'pw': 'asdfasdf',
'pw2': '<PASSWORD>',
'_session_id': self.app.cookies['_session_id'],
})
# Confirm password was changed.
assert_not_equal(old_pass, user.get_pref('password'))
# Confirm any existing tokens were reset.
assert_equal(user.get_tool_data('AuthPasswordReset', 'hash'), '')
assert_equal(user.get_tool_data('AuthPasswordReset', 'hash_expiry'), '')
# Confirm an email was sent
tasks = M.MonQTask.query.find(dict(task_name='allura.tasks.mail_tasks.sendsimplemail')).all()
assert_equal(len(tasks), 1)
assert_equal(tasks[0].kwargs['subject'], 'Password Changed')
assert_in('The password for your', tasks[0].kwargs['text'])
@patch('allura.lib.plugin.AuthenticationProvider.hibp_password_check_enabled', Mock(return_value=True))
@td.with_user_project('test-admin')
def test_change_password_hibp(self):
self.app.get('/').follow() # establish session
# Get and assert user with password reset token.
user = self._create_password_reset_hash()
old_pass = user.get_pref('password')
# Attempt change password with weak pwd
r = self.app.post('/auth/preferences/change_password',
extra_environ=dict(username=str('test-admin')),
params={
'oldpw': 'foo',
'pw': 'password',
'pw2': 'password',
'_session_id': self.app.cookies['_session_id'],
})
assert 'Unsafe' in str(r.headers)
r = self.app.post('/auth/preferences/change_password',
extra_environ=dict(username=str('test-admin')),
params={
'oldpw': 'foo',
'pw': '3j84rhoirwnoiwrnoiw',
'pw2': '3j84rhoirwnoiwrnoiw',
'_session_id': self.app.cookies['_session_id'],
})
assert 'Unsafe' not in str(r.headers)
# Confirm password was changed.
user = M.User.by_username('test-admin')
assert_not_equal(old_pass, user.get_pref('password'))
@td.with_user_project('test-admin')
def test_prefs(self):
r = self.app.get('/auth/preferences/',
extra_environ=dict(username=str('test-admin')))
# check preconditions of test data
assert '<EMAIL>' not in r
assert '<EMAIL>' in r
assert_equal(M.User.query.get(username='test-admin').get_pref('email_address'),
'<EMAIL>')
# add <EMAIL>
with td.audits('New email address: <EMAIL>', user=True):
r = self.app.post('/auth/preferences/update_emails',
extra_environ=dict(username=str('test-admin')),
params={
'new_addr.addr': '<EMAIL>',
'new_addr.claim': 'Claim Address',
'primary_addr': '<EMAIL>',
'password': '<PASSWORD>',
'preferences.email_format': 'plain',
'_session_id': self.app.cookies['_session_id'],
})
r = self.app.get('/auth/preferences/')
assert '<EMAIL>' in r
user = M.User.query.get(username='test-admin')
assert_equal(user.get_pref('email_address'), '<EMAIL>')
# remove <EMAIL>
with td.audits('Email address deleted: <EMAIL>', user=True):
r = self.app.post('/auth/preferences/update_emails',
extra_environ=dict(username=str('test-admin')),
params={
'addr-1.ord': '1',
'addr-1.delete': 'on',
'addr-2.ord': '2',
'new_addr.addr': '',
'primary_addr': '<EMAIL>',
'password': '<PASSWORD>',
'preferences.email_format': 'plain',
'_session_id': self.app.cookies['_session_id'],
})
r = self.app.get('/auth/preferences/')
assert '<EMAIL>' not in r
# preferred address has not changed if email is not verified
user = M.User.query.get(username='test-admin')
assert_equal(user.get_pref('email_address'), None)
with td.audits('Display Name changed Test Admin => Admin', user=True):
r = self.app.post('/auth/preferences/update',
params={'preferences.display_name': 'Admin',
'_session_id': self.app.cookies['_session_id'],
},
extra_environ=dict(username=str('test-admin')))
@td.with_user_project('test-admin')
def test_email_prefs_change_requires_password(self):
self.app.get('/').follow() # establish session
# Claim new email
new_email_params = {
'new_addr.addr': '<EMAIL>',
'new_addr.claim': 'Claim Address',
'primary_addr': '<EMAIL>',
'_session_id': self.app.cookies['_session_id'],
}
r = self.app.post('/auth/preferences/update_emails',
params=new_email_params,
extra_environ=dict(username=str('test-admin')))
assert_in('You must provide your current password to claim new email', self.webflash(r))
assert_not_in('<EMAIL>', r.follow())
new_email_params['password'] = '<PASSWORD>'
r = self.app.post('/auth/preferences/update_emails',
params=new_email_params,
extra_environ=dict(username=str('test-admin')))
assert_in('You must provide your current password to claim new email', self.webflash(r))
assert_not_in('<EMAIL>', r.follow())
new_email_params['password'] = '<PASSWORD>' # valid password
r = self.app.post('/auth/preferences/update_emails',
params=new_email_params,
extra_environ=dict(username=str('test-admin')))
assert_not_in('You must provide your current password to claim new email', self.webflash(r))
assert_in('<EMAIL>', r.follow())
# Change primary address
change_primary_params = {
'new_addr.addr': '',
'primary_addr': '<EMAIL>',
'_session_id': self.app.cookies['_session_id'],
}
r = self.app.post('/auth/preferences/update_emails',
params=change_primary_params,
extra_environ=dict(username=str('test-admin')))
assert_in('You must provide your current password to change primary address', self.webflash(r))
assert_equal(M.User.by_username('test-admin').get_pref('email_address'), '<EMAIL>')
change_primary_params['password'] = '<PASSWORD>'
r = self.app.post('/auth/preferences/update_emails',
params=change_primary_params,
extra_environ=dict(username=str('test-admin')))
assert_in('You must provide your current password to change primary address', self.webflash(r))
assert_equal(M.User.by_username('test-admin').get_pref('email_address'), '<EMAIL>')
change_primary_params['password'] = '<PASSWORD>' # valid password
self.app.get('/auth/preferences/') # let previous 'flash' message cookie get used up
r = self.app.post('/auth/preferences/update_emails',
params=change_primary_params,
extra_environ=dict(username=str('test-admin')))
assert_not_in('You must provide your current password to change primary address', self.webflash(r))
assert_equal(M.User.by_username('test-admin').get_pref('email_address'), '<EMAIL>')
# Remove email
remove_email_params = {
'addr-1.ord': '1',
'addr-2.ord': '2',
'addr-2.delete': 'on',
'new_addr.addr': '',
'primary_addr': '<EMAIL>',
'_session_id': self.app.cookies['_session_id'],
}
r = self.app.post('/auth/preferences/update_emails',
params=remove_email_params,
extra_environ=dict(username=str('test-admin')))
assert_in('You must provide your current password to delete an email', self.webflash(r))
assert_in('<EMAIL>', r.follow())
remove_email_params['password'] = '<PASSWORD>'
r = self.app.post('/auth/preferences/update_emails',
params=remove_email_params,
extra_environ=dict(username=str('test-admin')))
assert_in('You must provide your current password to delete an email', self.webflash(r))
assert_in('<EMAIL>', r.follow())
remove_email_params['password'] = '<PASSWORD>' # vallid password
r = self.app.post('/auth/preferences/update_emails',
params=remove_email_params,
extra_environ=dict(username=str('test-admin')))
assert_not_in('You must provide your current password to delete an email', self.webflash(r))
assert_not_in('<EMAIL>', r.follow())
@td.with_user_project('test-admin')
def test_prefs_subscriptions(self):
r = self.app.get('/auth/subscriptions/',
extra_environ=dict(username=str('test-admin')))
subscriptions = M.Mailbox.query.find(dict(
user_id=c.user._id, is_flash=False)).all()
# make sure page actually lists all the user's subscriptions
assert len(subscriptions) > 0, 'Test user has no subscriptions, cannot verify that they are shown'
for m in subscriptions:
assert str(m._id) in r, "Page doesn't list subscription for Mailbox._id = %s" % m._id
# make sure page lists all tools which user can subscribe
user = M.User.query.get(username='test-admin')
for p in user.my_projects():
for ac in p.app_configs:
if not M.Mailbox.subscribed(project_id=p._id, app_config_id=ac._id):
if ac.tool_name in ('activity', 'admin', 'search', 'userstats', 'profile'):
# these have has_notifications=False
assert str(ac._id) not in r, "Page lists tool %s but it should not" % ac.tool_name
else:
assert str(ac._id) in r, "Page doesn't list tool %s" % ac.tool_name
@td.with_user_project('test-admin')
def test_update_user_notifications(self):
self.app.get('/').follow() # establish session
assert not M.User.query.get(username='test-admin').get_pref('mention_notifications')
self.app.post('/auth/subscriptions/update_user_notifications',
params={'_session_id': self.app.cookies['_session_id'],
})
assert not M.User.query.get(username='test-admin').get_pref('mention_notifications')
self.app.post('/auth/subscriptions/update_user_notifications',
params={'allow_umnotif': 'on',
'_session_id': self.app.cookies['_session_id'],
})
assert M.User.query.get(username='test-admin').get_pref('mention_notifications')
def _find_subscriptions_form(self, r):
form = None
for f in six.itervalues(r.forms):
if f.action == 'update_subscriptions':
form = f
break
assert form is not None, "Can't find subscriptions form"
return form
def _find_subscriptions_field(self, form, subscribed=False):
field_name = None
for k, v in six.iteritems(form.fields):
if subscribed:
check = c and v[0].value == 'on'
else:
check = c and v[0].value != 'on'
if k and k.endswith('.subscribed') and check:
field_name = k.replace('.subscribed', '')
assert field_name, "Can't find unsubscribed tool for user"
return field_name
@td.with_user_project('test-admin')
def test_prefs_subscriptions_subscribe(self):
resp = self.app.get('/auth/subscriptions/',
extra_environ=dict(username=str('test-admin')))
form = self._find_subscriptions_form(resp)
# find not subscribed tool, subscribe and verify
field_name = self._find_subscriptions_field(form, subscribed=False)
t_id = ObjectId(form.fields[field_name + '.tool_id'][0].value)
p_id = ObjectId(form.fields[field_name + '.project_id'][0].value)
subscribed = M.Mailbox.subscribed(project_id=p_id, app_config_id=t_id)
assert not subscribed, "User already subscribed for tool %s" % t_id
form.fields[field_name + '.subscribed'][0].value = 'on'
form.submit()
subscribed = M.Mailbox.subscribed(project_id=p_id, app_config_id=t_id)
assert subscribed, "User is not subscribed for tool %s" % t_id
@td.with_user_project('test-admin')
def test_prefs_subscriptions_unsubscribe(self):
resp = self.app.get('/auth/subscriptions/',
extra_environ=dict(username=str('test-admin')))
form = self._find_subscriptions_form(resp)
field_name = self._find_subscriptions_field(form, subscribed=True)
s_id = ObjectId(form.fields[field_name + '.subscription_id'][0].value)
s = M.Mailbox.query.get(_id=s_id)
assert s, "User has not subscription with Mailbox._id = %s" % s_id
form.fields[field_name + '.subscribed'][0].value = None
form.submit()
s = M.Mailbox.query.get(_id=s_id)
assert not s, "User still has subscription with Mailbox._id %s" % s_id
def test_format_email(self):
self.app.get('/').follow() # establish session
self.app.post('/auth/subscriptions/update_subscriptions',
params={'email_format': 'plain', 'subscriptions': '',
'_session_id': self.app.cookies['_session_id']})
r = self.app.get('/auth/subscriptions/')
assert '<option selected value="plain">Plain Text</option>' in r
self.app.post('/auth/subscriptions/update_subscriptions',
params={'email_format': 'both', 'subscriptions': '',
'_session_id': self.app.cookies['_session_id']})
r = self.app.get('/auth/subscriptions/')
assert '<option selected value="both">HTML</option>' in r
def test_create_account(self):
r = self.app.get('/auth/create_account')
assert 'Create an Account' in r
r = self.app.post('/auth/save_new',
params=dict(username='AAA', pw='123',
_session_id=self.app.cookies['_session_id']))
assert_in('Enter a value 6 characters long or more', r)
assert_in('Usernames must include only small letters, numbers, '
'and dashes. They must also start with a letter and be '
'at least 3 characters long.', r)
r = self.app.post(
'/auth/save_new',
params=dict(
username='aaa',
pw='12345678',
pw2='12345678',
display_name='Test Me',
_session_id=self.app.cookies['_session_id'],
))
r = r.follow().follow()
assert 'User "aaa" registered' in unentity(r.text)
r = self.app.post(
'/auth/save_new',
params=dict(
username='aaa',
pw='12345678',
pw2='12345678',
display_name='Test Me',
_session_id=self.app.cookies['_session_id'],
))
assert 'That username is already taken. Please choose another.' in r
r = self.app.get('/auth/logout')
r = self.app.post(
'/auth/do_login',
params=dict(username='aaa', password='<PASSWORD>',
_session_id=self.app.cookies['_session_id']), antispam=True,
status=302)
def test_create_account_require_email(self):
self.app.get('/').follow() # establish session
with h.push_config(config, **{'auth.require_email_addr': 'false'}):
self.app.post(
'/auth/save_new',
params=dict(
username='aaa',
pw='12345678',
pw2='12345678',
display_name='<NAME>',
email='<EMAIL>',
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='aaa')
assert not user.pending
assert_equal(M.Project.query.find({'name': 'u/aaa'}).count(), 1)
with h.push_config(config, **{'auth.require_email_addr': 'true'}):
self.app.post(
'/auth/save_new',
params=dict(
username='bbb',
pw='12345678',
pw2='12345678',
display_name='<NAME>',
email='<EMAIL>',
_session_id=self.app.cookies['_session_id']
))
user = M.User.query.get(username='bbb')
assert user.pending
assert_equal(M.Project.query.find({'name': 'u/bbb'}).count(), 0)
def test_verify_email(self):
with h.push_config(config, **{'auth.require_email_addr': 'true'}):
self.app.get('/').follow() # establish session
r = self.app.post(
'/auth/save_new',
params=dict(
username='aaa',
pw='12345678',
pw2='12345678',
display_name='<NAME>',
email='<EMAIL>',
_session_id=self.app.cookies['_session_id']
))
r = r.follow()
user = M.User.query.get(username='aaa')
em = M.EmailAddress.get(email='<EMAIL>')
assert user._id == em.claimed_by_user_id
r = self.app.get('/auth/verify_addr', params=dict(a=em.nonce))
user = M.User.query.get(username='aaa')
em = M.EmailAddress.get(email='<EMAIL>')
assert not user.pending
assert em.confirmed
assert user.get_pref('email_address')
assert_equal(M.Project.query.find({'name': 'u/aaa'}).count(), 1)
def test_create_account_disabled_header_link(self):
with h.push_config(config, **{'auth.allow_user_registration': 'false'}):
r = self.app.get('/')
assert 'Register' not in r
def test_create_account_disabled_form_gone(self):
with h.push_config(config, **{'auth.allow_user_registration': 'false'}):
r = self.app.get('/auth/create_account', status=404)
assert 'Create an Account' not in r
def test_create_account_disabled_submit_fails(self):
with h.push_config(config, **{'auth.allow_user_registration': 'false'}):
self.app.get('/').follow() # establish session
self.app.post('/auth/save_new',
params=dict(
username='aaa',
pw='12345678',
pw2='12345678',
display_name='<NAME>',
_session_id=self.app.cookies['_session_id']
),
status=404)
def test_one_project_role(self):
"""Make sure when a user goes to a new project only one project role is created.
There was an issue with extra project roles getting created if a user went directly to
an admin page."""
p_nbhd = M.Neighborhood.query.get(name='Projects')
p = M.Project.query.get(shortname='test', neighborhood_id=p_nbhd._id)
self.app.get('/').follow() # establish session
self.app.post('/auth/save_new', params=dict(
username='aaa',
pw='12345678',
pw2='12345678',
display_name='<NAME>',
email='<EMAIL>',
_session_id=self.app.cookies['_session_id'],
)).follow()
user = M.User.query.get(username='aaa')
user.pending = False
session(user).flush(user)
assert M.ProjectRole.query.find(
dict(user_id=user._id, project_id=p._id)).count() == 0
self.app.get('/p/test/admin/permissions',
extra_environ=dict(username=str('aaa')), status=403)
assert M.ProjectRole.query.find(
dict(user_id=user._id, project_id=p._id)).count() <= 1
def test_default_lookup(self):
# Make sure that default _lookup() throws 404
self.app.get('/auth/foobar', status=404)
def test_disabled_user(self):
user = M.User.query.get(username='test-admin')
sess = session(user)
assert not user.disabled
r = self.app.get('/p/test/admin/',
extra_environ={'username': str('test-admin')})
assert_equal(r.status_int, 200, 'Redirect to %s' % r.location)
user.disabled = True
sess.save(user)
sess.flush()
user = M.User.query.get(username='test-admin')
assert user.disabled
r = self.app.get('/p/test/admin/',
extra_environ={'username': str('test-admin')})
assert_equal(r.status_int, 302)
assert_equal(r.location, 'http://localhost/auth/?return_to=%2Fp%2Ftest%2Fadmin%2F')
def test_no_open_return_to(self):
r = self.app.get('/auth/logout').follow().follow()
r = self.app.post('/auth/do_login', params=dict(
username='test-user', password='<PASSWORD>',
return_to='/foo',
_session_id=self.app.cookies['_session_id']),
antispam=True
)
assert_equal(r.location, 'http://localhost/foo')
r = self.app.get('/auth/logout')
r = self.app.post('/auth/do_login', antispam=True, params=dict(
username='test-user', password='<PASSWORD>',
return_to='http://localhost/foo',
_session_id=self.app.cookies['_session_id']))
assert_equal(r.location, 'http://localhost/foo')
r = self.app.get('/auth/logout')
r = self.app.post('/auth/do_login', antispam=True, params=dict(
username='test-user', password='<PASSWORD>',
return_to='http://example.com/foo',
_session_id=self.app.cookies['_session_id'])).follow()
assert_equal(r.location, 'http://localhost/dashboard')
r = self.app.get('/auth/logout')
r = self.app.post('/auth/do_login', antispam=True, params=dict(
username='test-user', password='<PASSWORD>',
return_to='//example.com/foo',
_session_id=self.app.cookies['_session_id'])).follow()
assert_equal(r.location, 'http://localhost/dashboard')
def test_no_injected_headers_in_return_to(self):
r = self.app.get('/auth/logout').follow().follow()
r = self.app.post('/auth/do_login', params=dict(
username='test-user', password='<PASSWORD>',
return_to='/foo\nContent-Length: 777',
# WebTest actually will raise an error if there's an invalid header (webob itself does not)
_session_id=self.app.cookies['_session_id']),
antispam=True
)
assert_equal(r.location, 'http://localhost/')
assert_not_equal(r.content_length, 777)
class TestPreferences(TestController):
@td.with_user_project('test-admin')
def test_personal_data(self):
from pytz import country_names
setsex, setbirthdate, setcountry, setcity, settimezone = \
('Male', '19/08/1988', 'IT', 'Milan', 'Europe/Rome')
self.app.get('/auth/user_info/')
# Check if personal data is properly set
r = self.app.post('/auth/user_info/change_personal_data',
params=dict(
sex=setsex,
birthdate=setbirthdate,
country=setcountry,
city=setcity,
timezone=settimezone,
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
sex = user.sex
assert sex == setsex
birthdate = user.birthdate.strftime('%d/%m/%Y')
assert birthdate == setbirthdate
country = user.localization.country
assert country_names.get(setcountry) == country
city = user.localization.city
assert city == setcity
timezone = user.timezone
assert timezone == settimezone
# Check if setting a wrong date everything works correctly
r = self.app.post('/auth/user_info/change_personal_data',
params=dict(birthdate='30/02/1998', _session_id=self.app.cookies['_session_id']))
assert 'Please enter a valid date' in r.text
user = M.User.query.get(username='test-admin')
sex = user.sex
assert sex == setsex
birthdate = user.birthdate.strftime('%d/%m/%Y')
assert birthdate == setbirthdate
country = user.localization.country
assert country_names.get(setcountry) == country
city = user.localization.city
assert city == setcity
timezone = user.timezone
assert timezone == settimezone
# Check deleting birthdate
r = self.app.post('/auth/user_info/change_personal_data',
params=dict(
sex=setsex,
birthdate='',
country=setcountry,
city=setcity,
timezone=settimezone,
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert user.birthdate is None
@td.with_user_project('test-admin')
def test_contacts(self):
# Add skype account
testvalue = 'testaccount'
self.app.get('/auth/user_info/contacts/')
self.app.post('/auth/user_info/contacts/skype_account',
params=dict(skypeaccount=testvalue, _session_id=self.app.cookies['_session_id']))
user = M.User.query.get(username='test-admin')
assert user.skypeaccount == testvalue
# Add social network account
socialnetwork = 'Facebook'
accounturl = 'http://www.facebook.com/test'
self.app.post('/auth/user_info/contacts/add_social_network',
params=dict(socialnetwork=socialnetwork,
accounturl=accounturl,
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert len(user.socialnetworks) == 1
assert_equal(user.socialnetworks[0].socialnetwork, socialnetwork)
assert_equal(user.socialnetworks[0].accounturl, accounturl)
# Add second social network account
socialnetwork2 = 'Twitter'
accounturl2 = 'http://twitter.com/test'
self.app.post('/auth/user_info/contacts/add_social_network',
params=dict(socialnetwork=socialnetwork2,
accounturl='@test',
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert len(user.socialnetworks) == 2
assert_in({'socialnetwork': socialnetwork, 'accounturl': accounturl}, user.socialnetworks)
assert_in({'socialnetwork': socialnetwork2, 'accounturl': accounturl2}, user.socialnetworks)
# Remove first social network account
self.app.post('/auth/user_info/contacts/remove_social_network',
params=dict(socialnetwork=socialnetwork,
account=accounturl,
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert len(user.socialnetworks) == 1
assert_in({'socialnetwork': socialnetwork2, 'accounturl': accounturl2}, user.socialnetworks)
# Add empty social network account
self.app.post('/auth/user_info/contacts/add_social_network',
params=dict(accounturl=accounturl, socialnetwork='',
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert len(user.socialnetworks) == 1
assert_in({'socialnetwork': socialnetwork2, 'accounturl': accounturl2}, user.socialnetworks)
# Add invalid social network account
self.app.post('/auth/user_info/contacts/add_social_network',
params=dict(accounturl=accounturl, socialnetwork='invalid',
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert len(user.socialnetworks) == 1
assert_in({'socialnetwork': socialnetwork2, 'accounturl': accounturl2}, user.socialnetworks)
# Add telephone number
telnumber = '+3902123456'
self.app.post('/auth/user_info/contacts/add_telnumber',
params=dict(newnumber=telnumber,
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert (len(user.telnumbers) == 1 and (user.telnumbers[0] == telnumber))
# Add second telephone number
telnumber2 = '+3902654321'
self.app.post('/auth/user_info/contacts/add_telnumber',
params=dict(newnumber=telnumber2,
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert (len(user.telnumbers) == 2 and telnumber in user.telnumbers and telnumber2 in user.telnumbers)
# Remove first telephone number
self.app.post('/auth/user_info/contacts/remove_telnumber',
params=dict(oldvalue=telnumber,
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert (len(user.telnumbers) == 1 and telnumber2 in user.telnumbers)
# Add website
website = 'http://www.testurl.com'
self.app.post('/auth/user_info/contacts/add_webpage',
params=dict(newwebsite=website,
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert (len(user.webpages) == 1 and (website in user.webpages))
# Add second website
website2 = 'http://www.testurl2.com'
self.app.post('/auth/user_info/contacts/add_webpage',
params=dict(newwebsite=website2,
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert (len(user.webpages) == 2 and website in user.webpages and website2 in user.webpages)
# Remove first website
self.app.post('/auth/user_info/contacts/remove_webpage',
params=dict(oldvalue=website,
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert (len(user.webpages) == 1 and website2 in user.webpages)
@td.with_user_project('test-admin')
def test_availability(self):
# Add availability timeslot
weekday = 'Monday'
starttime = time(9, 0, 0)
endtime = time(12, 0, 0)
self.app.get('/auth/user_info/availability/')
r = self.app.post('/auth/user_info/availability/add_timeslot',
params=dict(
weekday=weekday,
starttime=starttime.strftime('%H:%M'),
endtime=endtime.strftime('%H:%M'),
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
timeslot1dict = dict(
week_day=weekday, start_time=starttime, end_time=endtime)
assert len(
user.availability) == 1 and timeslot1dict in user.get_availability_timeslots()
weekday2 = 'Tuesday'
starttime2 = time(14, 0, 0)
endtime2 = time(16, 0, 0)
# Add second availability timeslot
r = self.app.post('/auth/user_info/availability/add_timeslot',
params=dict(
weekday=weekday2,
starttime=starttime2.strftime('%H:%M'),
endtime=endtime2.strftime('%H:%M'),
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
timeslot2dict = dict(week_day=weekday2,
start_time=starttime2, end_time=endtime2)
assert len(user.availability) == 2
assert_in(timeslot1dict, user.get_availability_timeslots())
assert_in(timeslot2dict, user.get_availability_timeslots())
# Remove availability timeslot
r = self.app.post('/auth/user_info/availability/remove_timeslot',
params=dict(
weekday=weekday,
starttime=starttime.strftime('%H:%M'),
endtime=endtime.strftime('%H:%M'),
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert len(user.availability) == 1 and timeslot2dict in user.get_availability_timeslots()
# Add invalid availability timeslot
r = self.app.post('/auth/user_info/availability/add_timeslot',
params=dict(
weekday=weekday2,
starttime=endtime2.strftime('%H:%M'),
endtime=starttime2.strftime('%H:%M'),
_session_id=self.app.cookies['_session_id'],
))
assert 'Invalid period:' in str(r)
user = M.User.query.get(username='test-admin')
timeslot2dict = dict(week_day=weekday2,
start_time=starttime2, end_time=endtime2)
assert len(user.availability) == 1 and timeslot2dict in user.get_availability_timeslots()
@td.with_user_project('test-admin')
def test_inactivity(self):
# Add inactivity period
now = datetime.utcnow().date()
now = datetime(now.year, now.month, now.day)
startdate = now + timedelta(days=1)
enddate = now + timedelta(days=7)
self.app.get('/auth/user_info/availability/')
r = self.app.post('/auth/user_info/availability/add_inactive_period',
params=dict(
startdate=startdate.strftime('%d/%m/%Y'),
enddate=enddate.strftime('%d/%m/%Y'),
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
period1dict = dict(start_date=startdate, end_date=enddate)
assert len(user.inactiveperiod) == 1 and period1dict in user.get_inactive_periods()
# Add second inactivity period
startdate2 = now + timedelta(days=24)
enddate2 = now + timedelta(days=28)
r = self.app.post('/auth/user_info/availability/add_inactive_period',
params=dict(
startdate=startdate2.strftime('%d/%m/%Y'),
enddate=enddate2.strftime('%d/%m/%Y'),
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
period2dict = dict(start_date=startdate2, end_date=enddate2)
assert len(user.inactiveperiod) == 2
assert_in(period1dict, user.get_inactive_periods())
assert_in(period2dict, user.get_inactive_periods())
# Remove first inactivity period
r = self.app.post(
'/auth/user_info/availability/remove_inactive_period',
params=dict(
startdate=startdate.strftime('%d/%m/%Y'),
enddate=enddate.strftime('%d/%m/%Y'),
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert len(user.inactiveperiod) == 1 and period2dict in user.get_inactive_periods()
# Add invalid inactivity period
r = self.app.post('/auth/user_info/availability/add_inactive_period',
params=dict(
startdate='NOT/A/DATE',
enddate=enddate2.strftime('%d/%m/%Y'),
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert 'Please enter a valid date' in str(r)
assert len(user.inactiveperiod) == 1 and period2dict in user.get_inactive_periods()
@td.with_user_project('test-admin')
def test_skills(self):
setup_trove_categories()
# Add a skill
skill_cat = M.TroveCategory.query.get(show_as_skill=True)
level = 'low'
comment = 'test comment'
self.app.get('/auth/user_info/skills/')
self.app.post('/auth/user_info/skills/save_skill',
params=dict(
level=level,
comment=comment,
selected_skill=str(skill_cat.trove_cat_id),
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
skilldict = dict(category_id=skill_cat._id,
comment=comment, level=level)
assert len(user.skills) == 1 and skilldict in user.skills
# Add again the same skill
level = 'medium'
comment = 'test comment 2'
self.app.get('/auth/user_info/skills/')
self.app.post('/auth/user_info/skills/save_skill',
params=dict(
level=level,
comment=comment,
selected_skill=str(skill_cat.trove_cat_id),
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
skilldict = dict(category_id=skill_cat._id,
comment=comment, level=level)
assert len(user.skills) == 1 and skilldict in user.skills
# Add an invalid skill
level2 = 'not a level'
comment2 = 'test comment 2'
self.app.post('/auth/user_info/skills/save_skill',
params=dict(
level=level2,
comment=comment2,
selected_skill=str(skill_cat.trove_cat_id),
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
# Check that everything is as it was before
assert len(user.skills) == 1 and skilldict in user.skills
# Remove a skill
self.app.get('/auth/user_info/skills/')
self.app.post('/auth/user_info/skills/remove_skill',
params=dict(
categoryid=str(skill_cat.trove_cat_id),
_session_id=self.app.cookies['_session_id'],
))
user = M.User.query.get(username='test-admin')
assert len(user.skills) == 0
@td.with_user_project('test-admin')
def test_user_message(self):
self.app.get('/').follow() # establish session
assert not M.User.query.get(username='test-admin').get_pref('disable_user_messages')
self.app.post('/auth/preferences/user_message',
params={'_session_id': self.app.cookies['_session_id'],
})
assert M.User.query.get(username='test-admin').get_pref('disable_user_messages')
self.app.post('/auth/preferences/user_message',
params={'allow_user_messages': 'on',
'_session_id': self.app.cookies['_session_id'],
})
assert not M.User.query.get(username='test-admin').get_pref('disable_user_messages')
@td.with_user_project('test-admin')
def test_additional_page(self):
class MyPP(plugin.UserPreferencesProvider):
def not_page(self):
return 'not page'
@expose()
def new_page(self):
return 'new page'
with mock.patch.object(plugin.UserPreferencesProvider, 'get') as upp_get:
upp_get.return_value = MyPP()
r = self.app.get('/auth/new_page')
assert_equal(r.text, 'new page')
self.app.get('/auth/not_page', status=404)
class TestPasswordReset(TestController):
test_primary_email = '<EMAIL>'
def setUp(self):
super(TestPasswordReset, self).setUp()
# so test-admin isn't automatically logged in for all requests
self.app.extra_environ = {'disable_auth_magic': str('True')}
@patch('allura.tasks.mail_tasks.sendmail')
@patch('allura.lib.helpers.gen_message_id')
def test_email_unconfirmed(self, gen_message_id, sendmail):
user = M.User.query.get(username='test-admin')
email = M.EmailAddress.find(
{'claimed_by_user_id': user._id}).first()
email.confirmed = False
ThreadLocalORMSession.flush_all()
self.app.get('/').follow() # establish session
self.app.post('/auth/password_recovery_hash', {'email': email.email,
'_session_id': self.app.cookies['_session_id'],
})
hash = user.get_tool_data('AuthPasswordReset', 'hash')
assert hash is None
@patch('allura.tasks.mail_tasks.sendmail')
@patch('allura.lib.helpers.gen_message_id')
def test_user_disabled(self, gen_message_id, sendmail):
user = M.User.query.get(username='test-admin')
email = M.EmailAddress.find(
{'claimed_by_user_id': user._id}).first()
user.disabled = True
ThreadLocalORMSession.flush_all()
self.app.get('/').follow() # establish session
self.app.post('/auth/password_recovery_hash', {'email': email.email,
'_session_id': self.app.cookies['_session_id'],
})
hash = user.get_tool_data('AuthPasswordReset', 'hash')
assert hash is None
@patch('allura.tasks.mail_tasks.sendsimplemail')
@patch('allura.lib.helpers.gen_message_id')
def test_only_primary_email_reset_allowed(self, gen_message_id, sendmail):
self.app.get('/').follow() # establish session
user = M.User.query.get(username='test-admin')
user.claim_address(self.test_primary_email)
user.set_pref('email_address', self.test_primary_email)
email = M.EmailAddress.find({'email': self.test_primary_email}).first()
email.confirmed = True
ThreadLocalORMSession.flush_all()
with h.push_config(config, **{'auth.allow_non_primary_email_password_reset': 'false'}):
self.app.post('/auth/password_recovery_hash', {'email': self.test_primary_email,
'_session_id': self.app.cookies['_session_id'],
})
hash = user.get_tool_data('AuthPasswordReset', 'hash')
assert hash is not None
args, kwargs = sendmail.post.call_args
assert_equal(kwargs['toaddr'], self.test_primary_email)
@patch('allura.tasks.mail_tasks.sendsimplemail')
@patch('allura.lib.helpers.gen_message_id')
def test_non_primary_email_reset_allowed(self, gen_message_id, sendmail):
self.app.get('/').follow() # establish session
user = M.User.query.get(username='test-admin')
email1 = M.EmailAddress.find({'claimed_by_user_id': user._id}).first()
user.claim_address(self.test_primary_email)
user.set_pref('email_address', self.test_primary_email)
email = M.EmailAddress.find({'email': self.test_primary_email}).first()
email.confirmed = True
ThreadLocalORMSession.flush_all()
with h.push_config(config, **{'auth.allow_non_primary_email_password_reset': 'true'}):
self.app.post('/auth/password_recovery_hash', {'email': email1.email,
'_session_id': self.app.cookies['_session_id'],
})
hash = user.get_tool_data('AuthPasswordReset', 'hash')
assert hash is not None
args, kwargs = sendmail.post.call_args
assert_equal(kwargs['toaddr'], email1.email)
@patch('allura.tasks.mail_tasks.sendsimplemail')
@patch('allura.lib.helpers.gen_message_id')
def test_password_reset(self, gen_message_id, sendmail):
self.app.get('/').follow() # establish session
user = M.User.query.get(username='test-<PASSWORD>')
email = M.EmailAddress.find({'claimed_by_user_id': user._id}).first()
email.confirmed = True
ThreadLocalORMSession.flush_all()
old_pw_hash = user.password
# request a reset
with td.audits('Password recovery link sent to: ' + email.email, user=True):
r = self.app.post('/auth/password_recovery_hash', {'email': email.email,
'_session_id': self.app.cookies['_session_id'],
})
# confirm some fields
hash = user.get_tool_data('AuthPasswordReset', 'hash')
hash_expiry = user.get_tool_data('AuthPasswordReset', 'hash_expiry')
assert hash is not None
assert hash_expiry is not None
# confirm email sent
text = '''Your username is test-admin
To update your password on %s, please visit the following URL:
%s/auth/forgotten_password/%s''' % (config['site_name'], config['base_url'], hash)
sendmail.post.assert_called_once_with(
sender='noreply@localhost',
toaddr=email.email,
fromaddr='"{}" <{}>'.format(config['site_name'], config['forgemail.return_path']),
reply_to=config['forgemail.return_path'],
subject='Allura Password recovery',
message_id=gen_message_id(),
text=text)
# load reset form and fill it out
r = self.app.get('/auth/forgotten_password/%s' % hash)
assert_in('Enter a new password for: <PASSWORD>', r)
assert_in('New Password:', r)
assert_in('New Password (again):', r)
form = r.forms[0]
form['pw'] = form['pw2'] = new_password = '<PASSWORD>'
with td.audits('Password changed \(through recovery process\)', user=True):
# escape parentheses, so they would not be treated as regex group
r = form.submit()
# confirm password changed and works
user = M.User.query.get(username='test-admin')
assert_not_equal(old_pw_hash, user.password)
provider = plugin.LocalAuthenticationProvider(None)
assert_true(provider._validate_password(user, new_password))
# confirm reset fields cleared
user = M.User.query.get(username='test-admin')
hash = user.get_tool_data('AuthPasswordReset', 'hash')
hash_expiry = user.get_tool_data('AuthPasswordReset', 'hash_expiry')
assert_equal(hash, '')
assert_equal(hash_expiry, '')
# confirm can log in now in same session
r = r.follow()
assert 'Log Out' not in r, r
form = r.forms[0]
encoded = self.app.antispam_field_names(r.form)
form[encoded['username']] = 'test-admin'
form[encoded['password']] = <PASSWORD>
r = form.submit(status=302)
r = r.follow().follow()
assert 'Log Out' in r, r
@patch('allura.tasks.mail_tasks.sendsimplemail')
@patch('allura.lib.helpers.gen_message_id')
def test_hash_expired(self, gen_message_id, sendmail):
user = M.User.query.get(username='test-admin')
email = M.EmailAddress.find(
{'claimed_by_user_id': user._id}).first()
email.confirmed = True
ThreadLocalORMSession.flush_all()
self.app.get('/').follow() # establish session
r = self.app.post('/auth/password_recovery_hash', {'email': email.email,
'_session_id': self.app.cookies['_session_id'],
})
user = M.User.by_username('test-admin')
hash = user.get_tool_data('AuthPasswordReset', 'hash')
user.set_tool_data('AuthPasswordReset',
hash_expiry=datetime(2000, 10, 10))
r = self.app.get('/auth/forgotten_password/%s' % hash.encode('utf-8'))
assert_in('Unable to process reset, please try again', r.follow().text)
r = self.app.post('/auth/set_new_password/%s' %
hash.encode('utf-8'), {'pw': '154321', 'pw2': '154321',
'_session_id': self.app.cookies['_session_id'],
})
assert_in('Unable to process reset, please try again', r.follow().text)
def test_hash_invalid(self):
r = self.app.get('/auth/forgotten_password/123412341234', status=302)
assert_in('Unable to process reset, please try again', r.follow().text)
@patch('allura.lib.plugin.AuthenticationProvider')
def test_provider_disabled(self, AP):
user = M.User.query.get(username='test-admin')
ap = AP.get()
ap.forgotten_password_process = False
ap.authenticate_request()._id = user._id
ap.by_username().username = user.username
self.app.get('/auth/forgotten_password', status=404)
self.app.get('/').follow() # establish session
self.app.post('/auth/set_new_password',
{'pw': 'foo', 'pw2': 'foo', '_session_id': self.app.cookies['_session_id']},
status=404)
self.app.post('/auth/password_recovery_hash',
{'email': 'foo', '_session_id': self.app.cookies['_session_id']},
status=404)
@patch('allura.lib.plugin.AuthenticationProvider.hibp_password_check_enabled', Mock(return_value=True))
@patch('allura.tasks.mail_tasks.sendsimplemail')
@patch('allura.lib.helpers.gen_message_id')
def test_pwd_reset_hibp_check(self, gen_message_id, sendmail):
self.app.get('/').follow() # establish session
user = M.User.query.get(username='test-admin')
email = M.EmailAddress.find({'claimed_by_user_id': user._id}).first()
email.confirmed = True
ThreadLocalORMSession.flush_all()
# request a reset
r = self.app.post('/auth/password_recovery_hash', {'email': email.email,
'_session_id': self.app.cookies['_session_id'],
})
hash = user.get_tool_data('AuthPasswordReset', 'hash')
# load reset form and fill it out with weak password
r = self.app.get('/auth/forgotten_password/%s' % hash)
form = r.forms[0]
form['pw'] = form['pw2'] = new_password = 'password'
r = form.submit()
assert 'Unsafe' in str(r.headers)
# fill it out again, with a stronger password
r = r.follow()
form = r.forms[0]
form['pw'] = form['pw2'] = new_password = '<PASSWORD>' # something unlikely to trip at hibp
r = form.submit()
assert 'Unsafe' not in str(r.headers)
# confirm password changed and works
user = M.User.query.get(username='test-admin')
provider = plugin.LocalAuthenticationProvider(None)
assert_true(provider._validate_password(user, <PASSWORD>))
# confirm can log in now in same session
r = r.follow()
assert 'Log Out' not in r, r
form = r.forms[0]
encoded = self.app.antispam_field_names(r.form)
form[encoded['username']] = 'test-admin'
form[encoded['password']] = <PASSWORD>
r = form.submit(status=302)
r = r.follow().follow()
assert 'Log Out' in r, r
class TestOAuth(TestController):
def test_register_deregister_app(self):
# register
r = self.app.get('/auth/oauth/')
r = self.app.post('/auth/oauth/register',
params={'application_name': 'oautstapp', 'application_description': 'Oauth rulez',
'_session_id': self.app.cookies['_session_id'],
}).follow()
assert 'oautstapp' in r
# deregister
assert_equal(r.forms[0].action, 'deregister')
r.forms[0].submit()
r = self.app.get('/auth/oauth/')
assert 'oautstapp' not in r
def test_generate_revoke_access_token(self):
# generate
self.app.get('/').follow() # establish session
r = self.app.post('/auth/oauth/register',
params={'application_name': 'oautstapp', 'application_description': 'Oauth rulez',
'_session_id': self.app.cookies['_session_id'],
}, status=302)
r = self.app.get('/auth/oauth/')
assert_equal(r.forms[1].action, 'generate_access_token')
r = r.forms[1].submit(extra_environ={'username': str('test-user')}) # not the right user
assert_in("Invalid app ID", self.webflash(r)) # gets an error
r = self.app.get('/auth/oauth/') # do it again
r = r.forms[1].submit() # as correct user
assert_equal('', self.webflash(r))
r = self.app.get('/auth/oauth/')
assert 'Bearer Token:' in r
assert_not_equal(
M.OAuthAccessToken.for_user(M.User.by_username('test-admin')), [])
# revoke
assert_equal(r.forms[0].action, 'revoke_access_token')
r.forms[0].submit()
r = self.app.get('/auth/oauth/')
assert_not_equal(r.forms[0].action, 'revoke_access_token')
assert_equal(
M.OAuthAccessToken.for_user(M.User.by_username('test-admin')), [])
def test_interactive(self):
with mock.patch('allura.controllers.rest.oauth.Server') as Server, \
mock.patch('allura.controllers.rest.oauth.Request') as Request: # these are the oauth2 libs
user = M.User.by_username('test-admin')
M.OAuthConsumerToken(
api_key='api_key',
user_id=user._id,
description='ctok_desc',
)
ThreadLocalORMSession.flush_all()
Request.from_request.return_value = {
'oauth_consumer_key': 'api_key',
'oauth_callback': 'http://my.domain.com/callback',
}
r = self.app.post('/rest/oauth/request_token', params={})
rtok = parse_qs(r.text)['oauth_token'][0]
r = self.app.post('/rest/oauth/authorize',
params={'oauth_token': rtok})
r = r.forms[0].submit('yes')
assert r.location.startswith('http://my.domain.com/callback')
pin = parse_qs(urlparse(r.location).query)['oauth_verifier'][0]
Request.from_request.return_value = {
'oauth_consumer_key': 'api_key',
'oauth_token': rtok,
'oauth_verifier': pin,
}
r = self.app.get('/rest/oauth/access_token')
atok = parse_qs(r.text)
assert_equal(len(atok['oauth_token']), 1)
assert_equal(len(atok['oauth_token_secret']), 1)
# now use the tokens & secrets to make a full OAuth request:
oauth_secret = atok['oauth_token_secret'][0]
oauth_token = atok['oauth_token'][0]
consumer = oauth2.Consumer('api_key', oauth_secret)
M.OAuthConsumerToken.consumer = consumer
access_token = oauth2.Token(oauth_token, oauth_secret)
oauth_client = oauth2.Client(consumer, access_token)
# use the oauth2 lib, but intercept the request and then send it to self.app.get
with mock.patch('oauth2.httplib2.Http.request', name='hl2req') as oa2_req:
oauth_client.request('http://localhost/rest/p/test/', 'GET')
oa2url = oa2_req.call_args[0][1]
oa2url = oa2url.replace('http://localhost', '')
print(oa2url)
oa2kwargs = oa2_req.call_args[1]
self.app.get(oa2url, headers=oa2kwargs['headers'], status=200)
self.app.get(oa2url.replace('oauth_signature=', 'removed='), headers=oa2kwargs['headers'], status=401)
@mock.patch('allura.controllers.rest.oauth.Server')
@mock.patch('allura.controllers.rest.oauth.Request')
def test_request_token_valid(self, Request, Server):
M.OAuthConsumerToken.consumer = mock.Mock()
user = M.User.by_username('test-user')
consumer_token = M.OAuthConsumerToken(
api_key='api_key',
user_id=user._id,
)
ThreadLocalORMSession.flush_all()
req = Request.from_request.return_value = {'oauth_consumer_key': 'api_key'}
r = self.app.post('/rest/oauth/request_token', params={'key': 'value'})
# dict-ify webob.EnvironHeaders
call = Request.from_request.call_args_list[0]
call[1]['headers'] = dict(call[1]['headers'])
# then check equality
assert_equal(Request.from_request.call_args_list, [
mock.call('POST', 'http://localhost/rest/oauth/request_token',
headers={'Host': 'localhost:80',
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': '9'},
parameters={'key': 'value'},
query_string='')
])
Server().verify_request.assert_called_once_with(req, consumer_token.consumer, None)
request_token = M.OAuthRequestToken.query.get(consumer_token_id=consumer_token._id)
assert_is_not_none(request_token)
assert_equal(r.text, request_token.to_string())
@mock.patch('allura.controllers.rest.oauth.Server')
@mock.patch('allura.controllers.rest.oauth.Request')
def test_request_token_no_consumer_token(self, Request, Server):
Request.from_request.return_value = {
'oauth_consumer_key': 'api_key'}
self.app.post('/rest/oauth/request_token',
params={'key': 'value'}, status=401)
@mock.patch('allura.controllers.rest.oauth.Server')
@mock.patch('allura.controllers.rest.oauth.Request')
def test_request_token_invalid(self, Request, Server):
Server().verify_request.side_effect = oauth2.Error('test_request_token_invalid')
M.OAuthConsumerToken.consumer = mock.Mock()
user = M.User.by_username('test-user')
M.OAuthConsumerToken(
api_key='api_key',
user_id=user._id,
)
ThreadLocalORMSession.flush_all()
Request.from_request.return_value = {'oauth_consumer_key': 'api_key'}
self.app.post('/rest/oauth/request_token', params={'key': 'value'}, status=401)
def test_authorize_ok(self):
user = M.User.by_username('test-admin')
ctok = M.OAuthConsumerToken(
api_key='api_key',
user_id=user._id,
description='ctok_desc',
)
M.OAuthRequestToken(
api_key='api_key',
consumer_token_id=ctok._id,
callback='oob',
user_id=user._id,
)
ThreadLocalORMSession.flush_all()
r = self.app.post('/rest/oauth/authorize', params={'oauth_token': 'api_key'})
assert_in('ctok_desc', r.text)
assert_in('api_key', r.text)
def test_authorize_invalid(self):
self.app.post('/rest/oauth/authorize', params={'oauth_token': 'api_key'}, status=401)
def test_do_authorize_no(self):
user = M.User.by_username('test-admin')
ctok = M.OAuthConsumerToken(
api_key='api_key',
user_id=user._id,
description='ctok_desc',
)
M.OAuthRequestToken(
api_key='api_key',
consumer_token_id=ctok._id,
callback='oob',
user_id=user._id,
)
ThreadLocalORMSession.flush_all()
self.app.post('/rest/oauth/do_authorize',
params={'no': '1', 'oauth_token': 'api_key'})
assert_is_none(M.OAuthRequestToken.query.get(api_key='api_key'))
def test_do_authorize_oob(self):
user = M.User.by_username('test-admin')
ctok = M.OAuthConsumerToken(
api_key='api_key',
user_id=user._id,
description='ctok_desc',
)
M.OAuthRequestToken(
api_key='api_key',
consumer_token_id=ctok._id,
callback='oob',
user_id=user._id,
)
ThreadLocalORMSession.flush_all()
r = self.app.post('/rest/oauth/do_authorize', params={'yes': '1', 'oauth_token': 'api_key'})
assert_is_not_none(r.html.find(text=re.compile('^PIN: ')))
def test_do_authorize_cb(self):
user = M.User.by_username('test-admin')
ctok = M.OAuthConsumerToken(
api_key='api_key',
user_id=user._id,
description='ctok_desc',
)
M.OAuthRequestToken(
api_key='api_key',
consumer_token_id=ctok._id,
callback='http://my.domain.com/callback',
user_id=user._id,
)
ThreadLocalORMSession.flush_all()
r = self.app.post('/rest/oauth/do_authorize', params={'yes': '1', 'oauth_token': 'api_key'})
assert r.location.startswith('http://my.domain.com/callback?oauth_token=api_key&oauth_verifier=')
def test_do_authorize_cb_params(self):
user = M.User.by_username('test-admin')
ctok = M.OAuthConsumerToken(
api_key='api_key',
user_id=user._id,
description='ctok_desc',
)
M.OAuthRequestToken(
api_key='api_key',
consumer_token_id=ctok._id,
callback='http://my.domain.com/callback?myparam=foo',
user_id=user._id,
)
ThreadLocalORMSession.flush_all()
r = self.app.post('/rest/oauth/do_authorize', params={'yes': '1', 'oauth_token': 'api_key'})
assert r.location.startswith('http://my.domain.com/callback?myparam=foo&oauth_token=api_key&oauth_verifier=')
@mock.patch('allura.controllers.rest.oauth.Request')
def test_access_token_no_consumer(self, Request):
Request.from_request.return_value = {
'oauth_consumer_key': 'api_key',
'oauth_token': 'api_key',
'oauth_verifier': 'good',
}
self.app.get('/rest/oauth/access_token', status=401)
@mock.patch('allura.controllers.rest.oauth.Request')
def test_access_token_no_request(self, Request):
Request.from_request.return_value = {
'oauth_consumer_key': 'api_key',
'oauth_token': 'api_key',
'oauth_verifier': 'good',
}
user = M.User.by_username('test-admin')
M.OAuthConsumerToken(
api_key='api_key',
user_id=user._id,
description='ctok_desc',
)
ThreadLocalORMSession.flush_all()
self.app.get('/rest/oauth/access_token', status=401)
@mock.patch('allura.controllers.rest.oauth.Request')
def test_access_token_bad_pin(self, Request):
Request.from_request.return_value = {
'oauth_consumer_key': 'api_key',
'oauth_token': 'api_key',
'oauth_verifier': 'bad',
}
user = M.User.by_username('test-admin')
ctok = M.OAuthConsumerToken(
api_key='api_key',
user_id=user._id,
description='ctok_desc',
)
M.OAuthRequestToken(
api_key='api_key',
consumer_token_id=ctok._id,
callback='http://my.domain.com/callback?myparam=foo',
user_id=user._id,
validation_pin='good',
)
ThreadLocalORMSession.flush_all()
self.app.get('/rest/oauth/access_token', status=401)
@mock.patch('allura.controllers.rest.oauth.Server')
@mock.patch('allura.controllers.rest.oauth.Request')
def test_access_token_bad_sig(self, Request, Server):
Request.from_request.return_value = {
'oauth_consumer_key': 'api_key',
'oauth_token': 'api_key',
'oauth_verifier': 'good',
}
user = M.User.by_username('test-admin')
ctok = M.OAuthConsumerToken(
api_key='api_key',
user_id=user._id,
description='ctok_desc',
)
M.OAuthRequestToken(
api_key='api_key',
consumer_token_id=ctok._id,
callback='http://my.domain.com/callback?myparam=foo',
user_id=user._id,
validation_pin='good',
)
ThreadLocalORMSession.flush_all()
Server().verify_request.side_effect = oauth2.Error('test_access_token_bad_sig')
self.app.get('/rest/oauth/access_token', status=401)
@mock.patch('allura.controllers.rest.oauth.Server')
@mock.patch('allura.controllers.rest.oauth.Request')
def test_access_token_ok(self, Request, Server):
Request.from_request.return_value = {
'oauth_consumer_key': 'api_key',
'oauth_token': 'api_key',
'oauth_verifier': 'good',
}
user = M.User.by_username('test-admin')
ctok = M.OAuthConsumerToken(
api_key='api_key',
user_id=user._id,
description='ctok_desc',
)
M.OAuthRequestToken(
api_key='api_key',
consumer_token_id=ctok._id,
callback='http://my.domain.com/callback?myparam=foo',
user_id=user._id,
validation_pin='good',
)
ThreadLocalORMSession.flush_all()
r = self.app.get('/rest/oauth/access_token')
atok = parse_qs(r.text)
assert_equal(len(atok['oauth_token']), 1)
assert_equal(len(atok['oauth_token_secret']), 1)
class TestDisableAccount(TestController):
def test_not_authenticated(self):
r = self.app.get(
'/auth/disable/',
extra_environ={'username': str('*anonymous')})
assert_equal(r.status_int, 302)
assert_equal(r.location,
'http://localhost/auth/?return_to=%2Fauth%2Fdisable%2F')
def test_lists_user_projects(self):
r = self.app.get('/auth/disable/')
user = M.User.by_username('test-admin')
for p in user.my_projects_by_role_name('Admin'):
if p.name == 'u/test-admin':
continue
assert_in(p.name, r)
assert_in(p.url(), r)
def test_has_asks_password(self):
r = self.app.get('/auth/disable/')
form = r.html.find('form', {'action': 'do_disable'})
assert form is not None
def test_bad_password(self):
self.app.get('/').follow() # establish session
r = self.app.post('/auth/disable/do_disable', {'password': '<PASSWORD>',
'_session_id': self.app.cookies['_session_id'], })
assert_in('Invalid password', r)
user = M.User.by_username('test-admin')
assert_equal(user.disabled, False)
def test_disable(self):
self.app.get('/').follow() # establish session
r = self.app.post('/auth/disable/do_disable', {'password': '<PASSWORD>',
'_session_id': self.app.cookies['_session_id'], })
assert_equal(r.status_int, 302)
assert_equal(r.location, 'http://localhost/')
flash = json.loads(self.webflash(r))
assert_equal(flash['status'], 'ok')
assert_equal(flash['message'], 'Your account was successfully disabled!')
user = M.User.by_username('test-admin')
assert_equal(user.disabled, True)
class TestPasswordExpire(TestController):
def login(self, username='test-user', pwd='<PASSWORD>', query_string=''):
extra = {'username': str('*anonymous'), 'REMOTE_ADDR': str('127.0.0.1')}
r = self.app.get('/auth/' + query_string, extra_environ=extra)
f = r.forms[0]
encoded = self.app.antispam_field_names(f)
f[encoded['username']] = username
f[encoded['password']] = pwd
return f.submit(extra_environ={'username': str('*anonymous')})
def assert_redirects(self, where='/'):
resp = self.app.get(where, extra_environ={'username': str('test-user')}, status=302)
assert_equal(resp.location, 'http://localhost/auth/pwd_expired?' + urlencode({'return_to': where}))
def assert_not_redirects(self, where='/neighborhood'):
self.app.get(where, extra_environ={'username': str('test-user')}, status=200)
def test_disabled(self):
r = self.login()
assert_false(r.session.get('pwd-expired'))
self.assert_not_redirects()
def expired(self, r):
return r.session.get('pwd-expired')
def set_expire_for_user(self, username='test-user', days=100):
user = M.User.by_username(username)
user.last_password_updated = datetime.utcnow() - timedelta(days=days)
session(user).flush(user)
return user
def test_days(self):
self.set_expire_for_user()
with h.push_config(config, **{'auth.pwdexpire.days': 180}):
r = self.login()
assert_false(self.expired(r))
self.assert_not_redirects()
with h.push_config(config, **{'auth.pwdexpire.days': 90}):
r = self.login()
assert_true(self.expired(r))
self.assert_redirects()
def test_before(self):
self.set_expire_for_user()
before = datetime.utcnow() - timedelta(days=180)
before = calendar.timegm(before.timetuple())
with h.push_config(config, **{'auth.pwdexpire.before': before}):
r = self.login()
assert_false(self.expired(r))
self.assert_not_redirects()
before = datetime.utcnow() - timedelta(days=90)
before = calendar.timegm(before.timetuple())
with h.push_config(config, **{'auth.pwdexpire.before': before}):
r = self.login()
assert_true(self.expired(r))
self.assert_redirects()
def test_logout(self):
self.set_expire_for_user()
with h.push_config(config, **{'auth.pwdexpire.days': 90}):
r = self.login()
assert_true(self.expired(r))
self.assert_redirects()
r = self.app.get('/auth/logout', extra_environ={'username': str('test-user')})
assert_false(self.expired(r))
self.assert_not_redirects()
def test_change_pwd(self):
self.set_expire_for_user()
with h.push_config(config, **{'auth.pwdexpire.days': 90}):
r = self.login()
assert_true(self.expired(r))
self.assert_redirects()
user = M.User.by_username('test-user')
old_update_time = user.last_password_updated
old_password = <PASSWORD>
r = self.app.get('/auth/pwd_expired', extra_environ={'username': str('test-user')})
f = r.forms[0]
f['oldpw'] = 'foo'
f['pw'] = 'qwerty'
f['pw2'] = 'qwerty'
r = f.submit(extra_environ={'username': str('test-user')}, status=302)
assert_equal(r.location, 'http://localhost/')
assert_false(self.expired(r))
user = M.User.by_username('test-user')
assert_true(user.last_password_updated > old_update_time)
assert_not_equal(user.password, <PASSWORD>)
# Can log in with new password and change isn't required anymore
r = self.login(pwd='<PASSWORD>').follow()
assert_equal(r.location, 'http://localhost/dashboard')
assert_not_in('Invalid login', r)
assert_false(self.expired(r))
self.assert_not_redirects()
# and can't log in with old password
r = self.login(pwd='<PASSWORD>')
assert_in('Invalid login', r)
def test_expired_pwd_change_invalidates_token(self):
self.set_expire_for_user()
with h.push_config(config, **{'auth.pwdexpire.days': 90}):
r = self.login()
assert_true(self.expired(r))
self.assert_redirects()
user = M.User.by_username('test-user')
user.set_tool_data('AuthPasswordReset',
hash="generated_hash_value",
hash_expiry="04-08-2020")
hash = user.get_tool_data('AuthPasswordReset', 'hash')
hash_expiry = user.get_tool_data('AuthPasswordReset', 'hash_expiry')
assert_equal(hash, 'generated_hash_value')
assert_equal(hash_expiry, '04-08-2020')
session(user).flush(user)
# Change expired password
r = self.app.get('/auth/pwd_expired', extra_environ={'username': str('test-user')})
f = r.forms[0]
f['oldpw'] = 'foo'
f['pw'] = 'qwerty'
f['pw2'] = 'qwerty'
r = f.submit(extra_environ={'username': str('test-user')}, status=302)
assert_equal(r.location, 'http://localhost/')
user = M.User.by_username('test-user')
hash = user.get_tool_data('AuthPasswordReset', 'hash')
hash_expiry = user.get_tool_data('AuthPasswordReset', 'hash_expiry')
assert_equal(hash, '')
assert_equal(hash_expiry, '')
def check_validation(self, oldpw, pw, pw2):
user = M.User.by_username('test-user')
old_update_time = user.last_password_updated
old_password = user.password
r = self.app.get('/auth/pwd_expired', extra_environ={'username': str('test-user')})
f = r.forms[0]
f['oldpw'] = oldpw
f['pw'] = pw
f['pw2'] = pw2
r = f.submit(extra_environ={'username': str('test-user')})
assert_true(self.expired(r))
user = M.User.by_username('test-user')
assert_equal(user.last_password_updated, old_update_time)
assert_equal(user.password, old_password)
return r
def test_change_pwd_validation(self):
self.set_expire_for_user()
with h.push_config(config, **{'auth.pwdexpire.days': 90}):
r = self.login()
assert_true(self.expired(r))
self.assert_redirects()
r = self.check_validation('', '', '')
assert_in('Please enter a value', r)
r = self.check_validation('', 'qwe', 'qwerty')
assert_in('Enter a value 6 characters long or more', r)
r = self.check_validation('bad', 'qwerty1', 'qwerty')
assert_in('Passwords must match', r)
r = self.check_validation('bad', 'qwerty', 'qwerty')
assert_in('Incorrect password', self.webflash(r))
assert_equal(r.location, 'http://localhost/auth/pwd_expired?return_to=')
with h.push_config(config, **{'auth.min_password_len': 3}):
r = self.check_validation('foo', 'foo', 'foo')
assert_in('Your old and new password should not be the same', r)
def test_return_to(self):
return_to = '/p/test/tickets/?milestone=1.0&page=2'
self.set_expire_for_user()
with h.push_config(config, **{'auth.pwdexpire.days': 90}):
r = self.login(query_string='?' + urlencode({'return_to': return_to}))
# don't go to the return_to yet
assert_equal(r.location, 'http://localhost/auth/pwd_expired?' + urlencode({'return_to': return_to}))
# but if user tries to go directly there anyway, intercept and redirect back
self.assert_redirects(where=return_to)
r = self.app.get('/auth/pwd_expired', extra_environ={'username': str('test-user')})
f = r.forms[0]
f['oldpw'] = 'foo'
f['pw'] = 'qwerty'
f['pw2'] = 'qwerty'
f['return_to'] = return_to
r = f.submit(extra_environ={'username': str('test-user')}, status=302)
assert_equal(r.location, 'http://localhost/p/test/tickets/?milestone=1.0&page=2')
class TestCSRFProtection(TestController):
def test_blocks_invalid(self):
# so test-admin isn't automatically logged in for all requests
self.app.extra_environ = {'disable_auth_magic': str('True'), 'REMOTE_ADDR': str('127.0.0.1')}
# regular login
r = self.app.get('/auth/')
r = self.app.post('/auth/do_login', params=dict(
username='test-admin', password='<PASSWORD>',
_session_id=self.app.cookies['_session_id']),
antispam=True)
# regular form submit
r = self.app.get('/admin/overview')
r = r.form.submit()
assert_equal(r.location, 'http://localhost/admin/overview')
# invalid form submit
r = self.app.get('/admin/overview')
r.form['_session_id'] = 'bogus'
r = r.form.submit()
assert_equal(r.location, 'http://localhost/auth/')
def test_blocks_invalid_on_login(self):
r = self.app.get('/auth/')
r.form['_session_id'] = 'bogus'
r.form.submit(status=403)
def test_token_present_on_first_request(self):
r = self.app.get('/auth/')
assert_true(r.form['_session_id'].value)
class TestTwoFactor(TestController):
sample_key = b'\<KEY>'
def _init_totp(self, username='test-admin'):
user = M.User.query.get(username=username)
totp_srv = TotpService().get()
totp_srv.set_secret_key(user, self.sample_key)
user.set_pref('multifactor', True)
def test_settings_on(self):
r = self.app.get('/auth/preferences/')
assert r.html.find(attrs={'class': 'preferences multifactor'})
def test_settings_off(self):
with h.push_config(config, **{'auth.multifactor.totp': 'false'}):
r = self.app.get('/auth/preferences/')
assert not r.html.find(attrs={'class': 'preferences multifactor'})
for url in ['/auth/preferences/totp_new',
'/auth/preferences/totp_view',
'/auth/preferences/totp_set',
'/auth/preferences/totp_send_link',
'/auth/preferences/multifactor_disable',
'/auth/preferences/multifactor_recovery',
'/auth/preferences/multifactor_recovery_regen',
'/auth/multifactor',
'/auth/do_multifactor',
]:
self.app.post(url,
{'password': '<PASSWORD>', '_session_id': self.app.cookies['_session_id']},
status=404)
def test_user_disabled(self):
r = self.app.get('/auth/preferences/')
info_html = str(r.html.find(attrs={'class': 'preferences multifactor'}))
assert_in('disabled', info_html)
def test_user_enabled(self):
self._init_totp()
r = self.app.get('/auth/preferences/')
info_html = str(r.html.find(attrs={'class': 'preferences multifactor'}))
assert_in('enabled', info_html)
def test_reconfirm_auth(self):
from datetime import datetime as real_datetime
with patch('allura.lib.decorators.datetime') as datetime:
datetime.min = real_datetime.min
# reconfirm required at first
datetime.utcnow.return_value = real_datetime(2016, 1, 1, 0, 0, 0)
r = self.app.get('/auth/preferences/totp_new')
assert_in('Password Confirmation', r)
# submit form, and its not required
r.form['password'] = 'foo'
r = r.form.submit()
assert_not_in('Password Confirmation', r)
# still not required
datetime.utcnow.return_value = real_datetime(2016, 1, 1, 0, 1, 45)
r = self.app.get('/auth/preferences/totp_new')
assert_not_in('Password Confirmation', r)
# required later
datetime.utcnow.return_value = real_datetime(2016, 1, 1, 0, 2, 3)
r = self.app.get('/auth/preferences/totp_new')
assert_in('Password Confirmation', r)
def test_enable_totp(self):
# create a separate session, for later use in the test
other_session = TestController()
other_session.setUp()
other_session.app.get('/auth/preferences/')
with out_audits(user=True):
r = self.app.get('/auth/preferences/totp_new')
assert_in('Password Confirmation', r)
with audits('Visited multifactor new TOTP page', user=True):
r.form['password'] = '<PASSWORD>'
r = r.form.submit()
assert_in('Scan this barcode', r)
first_key_shown = r.session['totp_new_key']
with audits('Failed to set up multifactor TOTP \(wrong code\)', user=True):
form = r.forms['totp_set']
form['code'] = ''
r = form.submit()
assert_in('Invalid', r)
assert_equal(first_key_shown, r.session['totp_new_key']) # different keys on each pageload would be bad!
new_totp = TotpService().Totp(r.session['totp_new_key'])
code = new_totp.generate(time_time())
form = r.forms['totp_set']
form['code'] = code
with audits('Set up multifactor TOTP', user=True):
r = form.submit()
assert_equal('Two factor authentication has now been set up.', json.loads(self.webflash(r))['message'],
self.webflash(r))
tasks = M.MonQTask.query.find(dict(task_name='allura.tasks.mail_tasks.sendsimplemail')).all()
assert_equal(len(tasks), 1)
assert_equal(tasks[0].kwargs['subject'], 'Two-Factor Authentication Enabled')
assert_in('new two-factor authentication', tasks[0].kwargs['text'])
r = r.follow()
assert_in('Recovery Codes', r)
# Confirm any pre-existing sessions have to re-authenticate
r = other_session.app.get('/auth/preferences/')
assert_in('/auth/?return_to', r.headers['Location'])
other_session.tearDown()
def test_reset_totp(self):
self._init_totp()
# access page
r = self.app.get('/auth/preferences/totp_new')
assert_in('Password Confirmation', r)
# reconfirm password to get to it
r.form['password'] = '<PASSWORD>'
r = r.form.submit()
# confirm warning message, and key is not changed yet
assert_in('Scan this barcode', r)
assert_in('this will invalidate your previous', r)
current_key = TotpService.get().get_secret_key(M.User.query.get(username='test-admin'))
assert_equal(self.sample_key, current_key)
# incorrect submission
form = r.forms['totp_set']
form['code'] = ''
r = form.submit()
assert_in('Invalid', r)
# still unchanged key
current_key = TotpService.get().get_secret_key(M.User.query.get(username='test-admin'))
assert_equal(self.sample_key, current_key)
# valid submission
new_key = r.session['totp_new_key']
new_totp = TotpService().Totp(new_key)
code = new_totp.generate(time_time())
form = r.forms['totp_set']
form['code'] = code
r = form.submit()
assert_equal('Two factor authentication has now been set up.', json.loads(self.webflash(r))['message'],
self.webflash(r))
# new key in place
current_key = TotpService.get().get_secret_key(M.User.query.get(username='test-admin'))
assert_equal(new_key, current_key)
assert_not_equal(self.sample_key, current_key)
def test_disable(self):
self._init_totp()
self.app.get('/auth/preferences/multifactor_disable', status=405) # GET not allowed
# get form and submit
r = self.app.get('/auth/preferences/')
form = r.forms['multifactor_disable']
r = form.submit()
# confirm first, no change
assert_in('Password Confirmation', r)
user = M.User.query.get(username='test-admin')
assert_equal(user.get_pref('multifactor'), True)
# confirm submit, everything goes off
r.form['password'] = '<PASSWORD>'
with audits('Disabled multifactor TOTP', user=True):
r = r.form.submit()
assert_equal('Multifactor authentication has now been disabled.', json.loads(self.webflash(r))['message'],
self.webflash(r))
user = M.User.query.get(username='test-admin')
assert_equal(user.get_pref('multifactor'), False)
assert_equal(TotpService().get().get_secret_key(user), None)
assert_equal(RecoveryCodeService().get().get_codes(user), [])
# email confirmation
tasks = M.MonQTask.query.find(dict(task_name='allura.tasks.mail_tasks.sendsimplemail')).all()
assert_equal(len(tasks), 1)
assert_equal(tasks[0].kwargs['subject'], 'Two-Factor Authentication Disabled')
assert_in('disabled two-factor authentication', tasks[0].kwargs['text'])
def test_login_totp(self):
self._init_totp()
# so test-admin isn't automatically logged in for all requests
self.app.extra_environ = {'disable_auth_magic': str('True')}
# regular login
r = self.app.get('/auth/?return_to=/p/foo')
encoded = self.app.antispam_field_names(r.form)
r.form[encoded['username']] = 'test-admin'
r.form[encoded['password']] = '<PASSWORD>'
with audits('Multifactor login - password ok, code not entered yet', user=True):
r = r.form.submit()
# check results
assert r.location.endswith('/auth/multifactor?return_to=%2Fp%2Ffoo'), r
r = r.follow()
assert not r.session.get('username')
# try an invalid code
r.form['code'] = 'invalid-code'
with audits('Multifactor login - invalid code', user=True):
r = r.form.submit()
assert_in('Invalid code', r)
assert not r.session.get('username')
# use a valid code
totp = TotpService().Totp(self.sample_key)
code = totp.generate(time_time())
r.form['code'] = code
with audits('Successful login', user=True):
r = r.form.submit()
# confirm login and final page
assert_equal(r.session['username'], 'test-admin')
assert r.location.endswith('/p/foo'), r
def test_login_rate_limit(self):
self._init_totp()
# so test-admin isn't automatically logged in for all requests
self.app.extra_environ = {'disable_auth_magic': str('True')}
# regular login
r = self.app.get('/auth/?return_to=/p/foo')
encoded = self.app.antispam_field_names(r.form)
r.form[encoded['username']] = 'test-admin'
r.form[encoded['password']] = '<PASSWORD>'
r = r.form.submit()
r = r.follow()
# try some invalid codes
for i in range(3):
r.form['code'] = 'invalid-code'
r = r.form.submit()
assert_in('Invalid code', r)
# use a valid code, but it'll hit rate limit
totp = TotpService().Totp(self.sample_key)
code = totp.generate(time_time())
r.form['code'] = code
with audits('Multifactor login - rate limit', user=True):
r = r.form.submit()
assert_in('rate limit exceeded', r)
assert not r.session.get('username')
def test_login_totp_disrupted(self):
self._init_totp()
# so test-admin isn't automatically logged in for all requests
self.app.extra_environ = {'disable_auth_magic': str('True')}
# regular login
r = self.app.get('/auth/')
encoded = self.app.antispam_field_names(r.form)
r.form[encoded['username']] = 'test-admin'
r.form[encoded['password']] = '<PASSWORD>'
r = r.form.submit()
r = r.follow()
# go to some other page instead of filling out the 2FA code
other_r = self.app.get('/')
# then try to complete the 2FA form
totp = TotpService().Totp(self.sample_key)
code = totp.generate(time_time())
r.form['code'] = code
r = r.form.submit()
# sent back to regular login
assert_equal('Your multifactor login was disrupted, please start over.',
json.loads(self.webflash(r))['message'],
self.webflash(r))
r = r.follow()
assert_in('Password Login', r)
def test_login_recovery_code(self):
self._init_totp()
# so test-admin isn't automatically logged in for all requests
self.app.extra_environ = {'disable_auth_magic': str('True')}
# regular login
r = self.app.get('/auth/?return_to=/p/foo')
encoded = self.app.antispam_field_names(r.form)
r.form[encoded['username']] = 'test-admin'
r.form[encoded['password']] = 'foo'
r = r.form.submit()
# check results
assert r.location.endswith('/auth/multifactor?return_to=%2Fp%2Ffoo'), r
r = r.follow()
assert not r.session.get('username')
# change login mode
r.form['mode'] = 'recovery'
# try an invalid code
r.form['code'] = 'invalid-code'
r = r.form.submit()
assert_in('Invalid code', r)
assert not r.session.get('username')
# use a valid code
user = M.User.by_username('test-admin')
recovery = RecoveryCodeService().get()
recovery.regenerate_codes(user)
recovery_code = recovery.get_codes(user)[0]
r.form['code'] = recovery_code
with audits('Logged in using a multifactor recovery code', user=True):
r = r.form.submit()
# confirm login and final page
assert_equal(r.session['username'], 'test-admin')
assert r.location.endswith('/p/foo'), r
# confirm code used up
assert_not_in(recovery_code, RecoveryCodeService().get().get_codes(user))
@patch('allura.lib.plugin.AuthenticationProvider.hibp_password_check_enabled', Mock(return_value=True))
def test_login_totp_with_hibp(self):
# this is essentially the same as regular TOTP test, just making sure that HIBP doesn't get in the way
# or cause any problems. It shouldn't even run since a password isn't present when the final login happens
self._init_totp()
# so test-admin isn't automatically logged in for all requests
self.app.extra_environ = {'disable_auth_magic': str('True')}
# regular login
r = self.app.get('/auth/?return_to=/p/foo')
encoded = self.app.antispam_field_names(r.form)
r.form[encoded['username']] = 'test-admin'
r.form[encoded['password']] = '<PASSWORD>'
with audits('Multifactor login - password ok, code not entered yet', user=True):
r = r.form.submit()
# check results
assert r.location.endswith('/auth/multifactor?return_to=%2Fp%2Ffoo'), r
r = r.follow()
assert not r.session.get('username')
# use a valid code
totp = TotpService().Totp(self.sample_key)
code = totp.generate(time_time())
r.form['code'] = code
with audits('Successful login', user=True):
r = r.form.submit()
# confirm login and final page
assert_equal(r.session['username'], 'test-admin')
assert r.location.endswith('/p/foo'), r
def test_view_key(self):
self._init_totp()
with out_audits(user=True):
r = self.app.get('/auth/preferences/totp_view')
assert_in('Password Confirmation', r)
with audits('Viewed multifactor TOTP config page', user=True):
r.form['password'] = '<PASSWORD>'
r = r.form.submit()
assert_in('Scan this barcode', r)
def test_view_recovery_codes_and_regen(self):
self._init_totp()
# reconfirm password
with out_audits(user=True):
r = self.app.get('/auth/preferences/multifactor_recovery')
assert_in('Password Confirmation', r)
# actual visit
with audits('Viewed multifactor recovery codes', user=True):
r.form['password'] = '<PASSWORD>'
r = r.form.submit()
assert_in('Download', r)
assert_in('Print', r)
# regenerate codes
with audits('Regenerated multifactor recovery codes', user=True):
r = r.forms['multifactor_recovery_regen'].submit()
# email confirmation
tasks = M.MonQTask.query.find(dict(task_name='allura.tasks.mail_tasks.sendsimplemail')).all()
assert_equal(len(tasks), 1)
assert_equal(tasks[0].kwargs['subject'], 'Two-Factor Recovery Codes Regenerated')
assert_in('regenerated', tasks[0].kwargs['text'])
def test_send_links(self):
r = self.app.get('/auth/preferences/totp_new')
r.form['password'] = '<PASSWORD>'
r = r.form.submit()
r = r.forms['totp_send_link'].submit()
tasks = M.MonQTask.query.find(dict(task_name='allura.tasks.mail_tasks.sendsimplemail')).all()
assert_equal(len(tasks), 1)
assert_equal(tasks[0].kwargs['subject'], 'Two-Factor Authentication Apps')
assert_in('itunes.apple.com', tasks[0].kwargs['text'])
assert_in('play.google.com', tasks[0].kwargs['text'])
```
#### File: tests/functional/test_home.py
```python
from __future__ import unicode_literals
from __future__ import absolute_import
import json
import re
import os
from io import open
from tg import tmpl_context as c
from nose.tools import assert_equal, assert_not_in, assert_in
from ming.orm import ThreadLocalORMSession
import allura
from allura.tests import TestController
from allura.tests import decorators as td
from allura import model as M
from six.moves import range
from six.moves import zip
class TestProjectHome(TestController):
@td.with_wiki
def test_project_nav(self):
response = self.app.get('/p/test/_nav.json')
root = self.app.get('/p/test/wiki/').follow()
assert re.search(r'<!-- Server: \S+ -->',
str(root.html)), 'Missing Server comment'
nav_links = root.html.find('div', dict(id='top_nav')).findAll('a')
nav_links = [nl for nl in nav_links if 'add-tool-toggle' not in nl['class']]
assert_equal(len(nav_links), len(response.json['menu']))
for nl, entry in zip(nav_links, response.json['menu']):
assert nl['href'] == entry['url']
@td.with_wiki
def test_project_nav_with_admin_options(self):
r = self.app.get('/p/test/_nav.json?admin_options=1')
assert_in({
"text": "Wiki",
"href": "/p/test/admin/install_tool?tool_name=wiki",
"tooltip":
"Documentation is key to your project and the wiki tool helps make it easy for anyone to contribute."
}, r.json['installable_tools'])
for m in r.json['menu']:
if m['mount_point'] == 'sub1':
assert_equal(m['admin_options'],
[{'className': None,
'text': 'Subproject Admin',
'href': '/p/test/sub1/admin',
}])
break
else:
raise AssertionError('Did not find sub1 subproject in menu results: {}'.format(r.json['menu']))
for m in r.json['menu']:
if m['mount_point'] == 'wiki':
assert_in({'className': 'admin_modal',
'text': 'Set Home',
'href': '/p/test/admin/wiki/home',
}, m['admin_options'])
assert_in({'className': None,
'text': 'Permissions',
'href': '/p/test/admin/wiki/permissions',
}, m['admin_options'])
assert_in({'className': 'admin_modal',
'text': 'Delete Everything',
'href': '/p/test/admin/wiki/delete',
}, m['admin_options'])
break
else:
raise AssertionError('Did not find wiki in menu results: {}'.format(r.json['menu']))
@td.with_wiki
def test_project_group_nav(self):
c.user = M.User.by_username('test-admin')
p = M.Project.query.get(shortname='test')
c.project = p
if 'wiki2' and not p.app_instance('wiki2'):
c.app = p.install_app('wiki', 'wiki2', 'wiki2', 9)
response = self.app.get('/p/test/_nav.json')
menu = response.json['menu']
wiki_group = menu[-2]
wikis = wiki_group.pop('children')
assert_equal({'url': '/p/test/_list/wiki', 'name': 'Wiki \u25be', 'mount_point': None,
'icon': 'tool-wiki', 'tool_name': 'wiki', 'is_anchored': False}, wiki_group)
assert_equal(len(wikis), 2)
assert_in({'url': '/p/test/wiki/', 'name': 'Wiki', 'mount_point': 'wiki',
'icon': 'tool-wiki', 'tool_name': 'wiki', 'is_anchored': False}, wikis)
assert_in({'url': '/p/test/wiki2/', 'name': 'wiki2', 'mount_point': 'wiki2',
'icon': 'tool-wiki', 'tool_name': 'wiki', 'is_anchored': False}, wikis)
def test_sitemap_limit_per_tool(self):
"""Test that sitemap is limited to max of 10 items per tool type."""
c.user = M.User.by_username('test-admin')
p = M.Project.query.get(shortname='test')
c.project = p
for i in range(11):
mnt = 'wiki' + str(i)
p.install_app('wiki', mnt, mnt, 10 + i)
response = self.app.get('/p/test/_nav.json')
menu = response.json['menu']
wikis = menu[-2]['children']
assert_equal(len(wikis), 10)
@td.with_wiki
def test_project_group_nav_more_than_ten(self):
for i in range(1, 15):
tool_name = "wiki%s" % str(i)
c.user = M.User.by_username('test-admin')
p = M.Project.query.get(shortname='test')
c.project = p
if tool_name and not p.app_instance(tool_name):
c.app = p.install_app('wiki', tool_name, tool_name, i)
response = self.app.get('/p/test/_nav.json')
menu = response.json['menu']
wiki_menu = [m for m in menu if m['tool_name'] == 'wiki'][0]
assert_equal(len(wiki_menu['children']), 10)
assert_in({'url': '/p/test/_list/wiki', 'name': 'More...', 'mount_point': None,
'icon': 'tool-wiki', 'tool_name': 'wiki', 'is_anchored': False}, wiki_menu['children'])
@td.with_wiki
def test_neighborhood_home(self):
self.app.get('/p/test/wiki/', status=302)
self.app.get('/adobe/test/wiki/', status=404)
self.app.get('/adobe/no_such_project/wiki/', status=404)
@td.with_user_project('test-admin')
def test_user_subproject_home_not_profile(self):
u_proj = M.Project.query.get(shortname='u/test-admin')
u_proj.new_subproject('sub1')
ThreadLocalORMSession.flush_all()
r = self.app.get('/u/test-admin/sub1/')
assert r.location.endswith('admin/'), r.location
assert_not_in('Profile', r.follow().text)
def test_user_icon_missing(self):
r = self.app.get('/u/test-user/user_icon', status=302)
assert r.location.endswith('images/user.png')
def test_user_icon(self):
file_name = 'neo-icon-set-454545-256x350.png'
file_path = os.path.join(allura.__path__[0], 'nf', 'allura', 'images', file_name)
file_data = open(file_path, 'rb').read()
upload = ('icon', file_name, file_data)
with td.audits('update project icon'):
self.app.post('/u/test-admin/admin/update', params=dict(
name='Test Project',
shortname='test',
short_description='A Test Project'),
upload_files=[upload])
r = self.app.get('/u/test-admin/user_icon')
assert_equal(r.content_type, 'image/png')
def test_user_search(self):
r = self.app.get('/p/test/user_search?term=test', status=200)
j = json.loads(r.text)
assert j['users'][0]['id'].startswith('test')
def test_user_search_for_disabled_user(self):
user = M.User.by_username('test-admin')
user.disabled = True
ThreadLocalORMSession.flush_all()
r = self.app.get('/p/test/user_search?term=test', status=200)
j = json.loads(r.text)
assert j == {'users': []}
def test_user_search_noparam(self):
self.app.get('/p/test/user_search', status=400)
def test_user_search_shortparam(self):
self.app.get('/p/test/user_search?term=ad', status=400)
def test_users(self):
r = self.app.get('/p/test/users', status=200)
j = json.loads(r.text)
expected = [{
'value': 'test-admin',
'label': 'Test Admin (test-admin)'
}]
assert_equal(j['options'], expected)
def test_members(self):
nbhd = M.Neighborhood.query.get(name='Projects')
self.app.post('/admin/groups/create', params={'name': 'B_role'})
test_project = M.Project.query.get(
shortname='test', neighborhood_id=nbhd._id)
test_project.add_user(M.User.by_username('test-user-1'), ['B_role'])
test_project.add_user(M.User.by_username('test-user'), ['Developer'])
test_project.add_user(M.User.by_username('test-user-0'), ['Member'])
test_project.add_user(M.User.by_username('test-user-2'), ['Member'])
test_project.add_user(M.User.by_username('test-user-3'), ['Member'])
test_project.add_user(M.User.by_username('test-user-3'), ['Developer'])
test_project.add_user(M.User.by_username('test-user-4'), ['Admin'])
ThreadLocalORMSession.flush_all()
r = self.app.get('/p/test/_members/')
assert '<td>Test Admin</td>' in r
assert '<td><a href="/u/test-admin/">test-admin</a></td>' in r
assert '<td>Admin</td>' in r
tr = r.html.findAll('tr')
assert "<td>Test Admin</td>" in str(tr[1])
assert "<td>Test User 4</td>" in str(tr[2])
assert "<td>Test User</td>" in str(tr[3])
assert "<td>Test User 3</td>" in str(tr[4])
assert "<td>Test User 0</td>" in str(tr[5])
assert "<td>Test User 1</td>" in str(tr[6])
assert "<td>Test User 2</td>" in str(tr[7])
def test_members_anonymous(self):
r = self.app.get('/p/test/_members/',
extra_environ=dict(username=str('*anonymous')))
assert '<td>Test Admin</td>' in r
assert '<td><a href="/u/test-admin/">test-admin</a></td>' in r
assert '<td>Admin</td>' in r
def test_toolaccess_before_subproject(self):
self.app.extra_environ = {'username': str('test-admin')}
# Add the subproject with a wiki.
self.app.post('/p/test/admin/update_mounts', params={
'new.install': 'install',
'new.ep_name': '',
'new.ordinal': '1',
'new.mount_point': 'test-mount',
'new.mount_label': 'Test Mount'})
r = self.app.get('/p/test/test-mount/')
assert r.location.endswith('admin/'), r.location
pr = M.Project.query.get(shortname='test/test-mount')
assert pr != None
c.user = M.User.query.get(username='test-admin')
# Install and Verify a Tool in the subproject.
pr.install_app(ep_name='Wiki', mount_point='test-sub', mount_label='Test Sub', ordinal='1')
r = self.app.get('/p/test/test-mount/test-sub/').follow()
active_link = r.html.findAll('li', {'class': 'selected'})
assert_equal(len(active_link), 1)
assert active_link[0].contents[1]['href'] == '/p/test/test-mount/test-sub/'
assert 'Welcome to your wiki!' in r
# Delete the Subproject.
self.app.post('/p/test/admin/update_mounts', params={
'subproject-0.delete': 'on',
'subproject-0.shortname': 'test/test-mount',
'new.ep_name': '',
})
# Try to access the installed tool as anon.
r = self.app.get('/p/test/test-mount/test-sub/', extra_environ=dict(username=str('*anonymous')), status=404)
# Try to access the installed tool as Admin.
r = self.app.get('/p/test/test-mount/test-sub/').follow()
assert 'Wiki' in r
# Install a new tool with same mount point in parent project. Here a Wiki is installed.
p = M.Project.query.get(shortname='test')
p.install_app(ep_name='Wiki', mount_point='test-mount', mount_label='Test Sub', ordinal='1')
# Check if the tool is accessed and not the subproject.
r = self.app.get('/p/test/test-mount/').follow()
active_link = r.html.findAll('li', {'class': 'selected'})
assert_equal(len(active_link), 1)
assert active_link[0].contents[1]['href'] == '/p/test/test-mount/'
assert 'Welcome to your wiki!' in r
```
#### File: ForgeBlog/forgeblog/widgets.py
```python
from __future__ import unicode_literals
from __future__ import absolute_import
import ew as ew_core
import ew.jinja2_ew as ew
from formencode import validators as fev
from allura.lib.widgets import form_fields as ffw
from allura.lib.widgets import forms
from allura import model as M
class BlogPager(ffw.PageList):
template = 'jinja:forgeblog:templates/blog_widgets/page_list.html'
class BlogPostForm(forms.ForgeForm):
template = 'jinja:forgeblog:templates/blog_widgets/post_form.html'
enctype = 'multipart/form-data'
@property
def fields(self):
return ew_core.NameList([
ew.TextField(name='title',
validator=fev.UnicodeString(not_empty=True,
messages={'empty': "You must provide a Title"}),
attrs=dict(placeholder='Enter your title here',
title='Enter your title here',
style='width: 425px')),
ffw.MarkdownEdit(name='text',
show_label=False,
attrs=dict(
placeholder='Enter your content here',
title='Enter your content here')),
ew.SingleSelectField(name='state',
options=[
ew.Option(py_value='draft', label='Draft'),
ew.Option(py_value='published', label='Published')]),
ffw.LabelEdit(name='labels',
placeholder='Add labels here',
title='Add labels here'),
ew.InputField(name='attachment',
label='Attachment', field_type='file', attrs={'multiple': 'True'},
validator=fev.FieldStorageUploadConverter(if_missing=None)),
])
def resources(self):
for r in super(BlogPostForm, self).resources():
yield r
yield ew.JSScript('''
$(function() {
$('input[name="title"]').focus();
});
''')
class NewPostForm(BlogPostForm):
@property
def fields(self):
fields = super(NewPostForm, self).fields
fields.append(ew.Checkbox(name='subscribe'))
return fields
class EditPostForm(BlogPostForm):
class buttons(ew_core.NameList):
delete = ew.SubmitButton(label='Delete')
class ViewPostForm(ew_core.Widget):
template = 'jinja:forgeblog:templates/blog_widgets/view_post.html'
defaults = dict(
ew_core.Widget.defaults,
value=None,
subscribed=None,
base_post=None)
def __call__(self, **kw):
kw = super(ViewPostForm, self).__call__(**kw)
kw['subscribed'] = \
M.Mailbox.subscribed(artifact=kw.get('value'))
return kw
class PreviewPostForm(ew_core.Widget):
template = 'jinja:forgeblog:templates/blog_widgets/preview_post.html'
defaults = dict(
ew_core.Widget.defaults,
value=None)
```
#### File: tests/github/test_extractor.py
```python
from __future__ import unicode_literals
from __future__ import absolute_import
import json
from unittest import TestCase
from io import BytesIO
import six.moves.urllib.request, six.moves.urllib.error, six.moves.urllib.parse
from mock import patch, Mock
from ... import github
from six.moves import zip
class TestGitHubProjectExtractor(TestCase):
PROJECT_INFO = {
'description': 'project description',
'homepage': 'http://example.com',
'has_wiki': True,
}
CLOSED_ISSUES_LIST = [
{'number': 1},
{'number': 2},
]
OPENED_ISSUES_LIST = [
{'number': 3},
{'number': 4},
{'number': 5},
]
OPENED_ISSUES_LIST_PAGE2 = [
{'number': 6},
{'number': 7},
{'number': 8},
]
ISSUE_COMMENTS = ['hello', 'mocked_comment']
ISSUE_COMMENTS_PAGE2 = ['hello2', 'mocked_comment2']
ISSUE_EVENTS = [
{'event': 'closed'},
{'event': 'reopened'},
]
ISSUE_EVENTS_PAGE2 = [
{'event': 'assigned'},
{'event': 'not-supported-event'},
]
def mocked_urlopen(self, url):
headers = {}
if url.endswith('/test_project'):
response = BytesIO(json.dumps(self.PROJECT_INFO))
elif url.endswith('/issues?state=closed'):
response = BytesIO(json.dumps(self.CLOSED_ISSUES_LIST))
elif url.endswith('/issues?state=open'):
response = BytesIO(json.dumps(self.OPENED_ISSUES_LIST))
headers = {'Link': '</issues?state=open&page=2>; rel="next"'}
elif url.endswith('/issues?state=open&page=2'):
response = BytesIO(json.dumps(self.OPENED_ISSUES_LIST_PAGE2))
elif url.endswith('/comments'):
response = BytesIO(json.dumps(self.ISSUE_COMMENTS))
headers = {'Link': '</comments?page=2>; rel="next"'}
elif url.endswith('/comments?page=2'):
response = BytesIO(json.dumps(self.ISSUE_COMMENTS_PAGE2))
elif url.endswith('/events'):
response = BytesIO(json.dumps(self.ISSUE_EVENTS))
headers = {'Link': '</events?page=2>; rel="next"'}
elif url.endswith('/events?page=2'):
response = BytesIO(json.dumps(self.ISSUE_EVENTS_PAGE2))
response.info = lambda: headers
return response
def setUp(self):
self.extractor = github.GitHubProjectExtractor('test_project')
self.extractor.urlopen = self.mocked_urlopen
def test_get_next_page_url(self):
self.assertIsNone(self.extractor.get_next_page_url(None))
self.assertIsNone(self.extractor.get_next_page_url(''))
link = '<https://api.github.com/repositories/8560576/issues?state=open&page=2>; rel="next", <https://api.github.com/repositories/8560576/issues?state=open&page=10>; rel="last"'
self.assertEqual(self.extractor.get_next_page_url(link),
'https://api.github.com/repositories/8560576/issues?state=open&page=2')
link = '<https://api.github.com/repositories/8560576/issues?state=open&page=2>; rel="next"'
self.assertEqual(self.extractor.get_next_page_url(link),
'https://api.github.com/repositories/8560576/issues?state=open&page=2')
link = '<https://api.github.com/repositories/8560576/issues?state=open&page=1>; rel="prev"'
self.assertIsNone(self.extractor.get_next_page_url(link))
def test_get_summary(self):
self.assertEqual(self.extractor.get_summary(), 'project description')
def test_get_homepage(self):
self.assertEqual(self.extractor.get_homepage(), 'http://example.com')
def test_iter_issues(self):
issues = list(self.extractor.iter_issues())
all_issues = list(zip((1, 2), self.CLOSED_ISSUES_LIST))
all_issues += list(zip((3, 4, 5), self.OPENED_ISSUES_LIST))
all_issues += list(zip((6, 7, 8), self.OPENED_ISSUES_LIST_PAGE2))
self.assertEqual(issues, all_issues)
def test_iter_comments(self):
mock_issue = {'comments_url': '/issues/1/comments'}
comments = list(self.extractor.iter_comments(mock_issue))
self.assertEqual(comments, self.ISSUE_COMMENTS +
self.ISSUE_COMMENTS_PAGE2)
def test_iter_events(self):
mock_issue = {'events_url': '/issues/1/events'}
events = list(self.extractor.iter_events(mock_issue))
self.assertEqual(events, self.ISSUE_EVENTS +
self.ISSUE_EVENTS_PAGE2[:1])
def test_has_wiki(self):
assert self.extractor.has_wiki()
def test_get_wiki_url(self):
self.assertEqual(self.extractor.get_page_url('wiki_url'),
'https://github.com/test_project.wiki')
@patch('forgeimporters.base.h.urlopen')
def test_urlopen(self, urlopen):
e = github.GitHubProjectExtractor('test_project')
url = 'https://github.com/u/p/'
e.urlopen(url)
request = urlopen.call_args[0][0]
self.assertEqual(request.get_full_url(), url)
user = Mock()
user.get_tool_data.return_value = 'abc'
e = github.GitHubProjectExtractor('test_project', user=user)
e.urlopen(url)
request = urlopen.call_args[0][0]
self.assertEqual(request.get_full_url(), url)
assert request.headers['User-agent']
self.assertEqual(request.unredirected_hdrs['Authorization'], 'token abc')
@patch('forgeimporters.base.h.urlopen')
@patch('forgeimporters.github.time.sleep')
@patch('forgeimporters.github.log')
def test_urlopen_rate_limit(self, log, sleep, urlopen):
limit_exceeded_headers = {
'X-RateLimit-Limit': '10',
'X-RateLimit-Remaining': '0',
'X-RateLimit-Reset': '1382693522',
}
response_limit_exceeded = BytesIO(b'{}')
response_limit_exceeded.info = lambda: limit_exceeded_headers
response_ok = BytesIO(b'{}')
response_ok.info = lambda: {}
urlopen.side_effect = [response_limit_exceeded, response_ok]
e = github.GitHubProjectExtractor('test_project')
e.get_page('fake')
self.assertEqual(sleep.call_count, 1)
self.assertEqual(urlopen.call_count, 2)
log.warn.assert_called_once_with(
'Rate limit exceeded (10 requests/hour). '
'Sleeping until 2013-10-25 09:32:02 UTC'
)
sleep.reset_mock()
urlopen.reset_mock()
log.warn.reset_mock()
response_ok = BytesIO(b'{}')
response_ok.info = lambda: {}
urlopen.side_effect = [response_ok]
e.get_page('fake 2')
self.assertEqual(sleep.call_count, 0)
self.assertEqual(urlopen.call_count, 1)
self.assertEqual(log.warn.call_count, 0)
@patch('forgeimporters.base.h.urlopen')
@patch('forgeimporters.github.time.sleep')
@patch('forgeimporters.github.log')
def test_urlopen_rate_limit_403(self, log, sleep, urlopen):
'''Test that urlopen catches 403 which may happen if limit exceeded by another task'''
limit_exceeded_headers = {
'X-RateLimit-Limit': '10',
'X-RateLimit-Remaining': '0',
'X-RateLimit-Reset': '1382693522',
}
def urlopen_side_effect(*a, **kw):
mock_resp = BytesIO(b'{}')
mock_resp.info = lambda: {}
urlopen.side_effect = [mock_resp]
raise six.moves.urllib.error.HTTPError(
'url', 403, 'msg', limit_exceeded_headers, BytesIO(b'{}'))
urlopen.side_effect = urlopen_side_effect
e = github.GitHubProjectExtractor('test_project')
e.get_page('fake')
self.assertEqual(sleep.call_count, 1)
self.assertEqual(urlopen.call_count, 2)
log.warn.assert_called_once_with(
'Rate limit exceeded (10 requests/hour). '
'Sleeping until 2013-10-25 09:32:02 UTC'
)
@patch.object(github.requests, 'head')
def test_check_readable(self, head):
head.return_value.status_code = 200
assert github.GitHubProjectExtractor('my-project').check_readable()
head.return_value.status_code = 404
assert not github.GitHubProjectExtractor('my-project').check_readable()
```
#### File: tests/functional/test_rest.py
```python
from __future__ import unicode_literals
from __future__ import absolute_import
from nose.tools import assert_equal
from allura.tests import decorators as td
from alluratest.controller import TestRestApiBase
from allura import model as M
from allura.lib import helpers as h
class TestLinkApi(TestRestApiBase):
def setUp(self):
super(TestLinkApi, self).setUp()
self.setup_with_tools()
@td.with_link
def setup_with_tools(self):
h.set_context('test', 'link', neighborhood='Projects')
def test_rest_link(self):
r = self.api_get('/rest/p/test/link'.encode('utf-8'))
assert_equal(r.json['url'], None)
r = self.api_post('/rest/p/test/link'.encode('utf-8'),
url='http://google.com')
assert_equal(r.json['url'], 'http://google.com')
self.api_post('/rest/p/test/link'.encode('utf-8'),
url='http://yahoo.com')
r = self.api_get('/rest/p/test/link'.encode('utf-8'))
assert_equal(r.json['url'], 'http://yahoo.com')
self.api_post('/rest/p/test/link'.encode('utf-8'))
r = self.api_get('/rest/p/test/link'.encode('utf-8'))
assert_equal(r.json['url'], 'http://yahoo.com')
def test_rest_link_get_permissions(self):
self.app.get('/rest/p/test/link',
extra_environ={'username': str('*anonymous')}, status=200)
p = M.Project.query.get(shortname='test')
acl = p.app_instance('link').config.acl
anon = M.ProjectRole.by_name('*anonymous')._id
anon_read = M.ACE.allow(anon, 'read')
acl.remove(anon_read)
self.app.get('/rest/p/test/link',
extra_environ={'username': str('*anonymous')}, status=401)
def test_rest_link_post_permissions(self):
self.app.post('/rest/p/test/link',
params={'url': 'http://yahoo.com'},
extra_environ={'username': str('*anonymous')},
status=401)
p = M.Project.query.get(shortname='test')
acl = p.app_instance('link').config.acl
anon = M.ProjectRole.by_name('*anonymous')._id
anon_configure = M.ACE.allow(anon, 'configure')
acl.append(anon_configure)
self.app.post('/rest/p/test/link',
params={'url': 'http://yahoo.com'},
extra_environ={'username': str('*anonymous')},
status=200)
r = self.api_get('/rest/p/test/link'.encode('utf-8'))
assert_equal(r.json['url'], 'http://yahoo.com')
class TestLinkHasAccess(TestRestApiBase):
def setUp(self):
super(TestLinkHasAccess, self).setUp()
self.setup_with_tools()
@td.with_link
def setup_with_tools(self):
h.set_context('test', 'link', neighborhood='Projects')
def test_has_access_no_params(self):
self.api_get('/rest/p/test/link/has_access', status=404)
self.api_get('/rest/p/test/link/has_access?user=root', status=404)
self.api_get('/rest/p/test/link/has_access?perm=read', status=404)
def test_has_access_unknown_params(self):
"""Unknown user and/or permission always False for has_access API"""
r = self.api_get(
'/rest/p/test/link/has_access?user=babadook&perm=read',
user='root')
assert_equal(r.status_int, 200)
assert_equal(r.json['result'], False)
r = self.api_get(
'/rest/p/test/link/has_access?user=test-user&perm=jump',
user='root')
assert_equal(r.status_int, 200)
assert_equal(r.json['result'], False)
def test_has_access_not_admin(self):
"""
User which has no 'admin' permission on neighborhood can't use
has_access API
"""
self.api_get(
'/rest/p/test/link/has_access?user=test-admin&perm=configure',
user='test-user',
status=403)
def test_has_access(self):
r = self.api_get(
'/rest/p/test/link/has_access?user=test-admin&perm=configure',
user='root')
assert_equal(r.status_int, 200)
assert_equal(r.json['result'], True)
r = self.api_get(
'/rest/p/test/link/has_access?user=test-user&perm=configure',
user='root')
assert_equal(r.status_int, 200)
assert_equal(r.json['result'], False)
``` |
{
"source": "99Kies/CarRentBlockChain",
"score": 2
} |
#### File: blueprints/public/public.py
```python
from flask import (
Blueprint,
current_app,
flash,
redirect,
render_template,
request,
url_for,
render_template_string
)
from flask_login import login_required, login_user, logout_user, current_user
from CarRentBlockChain.extensions import login_manager
from CarRentBlockChain.blueprints.public.forms import RegisterForm, LoginForm
from CarRentBlockChain.blueprints.public.models import User
from CarRentBlockChain.webutils import flash_errors, redirect_back
from CarRentBlockChain.extensions import db
from CarRentBlockChain.privkeyutils.privkeyutils import create_random_address
from CarRentBlockChain.settings import CARRENT_URL, REQUEST_HEADER
import requests
import json
from flask_cors import CORS
public_bp = Blueprint("public", __name__, static_folder="../static")
CORS(public_bp)
Identity_Status = {
1: "CarOwner",
2: "User",
}
@public_bp.route("/", methods=["GET", "POST"])
@login_required
def home():
"""Home page."""
return render_template("public/home.html")
@public_bp.route("/logout/")
@login_required
def logout():
"""Logout."""
logout_user()
flash("You are logged out.", "info")
return redirect(url_for("public.home"))
@public_bp.route('/login', methods=['GET', 'POST'])
def login():
# login in func
if current_user.is_authenticated:
return redirect(url_for('public.home'))
form = LoginForm()
if form.validate_on_submit():
username_or_email = form.username.data
password = form.password.data
# remember = form.remember.data
user = [User.query.filter(User.username==username_or_email).first(), User.query.filter(User.email==username_or_email).first()]
if user[0]:
if user[0].check_password(password):
# login_user(user[0], remember)
login_user(user[0])
flash('Welcome back.', 'info')
return redirect_back()
else:
flash('账号或者密码错误，请重新输入！', 'warning')
elif user[1]:
if user[1].check_password(password):
login_user(user[1])
flash('Welcome back.', 'info')
return redirect_back()
else:
flash('账号或者密码错误，请重新输入！', 'warning')
else:
flash('No account.', 'warning')
return render_template('public/login.html', form=form)
@public_bp.route("/register/", methods=["GET", "POST"])
def register():
"""Register new user."""
if current_user.is_authenticated:
return redirect(url_for('public.home'))
form = RegisterForm()
if form.validate_on_submit():
username = form.username.data
email = form.email.data
password = <PASSWORD>.data
password1 = <PASSWORD>
iphonenumber = form.iphone.data
idcard = form.idcard.data
status = form.status.data
if not all([username, email, password, password1, iphonenumber, idcard, status]):
flash('请把信息填写完整', "warning")
elif password != password1:
flash('两次密码不一致，请重新输入！', "warning")
elif User.query.filter(User.username==username).first():
flash('这个用户名已经被注册过了！', "warning")
elif User.query.filter(User.email==email).first():
flash('这个邮箱已经被注册过了！', "warning")
else:
addr_msg = create_random_address()
new_user = User(username=username, email=email, active=False, id=None, privkey=addr_msg["privateKeyHex"][2:],
iphone=iphonenumber, idcard=idcard, status=Identity_Status[status], privatekey_hex=addr_msg["privateKeyHex"],
privatekey_int=addr_msg["privateKeyInt"], publickey_hex=addr_msg["publicKeyHex"],
publickey_int=addr_msg["publicKeyInt"], address=addr_msg["address"])
if Identity_Status[status] == "User":
link_url = CARRENT_URL + "/user/add"
data = {
"address": new_user.address
}
r_user = requests.post(link_url, headers=REQUEST_HEADER, json=data)
if Identity_Status[status] == "CarOwner":
link_url = CARRENT_URL + "/carowner/add"
data = {
"address": new_user.address
}
r_carowner = requests.post(link_url, headers=REQUEST_HEADER, json=data)
# add a User(active = False)
new_user.set_password(password)
db.session.add(new_user)
# try:
# db.session.commit()
# return redirect(url_for('public.home'))
# except:
# flash("注册失败，请重试！")
# db.session.rollback()
db.session.commit()
flash("感谢注册，请联系管理员激活账号！", "success")
return redirect(url_for('public.login'))
return render_template('public/register.html', form=form)
@public_bp.route("/about/")
def about():
"""About page."""
form = LoginForm(request.form)
return render_template("public/about.html", form=form)
@public_bp.route("/Identity_manager/", methods=["GET", "POST"])
def Identity_manager():
"""Identity_manager page."""
form = LoginForm(request.form)
return render_template("public/Identity_manager.html", form=form)
@public_bp.route("/tables_data", methods=["GET", "POST"])
def tables_data():
return render_template("public/tables_data.html")
@public_bp.route("/certificate", methods=["GET", "POST"])
def certificate():
return render_template("public/certificate.html")
@public_bp.route("/Visualization_tools/")
def Visualization_tools():
"""Visualization_tools page."""
form = LoginForm(request.form)
return render_template("public/visualization_tools.html", form=form)
```
#### File: precompile/config/config_precompile.py
```python
from client.common import transaction_common
class ConfigPrecompile:
"""
implementation of ConfigPrecompile
"""
def __init__(self, contract_path):
"""
init the address for SystemConfig contract
"""
self._config_address = "0x0000000000000000000000000000000000001000"
self.gasPrice = 300000000
self.client = transaction_common.TransactionCommon(
self._config_address, contract_path, "SystemConfig")
def setValueByKey(self, key, value):
"""
set value for the givn key
"""
fn_name = "setValueByKey"
fn_args = [key, value]
return self.client.send_transaction_getReceipt(fn_name, fn_args, self.gasPrice)
``` |
{
"source": "99Kies/CTFd_python3",
"score": 2
} |
#### File: tests/utils/test_ctftime.py
```python
from tests.helpers import (
create_ctfd,
destroy_ctfd,
register_user,
login_as_user,
gen_challenge,
gen_flag,
)
from CTFd.models import Solves
from CTFd.utils import set_config
from CTFd.utils.dates import ctf_started, ctf_ended
from freezegun import freeze_time
def test_ctftime_prevents_accessing_challenges_before_ctf():
"""Test that the ctftime function prevents users from accessing challenges before the ctf"""
app = create_ctfd()
with app.app_context():
set_config(
"start", "1507089600"
) # Wednesday, October 4, 2017 12:00:00 AM GMT-04:00 DST
set_config(
"end", "1507262400"
) # Friday, October 6, 2017 12:00:00 AM GMT-04:00 DST
register_user(app)
chal = gen_challenge(app.db)
chal_id = chal.id
gen_flag(app.db, challenge_id=chal.id, content="flag")
with freeze_time("2017-10-3"): # CTF has not started yet.
client = login_as_user(app)
r = client.get("/challenges")
assert r.status_code == 403
with client.session_transaction() as sess:
data = {"key": "flag", "nonce": sess.get("nonce")}
r = client.get("/api/v1/challenges/{}".format(chal_id), data=data)
data = r.get_data(as_text=True)
assert r.status_code == 403
solve_count = app.db.session.query(app.db.func.count(Solves.id)).first()[0]
assert solve_count == 0
destroy_ctfd(app)
def test_ctftime_allows_accessing_challenges_during_ctf():
"""Test that the ctftime function allows accessing challenges during the ctf"""
app = create_ctfd()
with app.app_context():
set_config(
"start", "1507089600"
) # Wednesday, October 4, 2017 12:00:00 AM GMT-04:00 DST
set_config(
"end", "1507262400"
) # Friday, October 6, 2017 12:00:00 AM GMT-04:00 DST
register_user(app)
chal = gen_challenge(app.db)
chal_id = chal.id
gen_flag(app.db, challenge_id=chal.id, content="flag")
with freeze_time("2017-10-5"):
client = login_as_user(app)
r = client.get("/challenges")
assert r.status_code == 200
with client.session_transaction() as sess:
data = {
"submission": "flag",
"challenge_id": chal_id,
"nonce": sess.get("nonce"),
}
r = client.post("/api/v1/challenges/attempt", data=data)
assert r.status_code == 200
solve_count = app.db.session.query(app.db.func.count(Solves.id)).first()[0]
assert solve_count == 1
destroy_ctfd(app)
def test_ctftime_prevents_accessing_challenges_after_ctf():
"""Test that the ctftime function prevents accessing challenges after the ctf"""
app = create_ctfd()
with app.app_context():
set_config(
"start", "1507089600"
) # Wednesday, October 4, 2017 12:00:00 AM GMT-04:00 DST
set_config(
"end", "1507262400"
) # Friday, October 6, 2017 12:00:00 AM GMT-04:00 DST
register_user(app)
chal = gen_challenge(app.db)
chal_id = chal.id
gen_flag(app.db, challenge_id=chal.id, content="flag")
with freeze_time("2017-10-7"):
client = login_as_user(app)
r = client.get("/challenges")
assert r.status_code == 403
with client.session_transaction() as sess:
data = {
"submission": "flag",
"challenge_id": chal_id,
"nonce": sess.get("nonce"),
}
r = client.post("/api/v1/challenges/attempt", data=data)
assert r.status_code == 403
solve_count = app.db.session.query(app.db.func.count(Solves.id)).first()[0]
assert solve_count == 0
destroy_ctfd(app)
def test_ctf_started():
"""
Tests that the ctf_started function returns the correct value
:return:
"""
app = create_ctfd()
with app.app_context():
assert ctf_started() is True
set_config(
"start", "1507089600"
) # Wednesday, October 4, 2017 12:00:00 AM GMT-04:00 DST
set_config(
"end", "1507262400"
) # Friday, October 6, 2017 12:00:00 AM GMT-04:00 DST
with freeze_time("2017-10-3"):
ctf_started()
assert ctf_started() is False
with freeze_time("2017-10-5"):
assert ctf_started() is True
with freeze_time("2017-10-7"):
assert ctf_started() is True
destroy_ctfd(app)
def test_ctf_ended():
"""
Tests that the ctf_ended function returns the correct value
"""
app = create_ctfd()
with app.app_context():
assert ctf_ended() is False
set_config(
"start", "1507089600"
) # Wednesday, October 4, 2017 12:00:00 AM GMT-04:00 DST
set_config(
"end", "1507262400"
) # Friday, October 6, 2017 12:00:00 AM GMT-04:00 DST
with freeze_time("2017-10-3"):
assert ctf_ended() is False
with freeze_time("2017-10-5"):
assert ctf_ended() is False
with freeze_time("2017-10-7"):
assert ctf_ended() is True
destroy_ctfd(app)
``` |
{
"source": "99Kies/incubator-flagon-tap",
"score": 2
} |
#### File: incubator-flagon-tap/app_mgr/serializers.py
```python
from rest_framework import serializers
from django.contrib.auth import get_user_model
from app_mgr.models import UserProfile, Organization, Membership, Application, AppVersion
class MembershipSerializer(serializers.ModelSerializer):
user = serializers.PrimaryKeyRelatedField(queryset=UserProfile.objects.all())
org = serializers.PrimaryKeyRelatedField(queryset=Organization.objects.all())
class Meta:
model = Membership
fields = ('org', 'user', 'is_admin', 'join_date')
class UserProfileSerializer(serializers.ModelSerializer):
memberships = MembershipSerializer(source='membership_set', many=True)
class Meta:
model = UserProfile
fields = ('id', 'email', 'date_joined',
'is_staff', 'is_active', 'public_contact',
'memberships')
class OrganizationSerializer(serializers.ModelSerializer):
memberships = MembershipSerializer(source='membership_set', many=True)
class Meta:
model = Organization
fields = ('id', 'name', 'memberships')
class OwnerRelatedField(serializers.RelatedField):
def to_representation(self, value):
if isinstance(value, UserProfile):
serializer = UserProfileSerializer(value)
elif isinstance(value, Organization):
serializer = OrganizationSerializer(value)
else:
raise Exception('Unexpected type for owner')
return serializer.data
class AppVersionSerializer(serializers.ModelSerializer):
class Meta:
model = AppVersion
fields = ('id', 'name', 'domain', 'aliases')
class ApplicationSerializer(serializers.ModelSerializer):
versions = AppVersionSerializer(source='appversion_set', many=True)
class Meta:
model = Application
fields = ('id', 'name', 'isPublic', 'versions')
``` |
{
"source": "99Kies/MRoom",
"score": 3
} |
#### File: MRoom/app/app.py
```python
from flask import Flask, render_template, request, redirect, url_for, flash
from flask_bootstrap import Bootstrap
from flask_wtf import FlaskForm
from wtforms import StringField, SubmitField, TextAreaField, PasswordField
from wtforms.validators import DataRequired, Length
from werkzeug.security import check_password_hash, generate_password_hash
import os
app = Flask(__name__)
app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', 'secret string')
bootstrap = Bootstrap(app)
password = generate_password_hash("<PASSWORD>")
class UserForm(FlaskForm):
userid = PasswordField("User ID", validators=[DataRequired(), Length(8,30)])
submit = SubmitField("登入")
@app.route("/", methods=["GET","POST"])
def index():
form = UserForm()
if form.validate_on_submit():
userid = form.userid.data
if check_password_hash(password, "<PASSWORD>"):
return redirect(url_for("server"))
flash("账号或者密码错误！")
return render_template("index.html", form=form)
@app.route('/server')
def server():
return render_template("server.html")
if __name__ == "__main__":
app.run(host='0.0.0.0', port=33420)
``` |
{
"source": "99Kies/open-hackathon",
"score": 2
} |
#### File: src/client/functions.py
```python
import json, os, requests, urllib.request, urllib.error, urllib.parse
from datetime import datetime
from urllib.parse import parse_qs
import ssl
from flask import jsonify
try:
from config import Config
except ImportError:
from client.config_sample import Config
def convert(input):
if isinstance(input, dict):
return {convert(key): convert(value) for key, value in input.items()}
elif isinstance(input, list):
return [convert(element) for element in input]
elif isinstance(input, str):
return input.encode('utf-8')
else:
return input
def get_config(key):
ret = Config
for arg in key.split("."):
if arg in ret and isinstance(ret, dict):
ret = ret[arg]
else:
return None
return ret
def safe_get_config(key, default_value):
r = get_config(key)
return r if r is not None else default_value
def mkdir_safe(path):
if path and not (os.path.exists(path)):
os.makedirs(path)
return path
def get_class(kls):
# kls is the full name of a class obj. e.g. "hackathon.registration.Registration"
parts = kls.split('.')
module = ".".join(parts[:-1])
m = __import__(module)
for comp in parts[1:]:
m = getattr(m, comp)
return m
def post_to_remote(url, post_data, headers=None):
ssl.match_hostname = lambda cert, hostname: True
default_headers = {"content-type": "application/json"}
if headers is not None and isinstance(headers, dict):
default_headers.update(headers)
req = requests.post(url, data=json.dumps(post_data), headers=default_headers)
resp = json.loads(req.content)
return convert(resp)
def put_to_remote(url, post_data, headers=None):
ssl.match_hostname = lambda cert, hostname: True
default_headers = {"content-type": "application/json"}
if headers is not None and isinstance(headers, dict):
default_headers.update(headers)
req = requests.put(url, data=json.dumps(post_data), headers=default_headers)
resp = json.loads(req.content)
return convert(resp)
def get_remote(url, headers={}):
# ssl.match_hostname = lambda cert, hostname: True
# opener = urllib.request.build_opener(urllib.request.HTTPHandler)
# request = urllib.request.Request(url, None, headers)
# print(request)
# resp = opener.open(request)
# print(resp.read())
r = requests.get(url, headers=headers)
# print(r.text)
# print(jsonify(r.text))
r.encoding = r.apparent_encoding
# return resp.read()
return r.text
def delete_remote(url, headers=None):
ssl.match_hostname = lambda cert, hostname: True
default_headers = {"content-type": "application/json"}
if headers is not None and isinstance(headers, dict):
default_headers.update(headers)
opener = urllib.request.build_opener(urllib.request.HTTPHandler)
request = urllib.request.Request(url, headers=default_headers)
request.get_method = lambda: 'DELETE'
opener.open(request)
return "OK"
def get_now():
return datetime.utcnow() # tzinfo=None
def qs_dict(query):
return dict([(k, v[0]) for k, v in list(parse_qs(query).items())])
def is_local():
return safe_get_config("environment", "local") == "local"
```
#### File: src/client/__init__.py
```python
from flask import Flask
from flask_debugtoolbar import DebugToolbarExtension
from client.functions import safe_get_config
# flask
app = Flask(__name__)
app.config['SECRET_KEY'] = safe_get_config("app.secret_key", "secret_key")
app.config['DEBUG_TB_ENABLED'] = False
toolbar = DebugToolbarExtension(app)
class Context(object):
"""Helper class for JSON. We can access dict similarly as literal in JS
Essentially a collection of parameters that will be passed through threads/databases
NEVER put complex object in Context such as instance of db models or business manager
::Example:
dic = {"a": "va", "b": {"b1": "b1", "b2": [1, 2, 3], "b3": [{"b3a": "b3a"}]}}
c = Context.from_object(dic) # convert existing obj to Context
print c.a
print c["a"] # exactly the same as c.a. But it allows you pass values to key
key = "test"
print c[key] # now c[key] == c["test"] but c.key != c["test"], actually c.key=c["key"]
print c.b.b1
print c.b.b3[0].b3a
print c.get("c", 3) # unlike c.a or c["a"], get won't raise exception if key not found
print c.get("c")
c.c1 = True # you can set attribute any time
print c.get("c1")
ctx = Context("a"="a-v","b"="b-v") # you can also create instance directly through constructor
ctx.c = "c-v"
print ctx.a
print ctx["c"]
"""
def __init__(self, **kwargs):
for key, value in list(kwargs.items()):
self.__dict__[key] = value
def __getattr__(self, name):
if name in self.__dict__:
return self.__dict__[name]
raise AttributeError()
def __setattr__(self, key, value):
self.__dict__[key] = value
def __getitem__(self, item):
return self.__getattr__(item)
def __setitem__(self, key, value):
return self.__setattr__(key, value)
def __repr__(self):
return repr(self.__dict__)
def __contains__(self, key):
return key in self.__dict__
def get(self, key, default_value=None):
if key in self.__dict__:
return self.__dict__[key]
else:
return default_value
@staticmethod
def from_object(arg):
"""Convert JSON-like object to Context recursively
:returns list of Context if arg is list
instance of Context if arg is dict
the original arg otherwise
"""
if isinstance(arg, list):
return [Context.from_object(a) for a in arg]
elif isinstance(arg, dict):
ctx = Context()
for k, v in arg.items():
if isinstance(v, dict):
setattr(ctx, k, Context.from_object(v))
elif isinstance(v, list):
setattr(ctx, k, [Context.from_object(vv) for vv in v])
else:
setattr(ctx, k, v)
return ctx
else:
return arg
from .views import *
```
#### File: client/user/user.py
```python
import sys
sys.path.append("..")
class User():
def __init__(self, dic):
for key, value in dic.items():
setattr(self, key, value)
def get_avatar_url(self):
ret = None
if hasattr(self, "profile"):
ret = self.profile.get("avatar_url", None)
if not ret and hasattr(self, "avatar_url"):
ret = self.avatar_url
return ret
def get_user_id(self):
return self.id
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return str(self.get_user_id())
def is_super(self):
return self.is_super
def __repr__(self):
return repr(self.__dict__)
```
#### File: hackathon/cache/cache_mgr.py
```python
from beaker.cache import CacheManager
from beaker.util import parse_cache_config_options
from hackathon import Component
__all__ = ["CacheManagerExt"]
class CacheManagerExt(Component):
"""To cache resource"""
def get_cache(self, key, createfunc):
"""Get cached data of the returns of createfunc depending on the key.
If key and createfunc exist in cache, returns the cached data,
otherwise caches the returns of createfunc and returns data.
:type key: String
:param key: key name, present the unique key each time caching
:type createfunc: function object
:param createfunc: only the name of function, have no parameters,
its return type can be any basic object, like String, int, tuple, list, dict, etc.
:rtype: String
:return: the value mapped to the key
:example:
CacheManager.get_cache(key="abc", createfunc=func)
"""
results = self.tmpl_cache.get(key=key, createfunc=createfunc)
return results
def invalidate(self, key):
"""remove the key-value pair in the cache
:type key: String
:param key: key name, present the unique key each time caching
:rtype: bool
:return: True if remove the key-value pair correctly, otherwise False
"""
try:
self.tmpl_cache.remove_value(key=key)
return True
except Exception as e:
self.log.error(e)
return False
def clear(self):
"""clear all the cache
:rtype: bool
:return: True if clear the cache correctly, otherwise False
"""
try:
self.tmpl_cache.clear()
return True
except Exception as e:
self.log.error(e)
return False
def __init__(self):
"""initialize the class CacheManager
More configuration refer to http://beaker.readthedocs.org/en/latest/caching.html#about
"""
# store the basic configuration
self.cache_opts = {
'cache.type': 'memory',
# can be "memory" or "file"
'cache.data_dir': '/tmp/cache/data',
'cache.lock_dir': '/tmp/cache/lock'
}
# create CacheManager instance with cache_opts
self.cache = CacheManager(**parse_cache_config_options(self.cache_opts))
# In addition to the defaults supplied to the CacheManager instance,
# any of the Cache options can be changed on a per-namespace basis,
# by setting a type, and expire option.
self.tmpl_cache = self.cache.get_cache('mytemplate', type='file', expire=3600)
```
#### File: hackathon/hack/host_server_manager.py
```python
__author__ = 'ZGQ'
import sys
import requests
from uuid import uuid1
from time import strftime, sleep
sys.path.append("..")
from hackathon import Component, RequiredFeature, Context
from hackathon.hmongo.models import DockerHostServer, Hackathon
from hackathon.constants import (DockerPingResult, AVMStatus,
DockerHostServerStatus, DHS_QUERY_STATE,
ServiceDeploymentSlot, TCPProtocol,
EStatus)
from hackathon.hackathon_response import ok, not_found
__all__ = ["DockerHostManager"]
class DockerHostManager(Component):
"""Component to manage docker host server"""
docker = RequiredFeature("hosted_docker_proxy")
expr_manager = RequiredFeature("expr_manager")
def get_docker_hosts_list(self, hackathon):
"""
Get all host servers of a hackathon
:param hackathon_id: the id of this hackathon, on_success callback function
:type hackathon_id: integer
:return: a list of all docker hosts
:rtype: list
"""
host_servers = DockerHostServer.objects(hackathon=hackathon)
return [host_server.dic() for host_server in host_servers]
def get_available_docker_host(self, hackathon):
vms = DockerHostServer.objects.filter(__raw__={'$where': 'this.container_count+1 < this.container_max_count'}) \
.filter(hackathon=hackathon, state=DockerHostServerStatus.DOCKER_READY, disabled=False).all()
if self.util.is_local():
if len(vms) > 0:
return Context(state=DHS_QUERY_STATE.SUCCESS, docker_host_server=vms[0])
else:
return Context(state=DHS_QUERY_STATE.FAILED)
has_locked_host = False
for host in vms:
# check docker status
if not self.docker.ping(host):
host.state = DockerHostServerStatus.UNAVAILABLE
host.save()
continue
# cloud service locked?
if not self.is_host_server_locked(host):
return Context(state=DHS_QUERY_STATE.SUCCESS, docker_host_server=host)
else:
has_locked_host = True
if has_locked_host:
# still has available host but locked
return Context(state=DHS_QUERY_STATE.ONGOING)
elif self.start_new_docker_host_vm(hackathon):
# new VM is starting
return Context(state=DHS_QUERY_STATE.ONGOING)
else:
# no VM found or starting
return Context(state=DHS_QUERY_STATE.FAILED)
def is_host_server_locked(self, docker_host):
raise NotImplementedError()
def get_host_server_by_id(self, id_):
"""
Search host server in DB by id
:param id_: the id of host server in DB
:type id_: integer
:return: the found host server information in DB
:rtype: DockerHostServer object
"""
return DockerHostServer.objects(id=id_).first()
def schedule_pre_allocate_host_server_job(self):
"""
Schedule pre-allocate host server for every hackathon found in DB table:hackathon
"""
self.log.debug('Begin to check host server and prepare resource.')
min_avavilabe_container = 5
for hackathon in Hackathon.objects():
if self.__exist_request_host_server_by_hackathon_id(min_avavilabe_container, hackathon.id):
continue
if not self.start_new_docker_host_vm(hackathon):
self.log.error('Schedule pre-allocate host server for hackathon:%s failed.' % hackathon.name)
def start_new_docker_host_vm(self, hackathon):
"""
create docker host VM for hackathon whose id is hackathon_id
:param hackathon: hackathon
:type hackathon: Hackathon
:return: True if send an creating VM request via API successfully after validating storage, container and
service
Otherwise, False
:rtype: bool
"""
# todo debug this logic and make sure DON'T start two or more VM at the same time
return False
hackathon_id = hackathon.id
sms = self.__get_sms_object(hackathon_id)
if sms is None:
self.log.error('No account found for Hackathon:%d' % hackathon_id)
return False
# get storage and container
res, storage_account_name, container_name = self.__get_available_storage_account_and_container(hackathon_id)
if not res:
return False
# get service
res, service_name = self.__get_available_cloud_service(hackathon_id)
if not res:
return False
# set host_name to ensure its uniqueness
host_name = str(uuid1())[0:9] + strftime("%Y%m%d%H%M%S")
# set vm os image and hard disk storage
image_name_default = 'b549f4301d0b4295b8e76ceb65df47d4__Ubuntu-14_04-LTS-amd64-server-20140606.1-en-us-30GB'
image_name = self.util.safe_get_config('dockerhostserver.vm.image_name', image_name_default)
media_link = 'https://%s.blob.core.chinacloudapi.cn/%s/%s.vhd' % (storage_account_name, container_name,
host_name)
os_hd = OSVirtualHardDisk(image_name, media_link)
# set linux_config and endpoint_config
customdata = self.__get_customdata_from_local_file()
linux_config = LinuxConfigurationSet(host_name,
self.util.safe_get_config('dockerhostserver.vm.username', 'opentech'),
self.util.safe_get_config('dockerhostserver.vm.password', '<PASSWORD>!'),
False, custom_data=customdata)
endpoint_config = self.__set_endpoint_config(service_name, hackathon_id)
deployment_exist = True
deployment_slot = ServiceDeploymentSlot.PRODUCTION
try:
deployment_exist = self.__deployment_exists(service_name, deployment_slot, hackathon_id)
except Exception as e:
self.log.error(e)
return False
if not deployment_exist:
try:
result = sms.create_virtual_machine_deployment(service_name=service_name,
network_config=endpoint_config,
deployment_name=service_name,
deployment_slot=deployment_slot,
label=service_name,
role_name=host_name,
system_config=linux_config,
os_virtual_hard_disk=os_hd,
role_size=0)
self.log.debug('To create VM:%s in service:%s.(deployment)' % (host_name, service_name))
except Exception as e:
self.log.error(e)
return False
else:
try:
result = sms.add_role(service_name=service_name,
deployment_name=service_name,
role_name=host_name,
system_config=linux_config,
os_virtual_hard_disk=os_hd,
network_config=endpoint_config,
role_size=0)
self.log.debug('To create VM:%s in service:%s.(add role)' % (host_name, service_name))
except Exception as e:
self.log.error(e)
return False
# storage parameters in context
context = Context(hackathon_id=hackathon_id, request_id=result.request_id,
service_name=service_name, role_name=host_name,
deployment_name=service_name, deployment_slot=deployment_slot,
host_name=host_name)
# start schedule
self.sche.add_once('docker_host_manager', 'check_vm_status', context=context, minutes=5)
return True
def add_host_server(self, hackathon, args):
"""
create a docker host DB object for a hackathon and insert record into the database.
param-"args" contain all necessary infos to new a docker_host
:return: return True if succeed, otherwise return False
:rtype: bool
"""
host_server = DockerHostServer(vm_name=args.vm_name,
public_dns=args.public_dns,
public_ip=args.public_ip,
public_docker_api_port=args.public_docker_api_port,
private_ip=args.private_ip,
private_docker_api_port=args.private_docker_api_port,
container_count=0,
container_max_count=args.container_max_count,
is_auto=False,
disabled=args.get("disabled", False),
hackathon=hackathon)
if self.docker.ping(host_server):
host_server.state = DockerHostServerStatus.DOCKER_READY
else:
host_server.state = DockerHostServerStatus.UNAVAILABLE
host_server.save()
return host_server.dic()
def get_and_check_host_server(self, host_server_id):
"""
first get the docker host DB object for a hackathon,
and check whether the container_count is correct through "Docker Restful API",
if not, update this value in the database.
:param host_server_id: the id of host_server in DB
:type host_server_id: Integer
:return: A object of docker_host_server
:rtype: DockerHostServer object or None
"""
host_server = DockerHostServer.objects(id=host_server_id).first()
if host_server is None:
self.log.warn('get docker_host fail, not find host server by id:' + host_server_id)
return not_found("docker host server not found")
ping = self.docker.ping(host_server)
if not ping:
host_server.state = DockerHostServerStatus.UNAVAILABLE
host_server.save()
else:
try:
containers = self.docker.list_containers(host_server)
if len(containers) != host_server.container_count:
host_server.container_count = len(containers)
host_server.save()
except Exception as e:
self.log.error("Failed in sync container count")
self.log.error(e)
return self.__check_docker_host_server(host_server).dic()
def __check_docker_host_server(self, host_server):
ping = self.docker.ping(host_server)
if not ping:
host_server.state = DockerHostServerStatus.UNAVAILABLE
host_server.save()
else:
try:
containers = self.docker.list_containers(host_server)
if len(containers) != host_server.container_count:
host_server.container_count = len(containers)
host_server.save()
except Exception as e:
self.log.error("Failed in sync container count")
self.log.error(e)
return host_server
def update_host_server(self, args):
"""
update a docker host_server's information for a hackathon.
:param hackathon_id: the id of hackathon in DB
:type hackathon_id: Integer
:return: ok() if succeed.
not_found(...) if fail to update the docker_host's information
"""
vm = DockerHostServer.objects(id=args.id).first()
if vm is None:
self.log.warn('delete docker_host fail, not find hostserver_id:' + args.id)
return not_found("", "host_server not found")
vm.vm_name = args.get("vm_name", vm.vm_name)
vm.public_dns = args.get("public_dns", vm.public_dns)
vm.public_ip = args.get("public_ip", vm.public_ip)
vm.private_ip = args.get("private_ip", vm.private_ip)
vm.container_max_count = int(args.get("container_max_count", vm.container_max_count))
vm.public_docker_api_port = int(args.get("public_docker_api_port", vm.public_docker_api_port))
vm.private_docker_api_port = int(args.get("private_docker_api_port", vm.private_docker_api_port))
vm.disabled = args.get("disabled", vm.disabled)
if self.docker.ping(vm):
vm.state = DockerHostServerStatus.DOCKER_READY
else:
vm.state = DockerHostServerStatus.UNAVAILABLE
vm.save()
return self.__check_docker_host_server(vm).dic()
def delete_host_server(self, host_server_id):
"""
delete a docker host_server for a hackathon.
:param host_server_id: the id of host_server in DB
:type host_server_id: Integer
:return: ok() if succeeds or this host_server doesn't exist
precondition_failed() if there are still some containers running
"""
DockerHostServer.objects(id=host_server_id).delete()
return ok()
def check_vm_status(self, context):
raise NotImplementedError()
def get_hostserver_info(self, host_server_id):
"""
Get the infomation of a hostserver by host_server_id
:type host_server_id: int
:param host_server_id: the id of host_server
:rtype: dict
:return: the dict of host_server detail information
"""
host_server = self.db.find_first_object_by(DockerHostServer, id=host_server_id)
return host_server.dic()
def check_subscription_id(self, hackathon_id):
try:
sms = self.__get_sms_object(hackathon_id)
sms.list_hosted_services()
except Exception:
return False
return True
def __get_sms_object(self, hackathon_id):
raise NotImplementedError()
def __get_available_storage_account_and_container(self, hackathon_id):
raise NotImplementedError()
def __get_available_cloud_service(self, hackathon_id):
raise NotImplementedError()
def __get_customdata_from_local_file(self):
"""
Get customdata from local file
:return: content of file if successfully read, otherwise return None and VM will not do customization work.
:rtype: str|unicode
"""
sh_file = []
file_path = self.util.safe_get_config('dockerhostserver.vm.customdata',
'open-hackathon-server/customdata.sh')
try:
for line in open(file_path):
sh_file.append(line)
customdata = '\r\n'.join(sh_file)
return customdata
except Exception as e:
self.log.error('Encounter an error when reading customdata from local file')
self.log.error(e)
return None
def __get_used_public_port_set(self, service_name, hackathon_id):
raise NotImplementedError()
def __set_endpoint_config(self, service_name, hackathon_id):
raise NotImplementedError()
def __deployment_exists(self, service_name, deployment_slot, hackathon_id):
raise NotImplementedError()
def __exist_request_host_server_by_hackathon_id(self, request_count, hackathon_id):
"""
check whether there is a host server, belonging to a hackathon, that can hold a few more containers
:param request_count: the number of containers needed
:type request_count: integer
:param hackathon_id: the id of hackathon
:type hackathon_id: integer
:return: True if there exists one host server at least, otherwise False
:rtype: bool
"""
vms = self.db.find_all_objects(DockerHostServer,
DockerHostServer.container_count + request_count <=
DockerHostServer.container_max_count,
DockerHostServer.hackathon_id == hackathon_id,
DockerHostServer.state == DockerHostServerStatus.DOCKER_READY,
DockerHostServer.disabled == DockerHostServerDisable.ABLE)
return len(vms) > 0
```
#### File: hackathon/template/docker_template_unit.py
```python
from hackathon.template.template_constants import DOCKER_UNIT
from hackathon.template.template_unit import TemplateUnit
from hackathon.constants import VE_PROVIDER
__all__ = ["DockerTemplateUnit"]
DEPLOYMENT_TEMPLATE = """
apiVersion: apps/v1
kind: Deployment
metadata:
name: ohp-{{ expr_name }}
labels:
app.kubernetes.io/name: ohp-{{ expr_name }}
app.kubernetes.io/managed-by: ohp
spec:
replicas: 1
selector:
matchLabels:
app.kubernetes.io/name: ohp-{{ expr_name }}
app.kubernetes.io/managed-by: ohp
template:
metadata:
labels:
app.kubernetes.io/name: ohp-{{ expr_name }}
app.kubernetes.io/managed-by: ohp
spec:
containers:
- name: environment
image: {{ image }}
"""
SERVICE_TEMPLATE = """
apiVersion: v1
kind: Service
metadata:
name: ohp-{{ expr_name }}
spec:
selector:
app.kubernetes.io/name: ohp-{{ expr_name }}
app.kubernetes.io/managed-by: ohp
ports:
{{ ports }}
type: NodePort
"""
PORT_TEMPLATE = """
- protocol: TCP
name: {{ name }}
port: {{ port }}
"""
class DockerTemplateUnit(TemplateUnit):
"""
Smallest unit in docker template
"""
def __init__(self, config):
super(DockerTemplateUnit, self).__init__(VE_PROVIDER.DOCKER)
self.image = DOCKER_UNIT.IMAGE
net_configs = config.get(DOCKER_UNIT.NET_CONFIG, [])
self.network_configs = [{
DOCKER_UNIT.NET_NAME: cfg[DOCKER_UNIT.NET_NAME],
DOCKER_UNIT.NET_PORT: cfg[DOCKER_UNIT.NET_PORT],
DOCKER_UNIT.NET_PROTOCOL: cfg[DOCKER_UNIT.NET_PROTOCOL],
} for cfg in net_configs]
def gen_k8s_yaml(self, expr_name):
ports = []
for cfg in self.network_configs:
ports.append(PORT_TEMPLATE.format(**cfg))
svc = ""
if ports:
svc = SERVICE_TEMPLATE.format(expr_name=expr_name, ports="\n".join(ports))
deploy = DEPLOYMENT_TEMPLATE.format(expr_name=expr_name, image=self.image)
return "{}\n---\n{}\n".format(deploy, svc)
```
#### File: hackathon/user/user_profile_manager.py
```python
import sys
sys.path.append("..")
from flask import g
from hackathon.hmongo.models import User, UserProfile
from hackathon.hackathon_response import internal_server_error, not_found
from hackathon import Component
__all__ = ["UserProfileManager"]
class UserProfileManager(Component):
"""Component to manager user profile"""
def get_user_profile(self, user_id):
user = User.objects.get(id=user_id)
if not user:
return not_found("user {} not found".format(user_id))
profile = User.objects.get(id=user_id).profile
if profile:
return user.dic()
# if user do not create profile, create default
user.profile = UserProfile()
user.save()
return user.dic()
def create_user_profile(self, args):
self.log.debug("create_user_profile: %r" % args)
try:
u_id = g.user.id
user = User.objects.get(id=u_id)
user.profile = UserProfile(**args)
user.save()
return user.dic()
except Exception as e:
self.log.debug(e)
return internal_server_error("failed to create user profile")
def update_user_profile(self, args):
self.log.debug("update_user_profile")
try:
u_id = args["user_id"]
user = User.objects.get(id=u_id)
user.profile = UserProfile(**args)
user.save()
return user.dic()
except Exception as e:
self.log.debug(e)
return internal_server_error("failed to update user profile")
```
#### File: tests/apitest/test_user_api.py
```python
from . import ApiTestCase
from hackathon.constants import HACK_NOTICE_EVENT, HACK_NOTICE_CATEGORY
from hackathon.hmongo.models import HackathonNotice
USER_ONE_USERNAME = "test_one"
USER_ONE_ENCODE_PASSWORD = '<PASSWORD>'
class TestUserLoginApi(ApiTestCase):
def test_login(self, user1):
# test login by DB
data = {
"provider": "db",
"username": USER_ONE_USERNAME,
"password": <PASSWORD>,
"code": "test-only"
}
payload = self.client.post("/api/user/login", json_data=data)
user_info = payload['user']
assert user_info['id'], user1.id
data = {
"provider": "db",
"username": "user_one_not_found",
"password": <PASSWORD>,
"code": "test-only"
}
payload = self.client.post("/api/user/login", json_data=data)
assert "error" in payload
# todo add sso test when support authing
def test_logout(self, user1):
# do login
self.login(user1)
# get user profile
payload = self.client.get("/api/user/profile")
assert payload["id"] == str(user1.id)
# do logout
payload = self.client.delete("/api/user/login")
assert payload['code'] == 200
# get user profile failed
payload = self.client.get("/api/user/profile")
assert "error" in payload and payload["error"]["code"] == 401
class TestUserInfoApi(ApiTestCase):
def test_get_user_profile(self, user1):
self.login(user1)
payload = self.client.get("/api/user/profile")
assert payload["id"] == str(user1.id)
def test_update_user_picture(self, user1):
self.login(user1)
data = {"url": "http://www.new-url.com/pic.jpg"}
payload = self.client.put("/api/user/picture", json_data=data)
# fixme api response is too arbitrary
assert payload
def test_read_user_notice(self, user1):
self.login(user1)
# init new unread msg
hackathon_notice = HackathonNotice(
content='',
link='',
event=HACK_NOTICE_EVENT.HACK_CREATE,
category=HACK_NOTICE_CATEGORY.HACKATHON,
receiver=user1,
creator=user1,
)
hackathon_notice.save()
assert not hackathon_notice.is_read
# test read msg
payload = self.client.put("/api/user/notice/read", json_data=dict(id=str(hackathon_notice.id)))
assert payload['code'] == 200
hackathon_notice = HackathonNotice.objects(id=str(hackathon_notice.id)).first()
assert hackathon_notice.is_read
class TestUserFile(ApiTestCase):
def test_user_upload_files(self):
# TODO test for upload files
pass
class TestTalents(ApiTestCase):
def test_get_talents(self, user1):
payload = self.client.get("/api/talent/list")
assert len(payload) == 1 and payload[0]['id'] == str(user1.id)
``` |
{
"source": "99Kies/web3.py",
"score": 2
} |
#### File: web3.py/web3/version.py
```python
from typing import (
Callable,
NoReturn,
)
from web3._utils.rpc_abi import (
RPC,
)
from web3.method import (
Method,
)
from web3.module import (
Module,
ModuleV2,
)
class BaseVersion(ModuleV2):
retrieve_caller_fn = None
_get_node_version: Method[Callable[[], str]] = Method(RPC.web3_clientVersion)
_get_protocol_version: Method[Callable[[], str]] = Method(RPC.eth_protocolVersion)
@property
def api(self) -> str:
from web3 import __version__
return __version__
class AsyncVersion(BaseVersion):
is_async = True
@property
async def node(self) -> str:
# types ignored b/c mypy conflict with BlockingVersion properties
return await self._get_node_version() # type: ignore
@property
async def ethereum(self) -> int:
return await self._get_protocol_version() # type: ignore
class BlockingVersion(BaseVersion):
@property
def node(self) -> str:
return self._get_node_version()
@property
def ethereum(self) -> str:
return self._get_protocol_version()
class Version(Module):
@property
def api(self) -> NoReturn:
raise DeprecationWarning(
"This method has been deprecated ... Please use web3.api instead."
)
@property
def node(self) -> NoReturn:
raise DeprecationWarning(
"This method has been deprecated ... Please use web3.clientVersion instead."
)
@property
def ethereum(self) -> NoReturn:
raise DeprecationWarning(
"This method has been deprecated ... Please use web3.eth.protocol_version instead."
)
``` |
{
"source": "99linesofcode/playground-flask",
"score": 2
} |
#### File: app/controllers/main.py
```python
from flask import Blueprint, render_template, flash, request, redirect, url_for
blueprint = Blueprint('api', __name__)
@blueprint.route('/')
def home():
return "Hello"
```
#### File: back/app/__init__.py
```python
from flask import Flask
from app.controllers.main import blueprint as api
def create_app():
app = Flask(__name__, static_folder='static', template_folder='templates')
# register blueprints
app.register_blueprint(api, url_prefix='/api')
return app
``` |
{
"source": "99sbr/TextSummarisation",
"score": 2
} |
#### File: TextSummarisation/apis/ns_SimilaritySummarizer.py
```python
from flask_restplus import Namespace, Resource, fields
from core.utility import Utility
from werkzeug.datastructures import FileStorage
import uuid , os
from textblob import TextBlob
utils = Utility()
api = Namespace('SimilaritySummarizer',
description='Sentence Similarity based text summarizer')
upload_parser = api.parser()
upload_parser.add_argument('file', location='files',
type=FileStorage, required=True, help= 'text file')
@api.route('/upload/')
@api.expect(upload_parser)
class SummarizerSimilarity(Resource):
@api.response(200, 'Success')
@api.response(404, 'Validation Error')
def post(self):
try:
args = upload_parser.parse_args()
uploaded_file = args['file']
filepath = os.path.join('FileStorage',str(uuid.uuid4())+'.txt')
uploaded_file.save(filepath)
result = utils.generate_summary(filepath)
testimonial = TextBlob(result)
polarity = testimonial.sentiment.polarity
return {'SentimentPolarity':polarity, 'Summary':result}
except:
api.abort(404)
``` |
{
"source": "99scratch/allthevhosts",
"score": 3
} |
#### File: 99scratch/allthevhosts/allthevhosts.py
```python
import urllib2
import sys
import re
import json
import socket
import ssl
from HTMLParser import HTMLParser
from bs4 import BeautifulSoup
ca_certs="/etc/ssl/certs/ca-certificates.crt"
try:
ip=sys.argv[1]
except:
print "[E] I need an address you twat."
sys.exit(1)
## URLs that searches claim to be on the same IP
matches=[]
## URLs which resolve to the same IP as the original
vhosts=[]
def bing():
print "[-] searching bing...",
try:
search = urllib2.urlopen("http://www.bing.com/search?q=IP%3A"+ip+"&go=&qs=n&form=QBRE").read()
except:
print "\r[E]Bing search error",
soup = BeautifulSoup(search)
for url in soup.find_all('cite'):
try:
tld=re.sub('\/.*','',url.string)
if tld not in matches:
matches.append(tld)
except:
pass
print "\r[+] bing search complete"
def myipneighbours():
print "[-] searching myipneighbours...",
try:
search = urllib2.urlopen("http://www.my-ip-neighbors.com/?domain="+ip).read()
soup = BeautifulSoup(search)
for url in soup.find_all('td'):
try:
if url.attrs and str(url.attrs['class'])=="['domain']" and url.string not in matches:
matches.append(url.string)
except:
pass
print "\r[+] myipneighbours Search Complete"
except:
print "\r[E] myipneighbours search error"
def ipneighbour():
try:
print "[-] Searching ipneighbour...",
search = urllib2.urlopen("http://www.ipneighbour.com/", "domainName="+ip+"&submit=").read()
soup = BeautifulSoup(search)
for url in soup.find_all('a'):
try:
if url.attrs and str(url.attrs['target'])=='_blank' and url.attrs['href'].replace('http://','') not in matches:
matches.append(url.attrs['href'].replace('http://',''))
except:
pass
print "\r[+] ipneighbour Search Complete"
except:
print "\r[E]ipneighbour search error"
def yougetsignal():
print "[-] searching yougetsignal...",
req = urllib2.Request(url='http://www.yougetsignal.com/tools/web-sites-on-web-server/php/get-web-sites-on-web-server-json-data.php',data='remoteAddress='+ip+'&key=')
req.add_header('Referer', 'http://www.yougetsignal.com/tools/web-sites-on-web-server/')
req.add_header('User-Agent', 'firefox')
search = urllib2.urlopen(req)
results = json.load(search)
try:
for url in results['domainArray']:
if url[0] not in matches:
matches.append(url[0])
print "\r[+] yougetsignal Search Complete"
except:
print "\r[E] yougetsignal search error - probably just hit the limit for this IP"
def san():
print "[-] using Subject Alternate Names...",
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ssl_sock = ssl.wrap_socket(s, ca_certs=ca_certs, cert_reqs=ssl.CERT_REQUIRED)
ssl_sock.connect((ip, 443))
CERT = ssl_sock.getpeercert()
ssl_sock.close()
for type,url in CERT['subjectAltName']:
if url not in matches:
matches.append(url)
print "\r[+] SAN enumeration complete."
except:
"\r[E] Looks like there's no SSL"
def verifyresults():
print "[-] resolving original address...",
try:
socket.inet_aton(ip)
realip=ip
except socket.error:
realip = socket.gethostbyname(ip)
print "\r[+] resolved original address"
num=str(len(matches))
print "[+] verifying that "+num+" found URLs resolve to the same address"
i=1
if hasattr(socket, 'setdefaulttimeout'):
socket.setdefaulttimeout(5)
for url in matches:
try:
print "\r[-] resolving URL "+str(i)+" of "+num,
testip = socket.gethostbyname(url)
i=i+1
if realip==testip:
vhosts.append(url)
except:
i=i+1
print "\r[+] all URLs resolved\n"
def fileoutput():
try:
outfile = sys.argv[2]
f = open(outfile,'w')
for url in vhosts:
f.write(url+"\n")
f.close()
except:
for url in vhosts:
print url
bing()
myipneighbours()
ipneighbour()
yougetsignal()
san()
verifyresults()
fileoutput()
``` |
{
"source": "99stealth/aws-profile-manager",
"score": 2
} |
#### File: aws-profile-manager/aws_profile_manager/cli.py
```python
import os
import sys
import click
import logging
def setup_logging(quiet: bool, verbose: bool):
''' Function is setting logging configuration '''
if verbose:
logging_level = logging.INFO
elif quiet:
logging_level = logging.ERROR
else:
logging_level = logging.WARNING
logging.basicConfig(format='%(message)s', level=logging_level)
plugin_folder = os.path.join(os.path.dirname(__file__), 'commands')
class MyCLI(click.MultiCommand):
def list_commands(self, ctx):
rv = []
for filename in os.listdir(plugin_folder):
if filename.startswith('_'):
continue
if filename.endswith('.py'):
rv.append(filename[:-3])
rv.sort()
return rv
def get_command(self, ctx, name):
ns = {}
fn = os.path.join(plugin_folder, name + '.py')
with open(fn) as f:
code = compile(f.read(), fn, 'exec')
eval(code, ns, ns)
return ns['cli']
cli = MyCLI(help='This tool\'s subcommands are loaded from a '
'plugin folder dynamically.')
if __name__ == '__main__':
try:
setup_logging(quiet=False, verbose=False)
cli()
except KeyboardInterrupt:
logging.error("\nProcess has been stopped. Interrupted by user")
sys.exit(1)
```
#### File: aws_profile_manager/commands/profile-remove.py
```python
import sys
import click
import logging
from aws_profile_manager import Common, Remove
@click.command()
@click.option('--aws-profile-name', required=False, help="AWS profile to remove", type=str)
def cli(aws_profile_name):
""" Removes AWS profile from your ~/.aws/credentials """
common = Common()
remove = Remove()
users_home = common.get_users_home()
all_profiles = common.get_all_profiles(users_home)
if not aws_profile_name:
aws_profile_name = remove.choose_profile_to_remove(all_profiles)
try:
while True:
answer = input("Profile [{}] will be removed. Are you sure you want to proceed? [Y/n] ".format(aws_profile_name))
if answer.lower() == "yes" or answer.lower() == "y":
del all_profiles[aws_profile_name]
logging.info("Profile {} has been successfuly removed from {}/.aws/credentials".format(aws_profile_name, users_home))
break
elif answer.lower() == "no" or answer.lower() == "n":
break
else:
print("Yes or No?")
except KeyError as e:
logging.error("Looks like profile {} does not exist in {}/.aws/credentials".format(e, users_home))
sys.exit(1)
common.rewrite_credentials_file(all_profiles, users_home)
```
#### File: aws_profile_manager/common/common.py
```python
import sys
import re
from os.path import expanduser
from typing import Dict
import configparser
class Common:
def get_users_home(self) -> str:
""" Function returns user's home path """
return expanduser("~")
def get_all_profiles(self, users_home: str) -> Dict:
""" Function receive user's home and parses file .aws/credentials.
It returns all aws profiles and their credentials in dictionary """
profiles = {}
config = configparser.ConfigParser()
config.read('{}/.aws/credentials'.format(users_home))
sections = config.sections()
for section in sections:
section_items = {}
for key in config[section]:
section_items[key] = config[section][key]
profiles[section] = section_items
return profiles
def generate_new_profile_list(self, profiles: Dict, new_default: str) -> Dict:
""" Function receives list of profiles and name of new default.
Function returns regenerated list of profiles with new default """
new_profile_list = {"default": {}}
for item in profiles[new_default]:
new_profile_list["default"][item] = profiles[new_default][item]
profiles.pop('default', None)
for item in profiles:
new_profile_list[item] = profiles[item]
return new_profile_list
def rewrite_credentials_file(self, new_profiles_list: Dict, users_home: str):
""" Function receives new_profile_list and users_home.
Function revrites credentials file with updated profiles """
config = configparser.ConfigParser()
for profile in new_profiles_list:
config[profile] = new_profiles_list[profile]
config.write(open('{}/.aws/credentials'.format(users_home), 'w'))
def aws_access_key_id_is_valid(self, aws_access_key_id):
''' The method receives the string with AWS Access Key ID and checks if
it is valid. If everything is in order it will return True otherwise
it returns False '''
if re.match('^AK[A-Z0-9]{18}$', aws_access_key_id):
return True
return False
def aws_secret_access_key_is_valid(self, aws_secret_access_key):
''' The method receives the string with AWS Secret Access Key and
checks if it is valid. If everything is in order it will return True
otherwise it returns False '''
if re.match('^[A-Za-z0-9+=/]{40}$', aws_secret_access_key):
return True
return False
``` |
{
"source": "99stealth/aws-profile-switcher",
"score": 3
} |
#### File: aws_profile_manager/commands/rotate-keys.py
```python
import sys
import click
import logging
from aws_profile_manager import Common, Rotate
@click.command()
@click.option('--aws-profile-name', required=False, help="AWS profile to rotate keys", type=str)
@click.option('--yes', is_flag=True, required=False, help="Confirm that you agree to rotate keys. Avoids manual confirmation", default=False, type=bool)
def cli(aws_profile_name, yes):
""" Rotate keys for defined profile ~/.aws/credentials """
common = Common()
users_home = common.get_users_home()
all_profiles = common.get_all_profiles(users_home)
if not aws_profile_name:
aws_profile_name = common.choose_profile(all_profiles, operation="rotate")
access_key_id = all_profiles.get(aws_profile_name).get('aws_access_key_id')
rotate = Rotate()
current_access_keys = rotate.get_access_keys()
if len(current_access_keys) > 1:
logging.warning('There is more than one access key is created for the current user. '
f'One (which is not used in profile [{aws_profile_name}]) should be deleted. '
'Otherwise, it is not possible to make a credentials rotation')
for _ak in current_access_keys:
if _ak != access_key_id:
while True:
if yes:
answer = 'yes'
else:
_ak_last_used = rotate.get_access_key_last_used(_ak)
answer = input(f"\nAccess key {_ak} (last used: {_ak_last_used['LastUsedDate'] if 'LastUsedDate' in _ak_last_used else 'N/A'}) will be deleted. Do you agree with that? [Y/n] ")
if answer.lower() == "yes" or answer.lower() == "y":
rotate.delete_access_key(access_key_id=_ak)
break
elif answer.lower() == "no" or answer.lower() == "n":
print('Exit...')
sys.exit(1)
else:
print("Yes or No?")
aws_access_key_id, aws_secret_access_key = rotate.create_access_key()
if aws_access_key_id and aws_secret_access_key:
rotate.delete_access_key(access_key_id=access_key_id)
all_profiles[aws_profile_name]['aws_access_key_id'] = aws_access_key_id
all_profiles[aws_profile_name]['aws_secret_access_key'] = aws_secret_access_key
common.rewrite_credentials_file(all_profiles, users_home)
```
#### File: aws_profile_manager/tests/common.py
```python
import unittest
from aws_profile_manager import Common
class TestCommon(unittest.TestCase):
def setUp(self):
self.common = Common()
def test_generate_new_profile_list(self):
test_data = {
'default':
{
'aws_access_key_id': '<KEY>',
'aws_secret_access_key': '<KEY>'
},
'test1':
{
'aws_access_key_id': 'AKIAZZZZZZZZZZZZZZZZ',
'aws_secret_access_key': 'zZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZ'}
}
expected_output = {
'default':
{
'aws_access_key_id': 'AKIAZZZZZZZZZZZZZZZZ',
'aws_secret_access_key': 'zZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZ'
},
'test1':
{
'aws_access_key_id': 'AKIAZZZZZZZZZZZZZZZZ',
'aws_secret_access_key': 'zZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZ'
}
}
self.assertDictEqual(self.common.generate_new_profile_list(test_data, 'test1'), expected_output)
def test_aws_access_key_id_with_valid_value(self):
self.assertTrue(self.common.aws_access_key_id_is_valid('<KEY>'))
def test_aws_access_key_id_with_invalid_value(self):
self.assertFalse(self.common.aws_access_key_id_is_valid('<KEY>'))
def test_aws_secret_access_key_with_valid_value(self):
self.assertTrue(self.common.aws_secret_access_key_is_valid('<KEY>'))
def test_aws_secret_access_key_with_invalid_value(self):
self.assertFalse(self.common.aws_secret_access_key_is_valid('0ZzzZZzZZz0zZ'))
if __name__ == '__main__':
unittest.main()
``` |
{
"source": "99stealth/simple-infrastructure",
"score": 3
} |
#### File: simple-infrastructure/.travis_scripts/deploy_network.py
```python
from time import sleep
import boto3
from botocore.exceptions import ClientError
from argparse import ArgumentParser
def stack_exists(client, stack_name):
""" Checks that stack was specified is existing """
cfn_stacks = client.list_stacks()
for cfn_stack in cfn_stacks["StackSummaries"]:
if cfn_stack['StackName'] == stack_name and "COMPLETE" in cfn_stack['StackStatus'] and "DELETE" not in cfn_stack['StackStatus']:
return True
return False
def follow_cfn_stack(client, stack_name, try_timeout):
""" Listens for Success status while CFn stack is creating or updating"""
while True:
cfn_stacks = client.describe_stacks(StackName=stack_name)
for stack in cfn_stacks["Stacks"]:
if "IN_PROGRESS" in stack["StackStatus"] and "ROLLBACK" not in stack["StackStatus"] and "DELETE" not in stack["StackStatus"]:
print ("Current stack status: {0}. Waiting {1} seconds".format(stack["StackStatus"], try_timeout))
sleep(try_timeout)
elif "COMPLETE" in stack["StackStatus"] and "DELETE" not in stack["StackStatus"]:
print ("Stack {0}".format(stack["StackStatus"]))
return True
else:
print ("Current stack is {0}. Exit with error".format(stack["StackStatus"]))
return False
def stack_operations(client, stack_name, template, try_timeout, operation):
""" Creates or updates CFn stack with received parameters """
if operation == "create":
try:
with open(template, 'r') as cfn_template:
client.create_stack(StackName=stack_name,
TemplateBody=cfn_template.read(),
)
except ClientError as e:
print ("[Skipping stack create] {0}".format(e))
if not follow_cfn_stack(client, stack_name, try_timeout):
exit(1)
elif operation == "update":
with open(template, 'r') as cfn_template:
try:
client.update_stack(StackName=stack_name,
TemplateBody=cfn_template.read(),
)
except ClientError as e:
print ("[Skipping stack update] {0}".format(e))
if not follow_cfn_stack(client, stack_name, try_timeout):
exit(1)
else:
print("Unknown operation {0}".format(operation))
exit(1)
def get_arguments():
""" Gets parameters from command line """
parser = ArgumentParser(description='Check stack exists')
parser.add_argument('--stack-name', help='CFn stack name', required=True)
parser.add_argument('--template', help='CloudFormation template', required=True)
parser.add_argument('--try-timeout', help='Timeouts between tries', default=15)
return parser.parse_args()
def main():
""" main function which receives arguments, calls AWS client and runs update or create CFn stack """
args = get_arguments()
client = boto3.client('cloudformation')
if stack_exists(client, args.stack_name):
stack_operations(
client,
args.stack_name,
args.template,
args.try_timeout,
operation="update")
else:
stack_operations(
client,
args.stack_name,
args.template,
args.try_timeout,
operation="create")
if __name__ == "__main__":
main()
``` |
{
"source": "99wanglin/d2w_mini_projects",
"score": 4
} |
#### File: mp_calc/app/serverlibrary.py
```python
def merge(array, p, q, r, byfunc):
# print('merging')
nleft = q - p + 1
nright = r - q
left_array = array[p:q+1]
right_array = array[(q+1):r+1]
left = 0
right = 0
dest = p
while left < nleft and right < nright:
if byfunc(left_array[left]) <= byfunc(right_array[right]):
array[dest] = left_array[left]
left += 1
else:
array[dest] = right_array[right]
right += 1
dest += 1
while left < nleft:
array[dest] = left_array[left]
left += 1
dest += 1
while right < nright:
array[dest] = right_array[right]
right += 1
dest += 1
# print('stop merging')
def mergesort_recursive(array, p, r,byfunc):
q = (r+p)//2
if r-p <= 1:
# print('r', r)
# print('p', p)
merge(array, p, q, r, byfunc)
# print('done')
return
else:
mergesort_recursive(array, p, q, byfunc)
# print('p', p)
# print('q', q+1)
# print('r', r)
mergesort_recursive(array, q+1, r, byfunc)
# print('doing')
merge(array, p, q, r, byfunc)
def mergesort(array, byfunc=None):
if len(array) == 1:
return
mergesort_recursive(array, 0, len(array)-1, byfunc)
class Stack:
def __init__(self):
self.__items = []
def push(self, item):
self.__items.append(item)
def pop(self):
if self.is_empty:
return None
else:
item = self.__items[-1]
del self.__items[-1]
return item
def peek(self):
if self.is_empty:
return None
else:
return self.__items[-1]
@property
def is_empty(self):
if self.__items == []:
return True
else:
return False
@property
def size(self):
return len(self.__items)
class Queue:
def __init__(self):
self.left_stack = Stack()
self.right_stack = Stack()
@property
def is_empty(self):
return self.right_stack.is_empty
@property
def size(self):
return self.right_stack.size
def enqueue(self, item, side):
if side == 'left':
self.left_stack.push(item)
else:
self.right_stack.push(item)
def dequeue(self, side):
if side == 'left':
item = self.left_stack.pop()
else:
item = self.right_stack.pop()
return item
def peek(self):
return self.right_stack.peek()
class EvaluateExpression:
valid_char = '0123456789+-*/() '
operators = '*/-+()'
operand = '0123456789'
def __init__(self, string=""):
self.expression = string
@property
def expression(self):
return self._expression
@expression.setter
def expression(self, new_expr):
for val in new_expr:
if val not in self.valid_char:
self._expression = ''
return
else:
self._expression = new_expr
def insert_space(self):
temp = ''
for i, val in enumerate(self._expression):
if val in self.operators:
temp = temp + ' ' + val + ' '
else:
temp += val
return temp
def applyop(self, opr, val1, val2):
val1 = int(val1)
val2 = int(val2)
if opr == '+':
return val1 + val2
if opr == '-':
return val1 - val2
if opr == '*':
return val1 * val2
if opr == '/':
return val1 // val2
def process_operator(self, operand_stack, operator_stack):
right = operand_stack.pop()
left = operand_stack.pop()
opr = operator_stack.pop()
result = self.applyop(opr, left, right)
operand_stack.push(result)
def evaluate(self):
operand_stack = Stack()
operator_stack = Stack()
expression = self.insert_space()
tokens = expression.split()
n = len(self.expression)
i = 0
while i < n:
val = self.expression[i]
if val in self.operand:
number = ''
j = i
while j < n and '0' <= self.expression[j] <= '9':
number += self.expression[j]
j += 1
i = j-1
operand_stack.push(number)
elif val in '+-':
while not operator_stack.is_empty and \
operator_stack._Stack__items[-1] not in '()':
self.process_operator(operand_stack, operator_stack)
operator_stack.push(val)
elif val in '*/':
while not operator_stack.is_empty and \
operator_stack._Stack__items[-1] in '*/':
self.process_operator(operand_stack, operator_stack)
operator_stack.push(val)
elif val == '(':
operator_stack.push('(')
elif val == ')':
while operator_stack._Stack__items[-1] != '(':
self.process_operator(operand_stack, operator_stack)
operator_stack.pop()
i += 1
while not operator_stack.is_empty:
self.process_operator(operand_stack, operator_stack)
return round(operand_stack.pop(), 2)
def get_smallest_three(challenge):
records = challenge.records
times = [r for r in records]
mergesort(times, lambda x: x.elapsed_time)
return times[:3]
``` |
{
"source": "9a4gl/hass-peltec",
"score": 2
} |
#### File: custom_components/centrometal_boiler/config_flow.py
```python
from collections import OrderedDict
import logging
from centrometal_web_boiler import WebBoilerClient
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_EMAIL, CONF_ID, CONF_PASSWORD, CONF_PREFIX
from .const import DOMAIN
_LOGGER = logging.getLogger(__name__)
# pylint: disable=missing-function-docstring
# pylint: disable=broad-except
class CentrometalBoilerConfigFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Centrometal boiler."""
VERSION = 1
CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_PUSH
async def _show_setup_form(self, errors=None):
"""Show the setup form to the user."""
errors = {}
fields = OrderedDict()
fields[vol.Required(CONF_EMAIL)] = str
fields[vol.Required(CONF_PASSWORD)] = str
fields[vol.Optional(CONF_PREFIX)] = str
return self.async_show_form(
step_id="user", data_schema=vol.Schema(fields), errors=errors
)
async def async_step_user(self, user_input=None):
"""Handle the initial step."""
if user_input is None:
return await self._show_setup_form()
errors = {}
deviceCollection = None
try:
deviceCollection = await try_connection(
user_input[CONF_EMAIL], user_input[CONF_PASSWORD]
)
except Exception:
_LOGGER.exception("Unexpected exception " + user_input[CONF_EMAIL])
errors["base"] = "unknown"
return await self._show_setup_form(errors)
unique_id = user_input[CONF_EMAIL]
await self.async_set_unique_id(unique_id)
self._abort_if_unique_id_configured()
device = list(deviceCollection.values())[0]
title = device["product"] + ": " + device["address"] + ", " + device["place"]
return self.async_create_entry(
title=title,
data={
CONF_ID: unique_id,
CONF_EMAIL: user_input[CONF_EMAIL],
CONF_PASSWORD: user_input[CONF_PASSWORD],
CONF_PREFIX: user_input.get(CONF_PREFIX, ""),
},
)
async def try_connection(email, password):
_LOGGER.debug(
f"Trying to connect to Centrometal boiler server during setup {email}"
)
web_boiler_client = WebBoilerClient()
loggedIn = await web_boiler_client.login(username=email, password=password)
if not loggedIn:
raise Exception(f"Login to Centrometal boiler server failed {email}")
gotConfiguration = await web_boiler_client.get_configuration()
if not gotConfiguration:
raise Exception(
f"Getting devices from Centrometal boiler server failed {email}"
)
if len(web_boiler_client.data) == 0:
raise Exception(f"No device found on Centrometal boiler server {email}")
await web_boiler_client.close_websocket()
await web_boiler_client.http_client.close_session()
_LOGGER.debug(f"Successfully connected to Centrometal boiler during setup {email}")
return web_boiler_client.data
``` |
{
"source": "9A9A/wpa_supplicant-fork",
"score": 2
} |
#### File: tests/hwsim/test_mbo.py
```python
import logging
logger = logging.getLogger()
import hostapd
import os
import time
from tshark import run_tshark
def test_mbo_assoc_disallow(dev, apdev, params):
hapd1 = hostapd.add_ap(apdev[0], { "ssid": "MBO", "mbo": "1" })
hapd2 = hostapd.add_ap(apdev[1], { "ssid": "MBO", "mbo": "1" })
logger.debug("Set mbo_assoc_disallow with invalid value")
if "FAIL" not in hapd1.request("SET mbo_assoc_disallow 2"):
raise Exception("Set mbo_assoc_disallow for AP1 succeeded unexpectedly with value 2")
logger.debug("Disallow associations to AP1 and allow association to AP2")
if "OK" not in hapd1.request("SET mbo_assoc_disallow 1"):
raise Exception("Failed to set mbo_assoc_disallow for AP1")
if "OK" not in hapd2.request("SET mbo_assoc_disallow 0"):
raise Exception("Failed to set mbo_assoc_disallow for AP2")
dev[0].connect("MBO", key_mgmt="NONE", scan_freq="2412")
out = run_tshark(os.path.join(params['logdir'], "hwsim0.pcapng"),
"wlan.fc.type == 0 && wlan.fc.type_subtype == 0x00",
wait=False)
if "Destination address: " + hapd1.own_addr() in out:
raise Exception("Association request sent to disallowed AP")
timestamp = run_tshark(os.path.join(params['logdir'], "hwsim0.pcapng"),
"wlan.fc.type_subtype == 0x00",
display=['frame.time'], wait=False)
logger.debug("Allow associations to AP1 and disallow assications to AP2")
if "OK" not in hapd1.request("SET mbo_assoc_disallow 0"):
raise Exception("Failed to set mbo_assoc_disallow for AP1")
if "OK" not in hapd2.request("SET mbo_assoc_disallow 1"):
raise Exception("Failed to set mbo_assoc_disallow for AP2")
dev[0].request("DISCONNECT")
dev[0].wait_disconnected()
# Force new scan, so the assoc_disallowed indication is updated */
dev[0].request("FLUSH")
dev[0].connect("MBO", key_mgmt="NONE", scan_freq="2412")
filter = 'wlan.fc.type == 0 && wlan.fc.type_subtype == 0x00 && frame.time > "' + timestamp.rstrip() + '"'
out = run_tshark(os.path.join(params['logdir'], "hwsim0.pcapng"),
filter, wait=False)
if "Destination address: " + hapd2.own_addr() in out:
raise Exception("Association request sent to disallowed AP 2")
def test_mbo_cell_capa_update(dev, apdev):
"""MBO cellular data capability update"""
ssid = "test-wnm-mbo"
params = { 'ssid': ssid, 'mbo': '1' }
hapd = hostapd.add_ap(apdev[0], params)
bssid = apdev[0]['bssid']
if "OK" not in dev[0].request("SET mbo_cell_capa 1"):
raise Exception("Failed to set STA as cellular data capable")
dev[0].connect(ssid, key_mgmt="NONE", scan_freq="2412")
addr = dev[0].own_addr()
sta = hapd.get_sta(addr)
if 'mbo_cell_capa' not in sta or sta['mbo_cell_capa'] != '1':
raise Exception("mbo_cell_capa missing after association")
if "OK" not in dev[0].request("SET mbo_cell_capa 3"):
raise Exception("Failed to set STA as cellular data not-capable")
time.sleep(0.2)
sta = hapd.get_sta(addr)
if 'mbo_cell_capa' not in sta:
raise Exception("mbo_cell_capa missing after update")
if sta['mbo_cell_capa'] != '3':
raise Exception("mbo_cell_capa not updated properly")
def test_mbo_cell_capa_update_pmf(dev, apdev):
"""MBO cellular data capability update with PMF required"""
ssid = "test-wnm-mbo"
passphrase = "<PASSWORD>"
params = hostapd.wpa2_params(ssid=ssid, passphrase=<PASSWORD>)
params["wpa_key_mgmt"] = "WPA-PSK-SHA256";
params["ieee80211w"] = "2";
params['mbo'] = '1'
hapd = hostapd.add_ap(apdev[0], params)
bssid = apdev[0]['bssid']
if "OK" not in dev[0].request("SET mbo_cell_capa 1"):
raise Exception("Failed to set STA as cellular data capable")
dev[0].connect(ssid, psk=passphrase, key_mgmt="WPA-PSK-SHA256",
proto="WPA2", ieee80211w="2", scan_freq="2412")
addr = dev[0].own_addr()
sta = hapd.get_sta(addr)
if 'mbo_cell_capa' not in sta or sta['mbo_cell_capa'] != '1':
raise Exception("mbo_cell_capa missing after association")
if "OK" not in dev[0].request("SET mbo_cell_capa 3"):
raise Exception("Failed to set STA as cellular data not-capable")
time.sleep(0.2)
sta = hapd.get_sta(addr)
if 'mbo_cell_capa' not in sta:
raise Exception("mbo_cell_capa missing after update")
if sta['mbo_cell_capa'] != '3':
raise Exception("mbo_cell_capa not updated properly")
def test_mbo_non_pref_chan(dev, apdev):
"""MBO non-preferred channel list"""
ssid = "test-wnm-mbo"
params = { 'ssid': ssid, 'mbo': '1' }
hapd = hostapd.add_ap(apdev[0], params)
bssid = apdev[0]['bssid']
if "OK" not in dev[0].request("SET non_pref_chan 81:7:200:3"):
raise Exception("Failed to set non-preferred channel list")
if "OK" not in dev[0].request("SET non_pref_chan 81:7:200:1:123 81:9:100:2"):
raise Exception("Failed to set non-preferred channel list")
dev[0].connect(ssid, key_mgmt="NONE", scan_freq="2412")
addr = dev[0].own_addr()
sta = hapd.get_sta(addr)
logger.debug("STA: " + str(sta))
if 'non_pref_chan[0]' not in sta:
raise Exception("Missing non_pref_chan[0] value (assoc)")
if sta['non_pref_chan[0]'] != '81:200:1:123:7':
raise Exception("Unexpected non_pref_chan[0] value (assoc)")
if 'non_pref_chan[1]' not in sta:
raise Exception("Missing non_pref_chan[1] value (assoc)")
if sta['non_pref_chan[1]'] != '81:100:2:0:9':
raise Exception("Unexpected non_pref_chan[1] value (assoc)")
if 'non_pref_chan[2]' in sta:
raise Exception("Unexpected non_pref_chan[2] value (assoc)")
if "OK" not in dev[0].request("SET non_pref_chan 81:9:100:2"):
raise Exception("Failed to update non-preferred channel list")
time.sleep(0.1)
sta = hapd.get_sta(addr)
logger.debug("STA: " + str(sta))
if 'non_pref_chan[0]' not in sta:
raise Exception("Missing non_pref_chan[0] value (update 1)")
if sta['non_pref_chan[0]'] != '81:100:2:0:9':
raise Exception("Unexpected non_pref_chan[0] value (update 1)")
if 'non_pref_chan[1]' in sta:
raise Exception("Unexpected non_pref_chan[2] value (update 1)")
if "OK" not in dev[0].request("SET non_pref_chan 81:9:100:2 81:10:100:2 81:8:100:2 81:7:100:1:123 81:5:100:1:124"):
raise Exception("Failed to update non-preferred channel list")
time.sleep(0.1)
sta = hapd.get_sta(addr)
logger.debug("STA: " + str(sta))
if 'non_pref_chan[0]' not in sta:
raise Exception("Missing non_pref_chan[0] value (update 2)")
if sta['non_pref_chan[0]'] != '81:100:1:123:7':
raise Exception("Unexpected non_pref_chan[0] value (update 2)")
if 'non_pref_chan[1]' not in sta:
raise Exception("Missing non_pref_chan[1] value (update 2)")
if sta['non_pref_chan[1]'] != '81:100:1:124:5':
raise Exception("Unexpected non_pref_chan[1] value (update 2)")
if 'non_pref_chan[2]' not in sta:
raise Exception("Missing non_pref_chan[2] value (update 2)")
if sta['non_pref_chan[2]'] != '81:100:2:0:9,10,8':
raise Exception("Unexpected non_pref_chan[2] value (update 2)")
if 'non_pref_chan[3]' in sta:
raise Exception("Unexpected non_pref_chan[3] value (update 2)")
if "OK" not in dev[0].request("SET non_pref_chan 81:5:90:2 82:14:91:2"):
raise Exception("Failed to update non-preferred channel list")
time.sleep(0.1)
sta = hapd.get_sta(addr)
logger.debug("STA: " + str(sta))
if 'non_pref_chan[0]' not in sta:
raise Exception("Missing non_pref_chan[0] value (update 3)")
if sta['non_pref_chan[0]'] != '81:90:2:0:5':
raise Exception("Unexpected non_pref_chan[0] value (update 3)")
if 'non_pref_chan[1]' not in sta:
raise Exception("Missing non_pref_chan[1] value (update 3)")
if sta['non_pref_chan[1]'] != '82:91:2:0:14':
raise Exception("Unexpected non_pref_chan[1] value (update 3)")
if 'non_pref_chan[2]' in sta:
raise Exception("Unexpected non_pref_chan[2] value (update 3)")
if "OK" not in dev[0].request("SET non_pref_chan "):
raise Exception("Failed to update non-preferred channel list")
time.sleep(0.1)
sta = hapd.get_sta(addr)
logger.debug("STA: " + str(sta))
if 'non_pref_chan[0]' in sta:
raise Exception("Unexpected non_pref_chan[0] value (update 4)")
def test_mbo_sta_supp_op_classes(dev, apdev):
"""MBO STA supported operating classes"""
ssid = "test-wnm-mbo"
params = { 'ssid': ssid, 'mbo': '1' }
hapd = hostapd.add_ap(apdev[0], params)
dev[0].connect(ssid, key_mgmt="NONE", scan_freq="2412")
addr = dev[0].own_addr()
sta = hapd.get_sta(addr)
logger.debug("STA: " + str(sta))
if 'supp_op_classes' not in sta:
raise Exception("No supp_op_classes")
supp = bytearray(sta['supp_op_classes'].decode("hex"))
if supp[0] != 81:
raise Exception("Unexpected current operating class %d" % supp[0])
if 115 not in supp:
raise Exception("Operating class 115 missing")
```
#### File: tests/hwsim/test_radius.py
```python
import binascii
import hashlib
import hmac
import logging
logger = logging.getLogger()
import os
import select
import struct
import subprocess
import threading
import time
import hostapd
from utils import HwsimSkip, require_under_vm, skip_with_fips, fail_test
from test_ap_hs20 import build_dhcp_ack
from test_ap_ft import ft_params1
def connect(dev, ssid, wait_connect=True):
dev.connect(ssid, key_mgmt="WPA-EAP", scan_freq="2412",
eap="PSK", identity="<EMAIL>",
password_hex="<PASSWORD>",
wait_connect=wait_connect)
def test_radius_auth_unreachable(dev, apdev):
"""RADIUS Authentication server unreachable"""
params = hostapd.wpa2_eap_params(ssid="radius-auth")
params['auth_server_port'] = "18139"
hostapd.add_ap(apdev[0], params)
hapd = hostapd.Hostapd(apdev[0]['ifname'])
connect(dev[0], "radius-auth", wait_connect=False)
ev = dev[0].wait_event(["CTRL-EVENT-EAP-STARTED"])
if ev is None:
raise Exception("Timeout on EAP start")
logger.info("Checking for RADIUS retries")
time.sleep(4)
mib = hapd.get_mib()
if "radiusAuthClientAccessRequests" not in mib:
raise Exception("Missing MIB fields")
if int(mib["radiusAuthClientAccessRetransmissions"]) < 1:
raise Exception("Missing RADIUS Authentication retransmission")
if int(mib["radiusAuthClientPendingRequests"]) < 1:
raise Exception("Missing pending RADIUS Authentication request")
def test_radius_auth_unreachable2(dev, apdev):
"""RADIUS Authentication server unreachable (2)"""
subprocess.call(['ip', 'ro', 'replace', '192.168.213.17', 'dev', 'lo'])
params = hostapd.wpa2_eap_params(ssid="radius-auth")
params['auth_server_addr'] = "192.168.213.17"
params['auth_server_port'] = "18139"
hostapd.add_ap(apdev[0], params)
hapd = hostapd.Hostapd(apdev[0]['ifname'])
subprocess.call(['ip', 'ro', 'del', '192.168.213.17', 'dev', 'lo'])
connect(dev[0], "radius-auth", wait_connect=False)
ev = dev[0].wait_event(["CTRL-EVENT-EAP-STARTED"])
if ev is None:
raise Exception("Timeout on EAP start")
logger.info("Checking for RADIUS retries")
time.sleep(4)
mib = hapd.get_mib()
if "radiusAuthClientAccessRequests" not in mib:
raise Exception("Missing MIB fields")
if int(mib["radiusAuthClientAccessRetransmissions"]) < 1:
raise Exception("Missing RADIUS Authentication retransmission")
def test_radius_auth_unreachable3(dev, apdev):
"""RADIUS Authentication server initially unreachable, but then available"""
subprocess.call(['ip', 'ro', 'replace', 'blackhole', '192.168.213.18'])
params = hostapd.wpa2_eap_params(ssid="radius-auth")
params['auth_server_addr'] = "192.168.213.18"
hostapd.add_ap(apdev[0], params)
hapd = hostapd.Hostapd(apdev[0]['ifname'])
connect(dev[0], "radius-auth", wait_connect=False)
ev = dev[0].wait_event(["CTRL-EVENT-EAP-STARTED"])
if ev is None:
raise Exception("Timeout on EAP start")
subprocess.call(['ip', 'ro', 'del', 'blackhole', '192.168.213.18'])
time.sleep(0.1)
dev[0].request("DISCONNECT")
hapd.set('auth_server_addr_replace', '127.0.0.1')
dev[0].request("RECONNECT")
dev[0].wait_connected()
def test_radius_acct_unreachable(dev, apdev):
"""RADIUS Accounting server unreachable"""
params = hostapd.wpa2_eap_params(ssid="radius-acct")
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "18139"
params['acct_server_shared_secret'] = "radius"
hostapd.add_ap(apdev[0], params)
hapd = hostapd.Hostapd(apdev[0]['ifname'])
connect(dev[0], "radius-acct")
logger.info("Checking for RADIUS retries")
time.sleep(4)
mib = hapd.get_mib()
if "radiusAccClientRetransmissions" not in mib:
raise Exception("Missing MIB fields")
if int(mib["radiusAccClientRetransmissions"]) < 2:
raise Exception("Missing RADIUS Accounting retransmissions")
if int(mib["radiusAccClientPendingRequests"]) < 2:
raise Exception("Missing pending RADIUS Accounting requests")
def test_radius_acct_unreachable2(dev, apdev):
"""RADIUS Accounting server unreachable(2)"""
subprocess.call(['ip', 'ro', 'replace', '192.168.213.17', 'dev', 'lo'])
params = hostapd.wpa2_eap_params(ssid="radius-acct")
params['acct_server_addr'] = "192.168.213.17"
params['acct_server_port'] = "18139"
params['acct_server_shared_secret'] = "radius"
hostapd.add_ap(apdev[0], params)
hapd = hostapd.Hostapd(apdev[0]['ifname'])
subprocess.call(['ip', 'ro', 'del', '192.168.213.17', 'dev', 'lo'])
connect(dev[0], "radius-acct")
logger.info("Checking for RADIUS retries")
time.sleep(4)
mib = hapd.get_mib()
if "radiusAccClientRetransmissions" not in mib:
raise Exception("Missing MIB fields")
if int(mib["radiusAccClientRetransmissions"]) < 1 and int(mib["radiusAccClientPendingRequests"]) < 1:
raise Exception("Missing pending or retransmitted RADIUS Accounting requests")
def test_radius_acct_unreachable3(dev, apdev):
"""RADIUS Accounting server initially unreachable, but then available"""
require_under_vm()
subprocess.call(['ip', 'ro', 'replace', 'blackhole', '192.168.213.18'])
as_hapd = hostapd.Hostapd("as")
as_mib_start = as_hapd.get_mib(param="radius_server")
params = hostapd.wpa2_eap_params(ssid="radius-acct")
params['acct_server_addr'] = "192.168.213.18"
params['acct_server_port'] = "1813"
params['acct_server_shared_secret'] = "radius"
hostapd.add_ap(apdev[0], params)
hapd = hostapd.Hostapd(apdev[0]['ifname'])
connect(dev[0], "radius-acct")
subprocess.call(['ip', 'ro', 'del', 'blackhole', '192.168.213.18'])
time.sleep(0.1)
dev[0].request("DISCONNECT")
hapd.set('acct_server_addr_replace', '127.0.0.1')
dev[0].request("RECONNECT")
dev[0].wait_connected()
time.sleep(1)
as_mib_end = as_hapd.get_mib(param="radius_server")
req_s = int(as_mib_start['radiusAccServTotalResponses'])
req_e = int(as_mib_end['radiusAccServTotalResponses'])
if req_e <= req_s:
raise Exception("Unexpected RADIUS server acct MIB value")
def test_radius_acct_unreachable4(dev, apdev):
"""RADIUS Accounting server unreachable and multiple STAs"""
params = hostapd.wpa2_eap_params(ssid="radius-acct")
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "18139"
params['acct_server_shared_secret'] = "radius"
hostapd.add_ap(apdev[0], params)
hapd = hostapd.Hostapd(apdev[0]['ifname'])
for i in range(20):
connect(dev[0], "radius-acct")
dev[0].request("REMOVE_NETWORK all")
dev[0].wait_disconnected()
def test_radius_acct(dev, apdev):
"""RADIUS Accounting"""
as_hapd = hostapd.Hostapd("as")
as_mib_start = as_hapd.get_mib(param="radius_server")
params = hostapd.wpa2_eap_params(ssid="radius-acct")
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "1813"
params['acct_server_shared_secret'] = "radius"
params['radius_auth_req_attr'] = [ "126:s:Operator", "77:s:testing" ]
params['radius_acct_req_attr'] = [ "126:s:Operator", "77:s:testing" ]
hostapd.add_ap(apdev[0], params)
hapd = hostapd.Hostapd(apdev[0]['ifname'])
connect(dev[0], "radius-acct")
dev[1].connect("radius-acct", key_mgmt="WPA-EAP", scan_freq="2412",
eap="PAX", identity="test-class",
password_hex="<PASSWORD>")
dev[2].connect("radius-acct", key_mgmt="WPA-EAP",
eap="GPSK", identity="gpsk-cui",
password="<PASSWORD>",
scan_freq="2412")
logger.info("Checking for RADIUS counters")
count = 0
while True:
mib = hapd.get_mib()
if int(mib['radiusAccClientResponses']) >= 3:
break
time.sleep(0.1)
count += 1
if count > 10:
raise Exception("Did not receive Accounting-Response packets")
if int(mib['radiusAccClientRetransmissions']) > 0:
raise Exception("Unexpected Accounting-Request retransmission")
as_mib_end = as_hapd.get_mib(param="radius_server")
req_s = int(as_mib_start['radiusAccServTotalRequests'])
req_e = int(as_mib_end['radiusAccServTotalRequests'])
if req_e < req_s + 2:
raise Exception("Unexpected RADIUS server acct MIB value")
acc_s = int(as_mib_start['radiusAuthServAccessAccepts'])
acc_e = int(as_mib_end['radiusAuthServAccessAccepts'])
if acc_e < acc_s + 1:
raise Exception("Unexpected RADIUS server auth MIB value")
def test_radius_acct_non_ascii_ssid(dev, apdev):
"""RADIUS Accounting and non-ASCII SSID"""
params = hostapd.wpa2_eap_params()
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "1813"
params['acct_server_shared_secret'] = "radius"
ssid2 = "740665007374"
params['ssid2'] = ssid2
hostapd.add_ap(apdev[0], params)
dev[0].connect(ssid2=ssid2, key_mgmt="WPA-EAP", scan_freq="2412",
eap="PSK", identity="<EMAIL>",
password_hex="<PASSWORD>")
def test_radius_acct_pmksa_caching(dev, apdev):
"""RADIUS Accounting with PMKSA caching"""
as_hapd = hostapd.Hostapd("as")
as_mib_start = as_hapd.get_mib(param="radius_server")
params = hostapd.wpa2_eap_params(ssid="radius-acct")
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "1813"
params['acct_server_shared_secret'] = "radius"
hapd = hostapd.add_ap(apdev[0], params)
connect(dev[0], "radius-acct")
dev[1].connect("radius-acct", key_mgmt="WPA-EAP", scan_freq="2412",
eap="PAX", identity="test-class",
password_hex="<PASSWORD>")
for d in [ dev[0], dev[1] ]:
d.request("REASSOCIATE")
d.wait_connected(timeout=15, error="Reassociation timed out")
count = 0
while True:
mib = hapd.get_mib()
if int(mib['radiusAccClientResponses']) >= 4:
break
time.sleep(0.1)
count += 1
if count > 10:
raise Exception("Did not receive Accounting-Response packets")
if int(mib['radiusAccClientRetransmissions']) > 0:
raise Exception("Unexpected Accounting-Request retransmission")
as_mib_end = as_hapd.get_mib(param="radius_server")
req_s = int(as_mib_start['radiusAccServTotalRequests'])
req_e = int(as_mib_end['radiusAccServTotalRequests'])
if req_e < req_s + 2:
raise Exception("Unexpected RADIUS server acct MIB value")
acc_s = int(as_mib_start['radiusAuthServAccessAccepts'])
acc_e = int(as_mib_end['radiusAuthServAccessAccepts'])
if acc_e < acc_s + 1:
raise Exception("Unexpected RADIUS server auth MIB value")
def test_radius_acct_interim(dev, apdev):
"""RADIUS Accounting interim update"""
as_hapd = hostapd.Hostapd("as")
params = hostapd.wpa2_eap_params(ssid="radius-acct")
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "1813"
params['acct_server_shared_secret'] = "radius"
params['radius_acct_interim_interval'] = "1"
hostapd.add_ap(apdev[0], params)
hapd = hostapd.Hostapd(apdev[0]['ifname'])
connect(dev[0], "radius-acct")
logger.info("Checking for RADIUS counters")
as_mib_start = as_hapd.get_mib(param="radius_server")
time.sleep(3.1)
as_mib_end = as_hapd.get_mib(param="radius_server")
req_s = int(as_mib_start['radiusAccServTotalRequests'])
req_e = int(as_mib_end['radiusAccServTotalRequests'])
if req_e < req_s + 3:
raise Exception("Unexpected RADIUS server acct MIB value")
def test_radius_acct_interim_unreachable(dev, apdev):
"""RADIUS Accounting interim update with unreachable server"""
params = hostapd.wpa2_eap_params(ssid="radius-acct")
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "18139"
params['acct_server_shared_secret'] = "radius"
params['radius_acct_interim_interval'] = "1"
hapd = hostapd.add_ap(apdev[0], params)
start = hapd.get_mib()
connect(dev[0], "radius-acct")
logger.info("Waiting for interium accounting updates")
time.sleep(3.1)
end = hapd.get_mib()
req_s = int(start['radiusAccClientTimeouts'])
req_e = int(end['radiusAccClientTimeouts'])
if req_e < req_s + 2:
raise Exception("Unexpected RADIUS server acct MIB value")
def test_radius_acct_interim_unreachable2(dev, apdev):
"""RADIUS Accounting interim update with unreachable server (retry)"""
params = hostapd.wpa2_eap_params(ssid="radius-acct")
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "18139"
params['acct_server_shared_secret'] = "radius"
# Use long enough interim update interval to allow RADIUS retransmission
# case (3 seconds) to trigger first.
params['radius_acct_interim_interval'] = "4"
hapd = hostapd.add_ap(apdev[0], params)
start = hapd.get_mib()
connect(dev[0], "radius-acct")
logger.info("Waiting for interium accounting updates")
time.sleep(7.5)
end = hapd.get_mib()
req_s = int(start['radiusAccClientTimeouts'])
req_e = int(end['radiusAccClientTimeouts'])
if req_e < req_s + 2:
raise Exception("Unexpected RADIUS server acct MIB value")
def test_radius_acct_ipaddr(dev, apdev):
"""RADIUS Accounting and Framed-IP-Address"""
try:
_test_radius_acct_ipaddr(dev, apdev)
finally:
subprocess.call(['ip', 'link', 'set', 'dev', 'ap-br0', 'down'],
stderr=open('/dev/null', 'w'))
subprocess.call(['brctl', 'delbr', 'ap-br0'],
stderr=open('/dev/null', 'w'))
def _test_radius_acct_ipaddr(dev, apdev):
params = { "ssid": "radius-acct-open",
'acct_server_addr': "127.0.0.1",
'acct_server_port': "1813",
'acct_server_shared_secret': "radius",
'proxy_arp': '1',
'ap_isolate': '1',
'bridge': 'ap-br0' }
hapd = hostapd.add_ap(apdev[0], params, no_enable=True)
try:
hapd.enable()
except:
# For now, do not report failures due to missing kernel support
raise HwsimSkip("Could not start hostapd - assume proxyarp not supported in kernel version")
bssid = apdev[0]['bssid']
subprocess.call(['brctl', 'setfd', 'ap-br0', '0'])
subprocess.call(['ip', 'link', 'set', 'dev', 'ap-br0', 'up'])
dev[0].connect("radius-acct-open", key_mgmt="NONE", scan_freq="2412")
addr0 = dev[0].own_addr()
pkt = build_dhcp_ack(dst_ll="ff:ff:ff:ff:ff:ff", src_ll=bssid,
ip_src="192.168.1.1", ip_dst="255.255.255.255",
yiaddr="192.168.1.123", chaddr=addr0)
if "OK" not in hapd.request("DATA_TEST_FRAME ifname=ap-br0 " + binascii.hexlify(pkt)):
raise Exception("DATA_TEST_FRAME failed")
dev[0].request("DISCONNECT")
dev[0].wait_disconnected()
hapd.disable()
def send_and_check_reply(srv, req, code, error_cause=0):
reply = srv.SendPacket(req)
logger.debug("RADIUS response from hostapd")
for i in reply.keys():
logger.debug("%s: %s" % (i, reply[i]))
if reply.code != code:
raise Exception("Unexpected response code")
if error_cause:
if 'Error-Cause' not in reply:
raise Exception("Missing Error-Cause")
if reply['Error-Cause'][0] != error_cause:
raise Exception("Unexpected Error-Cause: {}".format(reply['Error-Cause']))
def test_radius_acct_psk(dev, apdev):
"""RADIUS Accounting - PSK"""
as_hapd = hostapd.Hostapd("as")
params = hostapd.wpa2_params(ssid="radius-acct", passphrase="<PASSWORD>")
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "1813"
params['acct_server_shared_secret'] = "radius"
hapd = hostapd.add_ap(apdev[0], params)
dev[0].connect("radius-acct", psk="12345678", scan_freq="2412")
def test_radius_acct_psk_sha256(dev, apdev):
"""RADIUS Accounting - PSK SHA256"""
as_hapd = hostapd.Hostapd("as")
params = hostapd.wpa2_params(ssid="radius-acct", passphrase="<PASSWORD>")
params["wpa_key_mgmt"] = "WPA-PSK-SHA256"
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "1813"
params['acct_server_shared_secret'] = "radius"
hapd = hostapd.add_ap(apdev[0], params)
dev[0].connect("radius-acct", key_mgmt="WPA-PSK-SHA256",
psk="12345678", scan_freq="2412")
def test_radius_acct_ft_psk(dev, apdev):
"""RADIUS Accounting - FT-PSK"""
as_hapd = hostapd.Hostapd("as")
params = ft_params1(ssid="radius-acct", passphrase="<PASSWORD>")
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "1813"
params['acct_server_shared_secret'] = "radius"
hapd = hostapd.add_ap(apdev[0], params)
dev[0].connect("radius-acct", key_mgmt="FT-PSK",
psk="12345678", scan_freq="2412")
def test_radius_acct_ieee8021x(dev, apdev):
"""RADIUS Accounting - IEEE 802.1X"""
skip_with_fips(dev[0])
as_hapd = hostapd.Hostapd("as")
params = hostapd.radius_params()
params["ssid"] = "radius-acct-1x"
params["ieee8021x"] = "1"
params["wep_key_len_broadcast"] = "13"
params["wep_key_len_unicast"] = "13"
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "1813"
params['acct_server_shared_secret'] = "radius"
hapd = hostapd.add_ap(apdev[0], params)
dev[0].connect("radius-acct-1x", key_mgmt="IEEE8021X", eap="PSK",
identity="<EMAIL>",
password_hex="<PASSWORD>",
scan_freq="2412")
def test_radius_das_disconnect(dev, apdev):
"""RADIUS Dynamic Authorization Extensions - Disconnect"""
try:
import pyrad.client
import pyrad.packet
import pyrad.dictionary
import radius_das
except ImportError:
raise HwsimSkip("No pyrad modules available")
params = hostapd.wpa2_eap_params(ssid="radius-das")
params['radius_das_port'] = "3799"
params['radius_das_client'] = "127.0.0.1 secret"
params['radius_das_require_event_timestamp'] = "1"
params['own_ip_addr'] = "127.0.0.1"
params['nas_identifier'] = "nas.example.com"
hapd = hostapd.add_ap(apdev[0], params)
connect(dev[0], "radius-das")
addr = dev[0].p2p_interface_addr()
sta = hapd.get_sta(addr)
id = sta['dot1xAuthSessionId']
dict = pyrad.dictionary.Dictionary("dictionary.radius")
srv = pyrad.client.Client(server="127.0.0.1", acctport=3799,
secret="secret", dict=dict)
srv.retries = 1
srv.timeout = 1
logger.info("Disconnect-Request with incorrect secret")
req = radius_das.DisconnectPacket(dict=dict, secret="incorrect",
User_Name="foo",
NAS_Identifier="localhost",
Event_Timestamp=int(time.time()))
logger.debug(req)
try:
reply = srv.SendPacket(req)
raise Exception("Unexpected response to Disconnect-Request")
except pyrad.client.Timeout:
logger.info("Disconnect-Request with incorrect secret properly ignored")
logger.info("Disconnect-Request without Event-Timestamp")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
User_Name="<EMAIL>")
logger.debug(req)
try:
reply = srv.SendPacket(req)
raise Exception("Unexpected response to Disconnect-Request")
except pyrad.client.Timeout:
logger.info("Disconnect-Request without Event-Timestamp properly ignored")
logger.info("Disconnect-Request with non-matching Event-Timestamp")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
User_Name="<EMAIL>",
Event_Timestamp=123456789)
logger.debug(req)
try:
reply = srv.SendPacket(req)
raise Exception("Unexpected response to Disconnect-Request")
except pyrad.client.Timeout:
logger.info("Disconnect-Request with non-matching Event-Timestamp properly ignored")
logger.info("Disconnect-Request with unsupported attribute")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
User_Name="foo",
User_Password="<PASSWORD>",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, 401)
logger.info("Disconnect-Request with invalid Calling-Station-Id")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
User_Name="foo",
Calling_Station_Id="foo",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, 407)
logger.info("Disconnect-Request with mismatching User-Name")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
User_Name="foo",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, 503)
logger.info("Disconnect-Request with mismatching Calling-Station-Id")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
Calling_Station_Id="12:34:56:78:90:aa",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, 503)
logger.info("Disconnect-Request with mismatching Acct-Session-Id")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
Acct_Session_Id="12345678-87654321",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, 503)
logger.info("Disconnect-Request with mismatching Acct-Session-Id (len)")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
Acct_Session_Id="12345678",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, 503)
logger.info("Disconnect-Request with mismatching Acct-Multi-Session-Id")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
Acct_Multi_Session_Id="12345678+87654321",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, 503)
logger.info("Disconnect-Request with mismatching Acct-Multi-Session-Id (len)")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
Acct_Multi_Session_Id="12345678",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, 503)
logger.info("Disconnect-Request with no session identification attributes")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, 503)
ev = dev[0].wait_event(["CTRL-EVENT-DISCONNECTED"], timeout=1)
if ev is not None:
raise Exception("Unexpected disconnection")
logger.info("Disconnect-Request with mismatching NAS-IP-Address")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_IP_Address="192.168.3.4",
Acct_Session_Id=id,
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, 403)
logger.info("Disconnect-Request with mismatching NAS-Identifier")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_Identifier="unknown.example.com",
Acct_Session_Id=id,
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, 403)
ev = dev[0].wait_event(["CTRL-EVENT-DISCONNECTED"], timeout=1)
if ev is not None:
raise Exception("Unexpected disconnection")
logger.info("Disconnect-Request with matching Acct-Session-Id")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_IP_Address="127.0.0.1",
NAS_Identifier="nas.example.com",
Acct_Session_Id=id,
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectACK)
dev[0].wait_disconnected(timeout=10)
dev[0].wait_connected(timeout=10, error="Re-connection timed out")
logger.info("Disconnect-Request with matching Acct-Multi-Session-Id")
sta = hapd.get_sta(addr)
multi_sess_id = sta['authMultiSessionId']
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_IP_Address="127.0.0.1",
NAS_Identifier="nas.example.com",
Acct_Multi_Session_Id=multi_sess_id,
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectACK)
dev[0].wait_disconnected(timeout=10)
dev[0].wait_connected(timeout=10, error="Re-connection timed out")
logger.info("Disconnect-Request with matching User-Name")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_Identifier="nas.example.com",
User_Name="<EMAIL>",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectACK)
dev[0].wait_disconnected(timeout=10)
dev[0].wait_connected(timeout=10, error="Re-connection timed out")
logger.info("Disconnect-Request with matching Calling-Station-Id")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_IP_Address="127.0.0.1",
Calling_Station_Id=addr,
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectACK)
dev[0].wait_disconnected(timeout=10)
ev = dev[0].wait_event(["CTRL-EVENT-EAP-STARTED", "CTRL-EVENT-CONNECTED"])
if ev is None:
raise Exception("Timeout while waiting for re-connection")
if "CTRL-EVENT-EAP-STARTED" not in ev:
raise Exception("Unexpected skipping of EAP authentication in reconnection")
dev[0].wait_connected(timeout=10, error="Re-connection timed out")
logger.info("Disconnect-Request with matching Calling-Station-Id and non-matching CUI")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
Calling_Station_Id=addr,
Chargeable_User_Identity="<EMAIL>",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, error_cause=503)
logger.info("Disconnect-Request with matching CUI")
dev[1].connect("radius-das", key_mgmt="WPA-EAP",
eap="GPSK", identity="gpsk-cui",
password="<PASSWORD>",
scan_freq="2412")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
Chargeable_User_Identity="gpsk-chargeable-user-identity",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectACK)
dev[1].wait_disconnected(timeout=10)
dev[1].wait_connected(timeout=10, error="Re-connection timed out")
ev = dev[0].wait_event(["CTRL-EVENT-DISCONNECTED"], timeout=1)
if ev is not None:
raise Exception("Unexpected disconnection")
connect(dev[2], "radius-das")
logger.info("Disconnect-Request with matching User-Name - multiple sessions matching")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_Identifier="nas.example.com",
User_Name="<EMAIL>",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, error_cause=508)
logger.info("Disconnect-Request with User-Name matching multiple sessions, Calling-Station-Id only one")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_Identifier="nas.example.com",
Calling_Station_Id=addr,
User_Name="<EMAIL>",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectACK)
dev[0].wait_disconnected(timeout=10)
dev[0].wait_connected(timeout=10, error="Re-connection timed out")
ev = dev[2].wait_event(["CTRL-EVENT-DISCONNECTED"], timeout=1)
if ev is not None:
raise Exception("Unexpected disconnection")
logger.info("Disconnect-Request with matching Acct-Multi-Session-Id after disassociation")
sta = hapd.get_sta(addr)
multi_sess_id = sta['authMultiSessionId']
dev[0].request("DISCONNECT")
dev[0].wait_disconnected(timeout=10)
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_IP_Address="127.0.0.1",
NAS_Identifier="nas.example.com",
Acct_Multi_Session_Id=multi_sess_id,
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectACK)
dev[0].request("RECONNECT")
ev = dev[0].wait_event(["CTRL-EVENT-EAP-STARTED"], timeout=15)
if ev is None:
raise Exception("Timeout on EAP start")
dev[0].wait_connected(timeout=15)
logger.info("Disconnect-Request with matching User-Name after disassociation")
dev[0].request("DISCONNECT")
dev[0].wait_disconnected(timeout=10)
dev[2].request("DISCONNECT")
dev[2].wait_disconnected(timeout=10)
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_IP_Address="127.0.0.1",
NAS_Identifier="nas.example.com",
User_Name="<EMAIL>",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectACK)
logger.info("Disconnect-Request with matching CUI after disassociation")
dev[1].request("DISCONNECT")
dev[1].wait_disconnected(timeout=10)
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_IP_Address="127.0.0.1",
NAS_Identifier="nas.example.com",
Chargeable_User_Identity="gpsk-chargeable-user-identity",
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectACK)
logger.info("Disconnect-Request with matching Calling-Station-Id after disassociation")
dev[0].request("RECONNECT")
ev = dev[0].wait_event(["CTRL-EVENT-EAP-STARTED"], timeout=15)
if ev is None:
raise Exception("Timeout on EAP start")
dev[0].wait_connected(timeout=15)
dev[0].request("DISCONNECT")
dev[0].wait_disconnected(timeout=10)
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_IP_Address="127.0.0.1",
NAS_Identifier="nas.example.com",
Calling_Station_Id=addr,
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectACK)
logger.info("Disconnect-Request with mismatching Calling-Station-Id after disassociation")
req = radius_das.DisconnectPacket(dict=dict, secret="secret",
NAS_IP_Address="127.0.0.1",
NAS_Identifier="nas.example.com",
Calling_Station_Id=addr,
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.DisconnectNAK, error_cause=503)
def test_radius_das_coa(dev, apdev):
"""RADIUS Dynamic Authorization Extensions - CoA"""
try:
import pyrad.client
import pyrad.packet
import pyrad.dictionary
import radius_das
except ImportError:
raise HwsimSkip("No pyrad modules available")
params = hostapd.wpa2_eap_params(ssid="radius-das")
params['radius_das_port'] = "3799"
params['radius_das_client'] = "127.0.0.1 secret"
params['radius_das_require_event_timestamp'] = "1"
hapd = hostapd.add_ap(apdev[0], params)
connect(dev[0], "radius-das")
addr = dev[0].p2p_interface_addr()
sta = hapd.get_sta(addr)
id = sta['dot1xAuthSessionId']
dict = pyrad.dictionary.Dictionary("dictionary.radius")
srv = pyrad.client.Client(server="127.0.0.1", acctport=3799,
secret="secret", dict=dict)
srv.retries = 1
srv.timeout = 1
# hostapd does not currently support CoA-Request, so NAK is expected
logger.info("CoA-Request with matching Acct-Session-Id")
req = radius_das.CoAPacket(dict=dict, secret="secret",
Acct_Session_Id=id,
Event_Timestamp=int(time.time()))
send_and_check_reply(srv, req, pyrad.packet.CoANAK, error_cause=405)
def test_radius_ipv6(dev, apdev):
"""RADIUS connection over IPv6"""
params = {}
params['ssid'] = 'as'
params['beacon_int'] = '2000'
params['radius_server_clients'] = 'auth_serv/radius_clients_ipv6.conf'
params['radius_server_ipv6'] = '1'
params['radius_server_auth_port'] = '18129'
params['radius_server_acct_port'] = '18139'
params['eap_server'] = '1'
params['eap_user_file'] = 'auth_serv/eap_user.conf'
params['ca_cert'] = 'auth_serv/ca.pem'
params['server_cert'] = 'auth_serv/server.pem'
params['private_key'] = 'auth_serv/server.key'
hostapd.add_ap(apdev[1], params)
params = hostapd.wpa2_eap_params(ssid="radius-ipv6")
params['auth_server_addr'] = "::0"
params['auth_server_port'] = "18129"
params['acct_server_addr'] = "::0"
params['acct_server_port'] = "18139"
params['acct_server_shared_secret'] = "radius"
params['own_ip_addr'] = "::0"
hostapd.add_ap(apdev[0], params)
connect(dev[0], "radius-ipv6")
def test_radius_macacl(dev, apdev):
"""RADIUS MAC ACL"""
params = hostapd.radius_params()
params["ssid"] = "radius"
params["macaddr_acl"] = "2"
hostapd.add_ap(apdev[0], params)
dev[0].connect("radius", key_mgmt="NONE", scan_freq="2412")
def test_radius_macacl_acct(dev, apdev):
"""RADIUS MAC ACL and accounting enabled"""
params = hostapd.radius_params()
params["ssid"] = "radius"
params["macaddr_acl"] = "2"
params['acct_server_addr'] = "127.0.0.1"
params['acct_server_port'] = "1813"
params['acct_server_shared_secret'] = "radius"
hostapd.add_ap(apdev[0], params)
dev[0].connect("radius", key_mgmt="NONE", scan_freq="2412")
dev[1].connect("radius", key_mgmt="NONE", scan_freq="2412")
dev[1].request("DISCONNECT")
dev[1].wait_disconnected()
dev[1].request("RECONNECT")
def test_radius_failover(dev, apdev):
"""RADIUS Authentication and Accounting server failover"""
subprocess.call(['ip', 'ro', 'replace', '192.168.213.17', 'dev', 'lo'])
as_hapd = hostapd.Hostapd("as")
as_mib_start = as_hapd.get_mib(param="radius_server")
params = hostapd.wpa2_eap_params(ssid="radius-failover")
params["auth_server_addr"] = "192.168.213.17"
params["auth_server_port"] = "1812"
params["auth_server_shared_secret"] = "testing"
params['acct_server_addr'] = "192.168.213.17"
params['acct_server_port'] = "1813"
params['acct_server_shared_secret'] = "testing"
params['radius_retry_primary_interval'] = "20"
hapd = hostapd.add_ap(apdev[0], params, no_enable=True)
hapd.set("auth_server_addr", "127.0.0.1")
hapd.set("auth_server_port", "1812")
hapd.set("auth_server_shared_secret", "radius")
hapd.set('acct_server_addr', "127.0.0.1")
hapd.set('acct_server_port', "1813")
hapd.set('acct_server_shared_secret', "radius")
hapd.enable()
ev = hapd.wait_event(["AP-ENABLED", "AP-DISABLED"], timeout=30)
if ev is None:
raise Exception("AP startup timed out")
if "AP-ENABLED" not in ev:
raise Exception("AP startup failed")
start = os.times()[4]
try:
subprocess.call(['ip', 'ro', 'replace', 'prohibit', '192.168.213.17'])
dev[0].request("SET EAPOL::authPeriod 5")
connect(dev[0], "radius-failover", wait_connect=False)
dev[0].wait_connected(timeout=20)
finally:
dev[0].request("SET EAPOL::authPeriod 30")
subprocess.call(['ip', 'ro', 'del', '192.168.213.17'])
as_mib_end = as_hapd.get_mib(param="radius_server")
req_s = int(as_mib_start['radiusAccServTotalRequests'])
req_e = int(as_mib_end['radiusAccServTotalRequests'])
if req_e <= req_s:
raise Exception("Unexpected RADIUS server acct MIB value")
end = os.times()[4]
try:
subprocess.call(['ip', 'ro', 'replace', 'prohibit', '192.168.213.17'])
dev[1].request("SET EAPOL::authPeriod 5")
if end - start < 21:
time.sleep(21 - (end - start))
connect(dev[1], "radius-failover", wait_connect=False)
dev[1].wait_connected(timeout=20)
finally:
dev[1].request("SET EAPOL::authPeriod 30")
subprocess.call(['ip', 'ro', 'del', '192.168.213.17'])
def run_pyrad_server(srv, t_events):
srv.RunWithStop(t_events)
def test_radius_protocol(dev, apdev):
"""RADIUS Authentication protocol tests with a fake server"""
try:
import pyrad.server
import pyrad.packet
import pyrad.dictionary
except ImportError:
raise HwsimSkip("No pyrad modules available")
class TestServer(pyrad.server.Server):
def _HandleAuthPacket(self, pkt):
pyrad.server.Server._HandleAuthPacket(self, pkt)
logger.info("Received authentication request")
reply = self.CreateReplyPacket(pkt)
reply.code = pyrad.packet.AccessAccept
if self.t_events['msg_auth'].is_set():
logger.info("Add Message-Authenticator")
if self.t_events['wrong_secret'].is_set():
logger.info("Use incorrect RADIUS shared secret")
pw = "incorrect"
else:
pw = reply.secret
hmac_obj = hmac.new(pw)
hmac_obj.update(struct.pack("B", reply.code))
hmac_obj.update(struct.pack("B", reply.id))
# reply attributes
reply.AddAttribute("Message-Authenticator",
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
attrs = reply._PktEncodeAttributes()
# Length
flen = 4 + 16 + len(attrs)
hmac_obj.update(struct.pack(">H", flen))
hmac_obj.update(pkt.authenticator)
hmac_obj.update(attrs)
if self.t_events['double_msg_auth'].is_set():
logger.info("Include two Message-Authenticator attributes")
else:
del reply[80]
reply.AddAttribute("Message-Authenticator", hmac_obj.digest())
self.SendReplyPacket(pkt.fd, reply)
def RunWithStop(self, t_events):
self._poll = select.poll()
self._fdmap = {}
self._PrepareSockets()
self.t_events = t_events
while not t_events['stop'].is_set():
for (fd, event) in self._poll.poll(1000):
if event == select.POLLIN:
try:
fdo = self._fdmap[fd]
self._ProcessInput(fdo)
except pyrad.server.ServerPacketError as err:
logger.info("pyrad server dropping packet: " + str(err))
except pyrad.packet.PacketError as err:
logger.info("pyrad server received invalid packet: " + str(err))
else:
logger.error("Unexpected event in pyrad server main loop")
srv = TestServer(dict=pyrad.dictionary.Dictionary("dictionary.radius"),
authport=18138, acctport=18139)
srv.hosts["127.0.0.1"] = pyrad.server.RemoteHost("127.0.0.1",
"radius",
"localhost")
srv.BindToAddress("")
t_events = {}
t_events['stop'] = threading.Event()
t_events['msg_auth'] = threading.Event()
t_events['wrong_secret'] = threading.Event()
t_events['double_msg_auth'] = threading.Event()
t = threading.Thread(target=run_pyrad_server, args=(srv, t_events))
t.start()
try:
params = hostapd.wpa2_eap_params(ssid="radius-test")
params['auth_server_port'] = "18138"
hapd = hostapd.add_ap(apdev[0], params)
connect(dev[0], "radius-test", wait_connect=False)
ev = dev[0].wait_event(["CTRL-EVENT-EAP-STARTED"], timeout=15)
if ev is None:
raise Exception("Timeout on EAP start")
time.sleep(1)
dev[0].request("REMOVE_NETWORK all")
time.sleep(0.1)
dev[0].dump_monitor()
t_events['msg_auth'].set()
t_events['wrong_secret'].set()
connect(dev[0], "radius-test", wait_connect=False)
time.sleep(1)
dev[0].request("REMOVE_NETWORK all")
time.sleep(0.1)
dev[0].dump_monitor()
t_events['wrong_secret'].clear()
connect(dev[0], "radius-test", wait_connect=False)
time.sleep(1)
dev[0].request("REMOVE_NETWORK all")
time.sleep(0.1)
dev[0].dump_monitor()
t_events['double_msg_auth'].set()
connect(dev[0], "radius-test", wait_connect=False)
time.sleep(1)
finally:
t_events['stop'].set()
t.join()
def test_radius_psk(dev, apdev):
"""WPA2 with PSK from RADIUS"""
try:
import pyrad.server
import pyrad.packet
import pyrad.dictionary
except ImportError:
raise HwsimSkip("No pyrad modules available")
class TestServer(pyrad.server.Server):
def _HandleAuthPacket(self, pkt):
pyrad.server.Server._HandleAuthPacket(self, pkt)
logger.info("Received authentication request")
reply = self.CreateReplyPacket(pkt)
reply.code = pyrad.packet.AccessAccept
a = "\xab\xcd"
secret = reply.secret
if self.t_events['long'].is_set():
p = b'\x10' + "0123456789abcdef" + 15 * b'\x00'
b = hashlib.md5(secret + pkt.authenticator + a).digest()
pp = bytearray(p[0:16])
bb = bytearray(b)
cc = bytearray(pp[i] ^ bb[i] for i in range(len(bb)))
b = hashlib.md5(reply.secret + bytes(cc)).digest()
pp = bytearray(p[16:32])
bb = bytearray(b)
cc += bytearray(pp[i] ^ bb[i] for i in range(len(bb)))
data = '\x00' + a + bytes(cc)
else:
p = b'\x08' + "12345678" + 7 * b'\x00'
b = hashlib.md5(secret + pkt.authenticator + a).digest()
pp = bytearray(p)
bb = bytearray(b)
cc = bytearray(pp[i] ^ bb[i] for i in range(len(bb)))
data = '\x00' + a + bytes(cc)
reply.AddAttribute("Tunnel-Password", data)
self.SendReplyPacket(pkt.fd, reply)
def RunWithStop(self, t_events):
self._poll = select.poll()
self._fdmap = {}
self._PrepareSockets()
self.t_events = t_events
while not t_events['stop'].is_set():
for (fd, event) in self._poll.poll(1000):
if event == select.POLLIN:
try:
fdo = self._fdmap[fd]
self._ProcessInput(fdo)
except pyrad.server.ServerPacketError as err:
logger.info("pyrad server dropping packet: " + str(err))
except pyrad.packet.PacketError as err:
logger.info("pyrad server received invalid packet: " + str(err))
else:
logger.error("Unexpected event in pyrad server main loop")
srv = TestServer(dict=pyrad.dictionary.Dictionary("dictionary.radius"),
authport=18138, acctport=18139)
srv.hosts["127.0.0.1"] = pyrad.server.RemoteHost("127.0.0.1",
"radius",
"localhost")
srv.BindToAddress("")
t_events = {}
t_events['stop'] = threading.Event()
t_events['long'] = threading.Event()
t = threading.Thread(target=run_pyrad_server, args=(srv, t_events))
t.start()
try:
ssid = "test-wpa2-psk"
params = hostapd.radius_params()
params['ssid'] = ssid
params["wpa"] = "2"
params["wpa_key_mgmt"] = "WPA-PSK"
params["rsn_pairwise"] = "CCMP"
params['macaddr_acl'] = '2'
params['wpa_psk_radius'] = '2'
params['auth_server_port'] = "18138"
hapd = hostapd.add_ap(apdev[0], params)
dev[0].connect(ssid, psk="12345678", scan_freq="2412")
t_events['long'].set()
dev[1].connect(ssid, psk="0123456789abcdef", scan_freq="2412")
finally:
t_events['stop'].set()
t.join()
def test_radius_psk_invalid(dev, apdev):
"""WPA2 with invalid PSK from RADIUS"""
try:
import pyrad.server
import pyrad.packet
import pyrad.dictionary
except ImportError:
raise HwsimSkip("No pyrad modules available")
class TestServer(pyrad.server.Server):
def _HandleAuthPacket(self, pkt):
pyrad.server.Server._HandleAuthPacket(self, pkt)
logger.info("Received authentication request")
reply = self.CreateReplyPacket(pkt)
reply.code = pyrad.packet.AccessAccept
a = "\xab\xcd"
secret = reply.secret
p = b'\x07' + "1234567" + 8 * b'\x00'
b = hashlib.md5(secret + pkt.authenticator + a).digest()
pp = bytearray(p)
bb = bytearray(b)
cc = bytearray(pp[i] ^ bb[i] for i in range(len(bb)))
data = '\x00' + a + bytes(cc)
reply.AddAttribute("Tunnel-Password", data)
self.SendReplyPacket(pkt.fd, reply)
def RunWithStop(self, t_events):
self._poll = select.poll()
self._fdmap = {}
self._PrepareSockets()
self.t_events = t_events
while not t_events['stop'].is_set():
for (fd, event) in self._poll.poll(1000):
if event == select.POLLIN:
try:
fdo = self._fdmap[fd]
self._ProcessInput(fdo)
except pyrad.server.ServerPacketError as err:
logger.info("pyrad server dropping packet: " + str(err))
except pyrad.packet.PacketError as err:
logger.info("pyrad server received invalid packet: " + str(err))
else:
logger.error("Unexpected event in pyrad server main loop")
srv = TestServer(dict=pyrad.dictionary.Dictionary("dictionary.radius"),
authport=18138, acctport=18139)
srv.hosts["127.0.0.1"] = pyrad.server.RemoteHost("127.0.0.1",
"radius",
"localhost")
srv.BindToAddress("")
t_events = {}
t_events['stop'] = threading.Event()
t = threading.Thread(target=run_pyrad_server, args=(srv, t_events))
t.start()
try:
ssid = "test-wpa2-psk"
params = hostapd.radius_params()
params['ssid'] = ssid
params["wpa"] = "2"
params["wpa_key_mgmt"] = "WPA-PSK"
params["rsn_pairwise"] = "CCMP"
params['macaddr_acl'] = '2'
params['wpa_psk_radius'] = '2'
params['auth_server_port'] = "18138"
hapd = hostapd.add_ap(apdev[0], params)
dev[0].connect(ssid, psk="12345678", scan_freq="2412",
wait_connect=False)
time.sleep(1)
finally:
t_events['stop'].set()
t.join()
def test_radius_auth_force_client_addr(dev, apdev):
"""RADIUS client address specified"""
params = hostapd.wpa2_eap_params(ssid="radius-auth")
params['radius_client_addr'] = "127.0.0.1"
hapd = hostapd.add_ap(apdev[0], params)
connect(dev[0], "radius-auth")
def test_radius_auth_force_invalid_client_addr(dev, apdev):
"""RADIUS client address specified and invalid address"""
params = hostapd.wpa2_eap_params(ssid="radius-auth")
#params['radius_client_addr'] = "10.11.12.14"
params['radius_client_addr'] = "fd00:a516:7c1b:17cd:6d81:2137:bd2a:2c5b"
hapd = hostapd.add_ap(apdev[0], params)
connect(dev[0], "radius-auth", wait_connect=False)
ev = dev[0].wait_event(["CTRL-EVENT-EAP-STARTED"])
if ev is None:
raise Exception("Timeout on EAP start")
ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED"], timeout=1)
if ev is not None:
raise Exception("Unexpected connection")
def add_message_auth(req):
req.authenticator = req.CreateAuthenticator()
hmac_obj = hmac.new(req.secret)
hmac_obj.update(struct.pack("B", req.code))
hmac_obj.update(struct.pack("B", req.id))
# request attributes
req.AddAttribute("Message-Authenticator",
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
attrs = req._PktEncodeAttributes()
# Length
flen = 4 + 16 + len(attrs)
hmac_obj.update(struct.pack(">H", flen))
hmac_obj.update(req.authenticator)
hmac_obj.update(attrs)
del req[80]
req.AddAttribute("Message-Authenticator", hmac_obj.digest())
def test_radius_server_failures(dev, apdev):
"""RADIUS server failure cases"""
try:
import pyrad.client
import pyrad.packet
import pyrad.dictionary
except ImportError:
raise HwsimSkip("No pyrad modules available")
dict = pyrad.dictionary.Dictionary("dictionary.radius")
client = pyrad.client.Client(server="127.0.0.1", authport=1812,
secret="radius", dict=dict)
client.retries = 1
client.timeout = 1
# unexpected State
req = client.CreateAuthPacket(code=pyrad.packet.AccessRequest,
User_Name="foo")
req['State'] = 'foo-state'
add_message_auth(req)
reply = client.SendPacket(req)
if reply.code != pyrad.packet.AccessReject:
raise Exception("Unexpected RADIUS response code " + str(reply.code))
# no EAP-Message
req = client.CreateAuthPacket(code=pyrad.packet.AccessRequest,
User_Name="foo")
add_message_auth(req)
try:
reply = client.SendPacket(req)
raise Exception("Unexpected response")
except pyrad.client.Timeout:
pass
def test_ap_vlan_wpa2_psk_radius_required(dev, apdev):
"""AP VLAN with WPA2-PSK and RADIUS attributes required"""
try:
import pyrad.server
import pyrad.packet
import pyrad.dictionary
except ImportError:
raise HwsimSkip("No pyrad modules available")
class TestServer(pyrad.server.Server):
def _HandleAuthPacket(self, pkt):
pyrad.server.Server._HandleAuthPacket(self, pkt)
logger.info("Received authentication request")
reply = self.CreateReplyPacket(pkt)
reply.code = pyrad.packet.AccessAccept
secret = reply.secret
if self.t_events['extra'].is_set():
reply.AddAttribute("Chargeable-User-Identity", "test-cui")
reply.AddAttribute("User-Name", "test-user")
if self.t_events['long'].is_set():
reply.AddAttribute("Tunnel-Type", 13)
reply.AddAttribute("Tunnel-Medium-Type", 6)
reply.AddAttribute("Tunnel-Private-Group-ID", "1")
self.SendReplyPacket(pkt.fd, reply)
def RunWithStop(self, t_events):
self._poll = select.poll()
self._fdmap = {}
self._PrepareSockets()
self.t_events = t_events
while not t_events['stop'].is_set():
for (fd, event) in self._poll.poll(1000):
if event == select.POLLIN:
try:
fdo = self._fdmap[fd]
self._ProcessInput(fdo)
except pyrad.server.ServerPacketError as err:
logger.info("pyrad server dropping packet: " + str(err))
except pyrad.packet.PacketError as err:
logger.info("pyrad server received invalid packet: " + str(err))
else:
logger.error("Unexpected event in pyrad server main loop")
srv = TestServer(dict=pyrad.dictionary.Dictionary("dictionary.radius"),
authport=18138, acctport=18139)
srv.hosts["127.0.0.1"] = pyrad.server.RemoteHost("127.0.0.1",
"radius",
"localhost")
srv.BindToAddress("")
t_events = {}
t_events['stop'] = threading.Event()
t_events['long'] = threading.Event()
t_events['extra'] = threading.Event()
t = threading.Thread(target=run_pyrad_server, args=(srv, t_events))
t.start()
try:
ssid = "test-wpa2-psk"
params = hostapd.radius_params()
params['ssid'] = ssid
params["wpa"] = "2"
params["wpa_key_mgmt"] = "WPA-PSK"
params["rsn_pairwise"] = "CCMP"
params['macaddr_acl'] = '2'
params['dynamic_vlan'] = "2"
params['wpa_passphrase'] = '<PASSWORD>'
params['auth_server_port'] = "18138"
hapd = hostapd.add_ap(apdev[0], params)
logger.info("connecting without VLAN")
dev[0].connect(ssid, psk="0123456789abcdefghi", scan_freq="2412",
wait_connect=False)
ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED",
"CTRL-EVENT-SSID-TEMP-DISABLED"], timeout=20)
if ev is None:
raise Exception("Timeout on connection attempt")
if "CTRL-EVENT-CONNECTED" in ev:
raise Exception("Unexpected success without vlan parameters")
logger.info("connecting without VLAN failed as expected")
logger.info("connecting without VLAN (CUI/User-Name)")
t_events['extra'].set()
dev[1].connect(ssid, psk="0123456789abcdefghi", scan_freq="2412",
wait_connect=False)
ev = dev[1].wait_event(["CTRL-EVENT-CONNECTED",
"CTRL-EVENT-SSID-TEMP-DISABLED"], timeout=20)
if ev is None:
raise Exception("Timeout on connection attempt")
if "CTRL-EVENT-CONNECTED" in ev:
raise Exception("Unexpected success without vlan parameters(2)")
logger.info("connecting without VLAN failed as expected(2)")
t_events['extra'].clear()
t_events['long'].set()
logger.info("connecting with VLAN")
dev[2].connect(ssid, psk="0123456789abcdefghi", scan_freq="2412",
wait_connect=False)
ev = dev[2].wait_event(["CTRL-EVENT-CONNECTED",
"CTRL-EVENT-SSID-TEMP-DISABLED"], timeout=20)
if ev is None:
raise Exception("Timeout on connection attempt")
if "CTRL-EVENT-SSID-TEMP-DISABLED" in ev:
raise Exception("Unexpected failure with vlan parameters")
logger.info("connecting with VLAN succeeded as expected")
finally:
t_events['stop'].set()
t.join()
def test_radius_mppe_failure(dev, apdev):
"""RADIUS failure when adding MPPE keys"""
params = { "ssid": "as", "beacon_int": "2000",
"radius_server_clients": "auth_serv/radius_clients.conf",
"radius_server_auth_port": '18127',
"eap_server": "1",
"eap_user_file": "auth_serv/eap_user.conf",
"ca_cert": "auth_serv/ca.pem",
"server_cert": "auth_serv/server.pem",
"private_key": "auth_serv/server.key" }
authsrv = hostapd.add_ap(apdev[1], params)
params = hostapd.wpa2_eap_params(ssid="test-wpa2-eap")
params['auth_server_port'] = "18127"
hapd = hostapd.add_ap(apdev[0], params)
with fail_test(authsrv, 1, "os_get_random;radius_msg_add_mppe_keys"):
dev[0].connect("test-wpa2-eap", key_mgmt="WPA-EAP", eap="TTLS",
identity="user", anonymous_identity="ttls",
password="password",
ca_cert="auth_serv/ca.pem", phase2="autheap=GTC",
wait_connect=False, scan_freq="2412")
dev[0].wait_disconnected()
dev[0].request("REMOVE_NETWORK all")
``` |
{
"source": "9aditya9/karigar",
"score": 3
} |
#### File: karigar/app/models.py
```python
from datetime import datetime
from app import db
from werkzeug.security import generate_password_hash, check_password_hash
from flask_login import UserMixin
from app import login
from hashlib import md5
#association table
# booked = db.Table('booked',
# db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
# db.Column('services_id', db.Integer, db.ForeignKey('services.id'))
# )
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
booked_service = db.relationship('Booked',
backref='customer',
lazy='dynamic')
posts = db.relationship('Post', backref='author', lazy='dynamic')
# booked_service = db.relationship('Booked', backref='customer', lazy='dynamic')
# services = db.relationship("Services", secondary="booked", lazy='subquery', backref=db.backref('users', lazy=True))
# services_id = db.Column(db.Integer, db.ForeignKey('services.id'))
# followed = db.relationship(
# 'Services', secondary=booked,
# primaryjoin=(booked.c.services_id == services_id),
# secondaryjoin=(booked.c.user_id == id),
# backref=db.backref('booked', lazy='dynamic'), lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?s={}'.format(digest, size)
# return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(digest, size)
class Services(db.Model):
id = db.Column(db.Integer, primary_key=True)
price = db.Column(db.Integer)
name = db.Column(db.String(60), unique=True)
def __repr__(self):
return '<Services {}{}{}>'.format(self.id, self.name, self.price)
class Booked(db.Model):
id = db.Column(db.Integer, primary_key=True)
services_id = db.Column(db.Integer, db.ForeignKey('services.id'), nullable=False)
# services_name = db.Column(db.String, db.ForeignKey('services.name'))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
services=db.relationship('Services', backref='booker')
def __repr__(self):
"""
docstring
"""
return '<Booked {}{}{}>'.format(self.id, self.services_id, self.user_id)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Post {}>'.format(self.body)
@login.user_loader
def load_user(id):
return User.query.get(int(id))
```
#### File: karigar/app/routes.py
```python
from app import app, db
from flask import render_template, flash, redirect, url_for, request
from flask_login import current_user, login_user, logout_user, login_required
from werkzeug.urls import url_parse
from app.forms import LoginForm, RegistrationForm, EditProfileForm, AddServiceForm
from app.models import User, Post, Services, Booked
from datetime import datetime
# index/home route
@app.route('/')
@app.route('/index')
def index():
form = LoginForm()
reg_form = RegistrationForm()
return render_template('index.html',
title='Home Page')
#login route
@app.route('/login', methods=['GET', 'POST'])
def login():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = LoginForm()
# reg_form = RegistrationForm()
if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
if user is None or not user.check_password(form.password.data):
flash('Invalid username or password')
return redirect(url_for('login'))
login_user(user, remember=form.remember_me.data)
next_page = request.args.get('next')
if not next_page:
next_page = url_for('index')
return redirect(next_page)
return render_template('login.html',
title='Sign In',
form=form)
#changed url from login.html
@app.route('/logout')
def logout():
logout_user()
return redirect(url_for('index'))
@app.route('/register', methods=['GET', 'POST'])
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash('Congratulations, you are now a registered user!')
return redirect(url_for('login'))
return render_template('register.html', title="Register", form=form)
#changed url from register.html
@app.route('/user')
@app.route('/user/<username>')
@login_required
def user(username):
user = User.query.filter_by(username=username).first_or_404()
# posts = [{
# 'author': user,
# 'body': 'Test post #1'
# }, {
# 'author': user,
# 'body': 'Test post #2'
# }]
# booked_service = user.booked_service.order_by(Booked.timestamp.desc())
#result = db.session.query(Services).join(Booked).filter(Booked.user_id == user.id)
#booked = Booked.query.filter(Booked.user_id == user.id)
#services = Services.query.all()
result = db.session.query(Services, Booked).join(
Booked, Booked.services_id == Services.id).filter(
Booked.user_id == user.id).all()
return render_template('user.html',
user=user,
title='My Account',
result=result)
#changed posts=posts
@app.before_request
def before_request():
if current_user.is_authenticated:
current_user.last_seen = datetime.utcnow()
db.session.commit()
@app.route('/edit_profile', methods=['GET', 'POST'])
@login_required
def edit_profile():
form = EditProfileForm(current_user.username)
if form.validate_on_submit():
current_user.username = form.username.data
current_user.about_me = form.about_me.data
db.session.commit()
flash('Your changes have been saved.')
return redirect(url_for('edit_profile'))
elif request.method == 'GET':
form.username.data = current_user.username
form.about_me.data = current_user.about_me
return render_template('edit_profile.html',
title='Edit Profile',
form=form)
@app.route('/service')
@app.route('/services/')
@app.route('/services')
def services():
# if session.get("user_id") is None:
# return render_template("services.html", name="SignIn/SignUp")
return render_template('services.html', title='Services')
@app.route('/booked')
@login_required
def add_book():
if not current_user.is_authenticated:
return redirect(url_for('login'))
serviceId = request.args.get('serviceId')
order = Booked(services_id=serviceId, customer=current_user)
db.session.add(order)
db.session.commit()
flash('Thank You! Your service has booked, our Karigar will be on your doorstep soon!')
return redirect(url_for('services'))
@app.route('/add', methods=['GET', 'POST'])
def addService():
add_form = AddServiceForm()
if add_form.validate_on_submit():
name = Services(name=add_form.name.data, price=add_form.price.data)
db.session.add(name)
db.session.commit()
return render_template(url_for('all'))
return render_template("add.html", form=add_form)
@app.route('/all')
def all():
services = Services.query.all()
return render_template("all.html", services=services)
@app.route('/nuser')
def nuser():
return render_template("2col.html")
@app.route('/services/deepcleaning')
@app.route('/services/deepcleaning/')
def deepcleaning():
title = 'Deep Cleaning'
serviceId = Services.query.filter_by(name='Deep Cleaning').first()
return render_template("deepcleaning.html",
serviceId=serviceId,
title='Deep Cleaning')
@app.route('/services/haircut')
@app.route('/services/haircut/')
def haircut():
title = 'Haircut'
serviceId = Services.query.filter_by(name='Haircut').first()
return render_template("haircut.html",
serviceId=serviceId,
title='Haircut')
@app.route('/services/washingmachinerepair')
@app.route('/services/washingmachinerepair/')
def washingmachinerepair():
title = 'Washing Machine Repair'
serviceId = Services.query.filter_by(name='Washing Machine Repair').first()
return render_template("washingmachinerepair.html",
serviceId=serviceId,
title='Washing Machine Repair')
@app.route('/services/refrigeratorrepair')
@app.route('/services/refrigeratorrepair/')
def refrigeratorrepair():
title = 'Refrigerator Repair'
serviceId = Services.query.filter_by(name='Refrigerator Repair').first()
return render_template("refrigeratorrepair.html",
serviceId=serviceId,
title='Refrigerator Repair')
@app.route('/services/tvrepair')
@app.route('/services/tvrepair/')
def tvrepair():
title = 'TV Repair'
serviceId = Services.query.filter_by(name='TV Repair').first()
return render_template("tvrepair.html",
serviceId=serviceId,
title='TV Repair')
@app.route('/services/facial')
@app.route('/services/facial/')
def facial():
title = 'Facial'
serviceId = Services.query.filter_by(name='Facial').first()
return render_template("facial.html", serviceId=serviceId, title='Facial')
@app.route('/services/bodyspa')
@app.route('/services/bodyspa/')
def bodyspa():
title = 'Body Spa'
serviceId = Services.query.filter_by(name='Body Spa').first()
return render_template("bodyspa.html",
serviceId=serviceId,
title='Body Spa')
@app.route('/services/geyserrepair')
@app.route('/services/geyserrepair/')
def geyserrepair():
title = 'Geyser Repair'
serviceId = Services.query.filter_by(name='Geyser Repair').first()
return render_template("geyserrepair.html",
serviceId=serviceId,
title='Geyser Repair')
@app.route('/services/haircutforwomen')
@app.route('/services/haircutforwomen/')
def haircutforwomen():
title = 'Haircut for women'
serviceId = Services.query.filter_by(name='Haircut for women').first()
return render_template("haircutforwomen.html",
serviceId=serviceId,
title='Haircut for women')
@app.route('/services/bathroomcleaning')
@app.route('/services/bathroomcleaning/')
def bathroomcleaning():
title = 'Bathroom Cleaning'
serviceId = Services.query.filter_by(name='Bathroom Cleaning').first()
return render_template("bathroomcleaning.html",
serviceId=serviceId,
title='Bathroom Cleaning')
@app.route('/services/kitchencleaning')
@app.route('/services/kitchencleaning/')
def kitchencleaning():
title = 'Kitchen Cleaning'
serviceId = Services.query.filter_by(name='Kitchen Cleaning').first()
return render_template("kitchencleaning.html",
serviceId=serviceId,
title='Kitchen Cleaning')
@app.route('/services/plumber')
@app.route('/services/plumber/')
def plumber():
title = 'Plumber'
serviceId = Services.query.filter_by(name='Plumber').first()
return render_template("plumber.html",
serviceId=serviceId,
title='Plumber')
@app.route('/services/electrician')
@app.route('/services/electrician/')
def electrician():
title = 'Electrician'
serviceId = Services.query.filter_by(name='Electrician').first()
return render_template("electrician.html",
serviceId=serviceId,
title='Electrician')
@app.route('/services/painter')
@app.route('/services/painter/')
def painter():
title = 'Painter'
serviceId = Services.query.filter_by(name='Painter').first()
return render_template("painter.html",
serviceId=serviceId,
title='Painter')
@app.route('/services/carpenter')
@app.route('/services/carpenter/')
def carpenter():
title = 'Carpenter'
serviceId = Services.query.filter_by(name='Carpenter').first()
return render_template("carpenter.html",
serviceId=serviceId,
title='Carpenter')
@app.route('/services/floorcleaning')
@app.route('/services/floorcleaning/')
def floorcleaning():
title = 'Floor Cleaning'
serviceId = Services.query.filter_by(name='Floor Cleaning').first()
return render_template("floorcleaning.html",
serviceId=serviceId,
title='Floor Cleaning')
``` |
{
"source": "9ae/layer-python",
"score": 2
} |
#### File: layer-python/tests/test_send_announcement.py
```python
import datetime
from dateutil.tz import tzutc
import json
from LayerClient import LayerClient
from test_utils import MockRequestResponse, TestPlatformClient
class TestSendAnnouncement(TestPlatformClient):
def test_send_announcement(self, layerclient, monkeypatch):
sender = LayerClient.Sender('alice', 'Alice')
recipients = ['bob', 'charlie']
message_parts = [
LayerClient.MessagePart(
'Top secret message',
'text/confidential',
),
]
def verify_request_args(method, url, headers, data, params):
assert method == 'POST'
assert url == (
'https://api.layer.com/apps/TEST_APP_UUID/announcements'
)
assert headers == {
'Accept': 'application/vnd.layer+json; version=1.0',
'Authorization': 'Bearer TEST_BEARER_TOKEN',
'Content-Type': 'application/json',
}
json_data = json.loads(data)
assert json_data == {
'recipients': recipients,
'parts': [{
'body': 'Top secret message',
'mime_type': 'text/confidential',
}],
'sender': {
'name': 'Alice',
}
}
return MockRequestResponse(
True,
{
'id': 'layer:///messages/TEST_MESSAGE_UUID',
'url': 'layer:///messages/TEST_MESSAGE_UUID',
},
)
monkeypatch.setattr('requests.request', verify_request_args)
layerclient.send_announcement(
sender,
recipients,
message_parts,
)
def test_parse_response(self, layerclient, monkeypatch):
def return_sample_response(method, url, headers, data, params):
return MockRequestResponse(
True,
{
'id': (
'layer:///announcements/'
'f3cc7b32-3c92-11e4-baad-164230d1df67'
),
'url': (
'https://api.layer.com/apps/'
'24f43c32-4d95-11e4-b3a2-0fd00000020d/announcements'
'/f3cc7b32-3c92-11e4-baad-164230d1df67'
),
'sent_at': '2014-09-15T04:44:47+00:00',
'recipients': ['bob', 'charlie'],
'sender': {
'name': 'Alice',
'user_id': None
},
'parts': [
{
'body': 'Hello, World!',
'mime_type': 'text/plain'
}
]
},
)
monkeypatch.setattr('requests.request', return_sample_response)
sender = LayerClient.Sender('alice', 'Alice')
recipients = ['bob', 'charlie']
message_parts = [
LayerClient.MessagePart(
'Top secret message',
),
]
announcement = layerclient.send_announcement(
sender,
recipients,
message_parts,
)
assert announcement.uuid() == 'f3cc7b32-3c92-11e4-baad-164230d1df67'
assert announcement.sent_at == datetime.datetime(
2014, 9, 15, 4, 44, 47, tzinfo=tzutc()
)
assert announcement.recipients == ['bob', 'charlie']
assert announcement.sender.as_dict() == {
'name': 'Alice',
}
assert announcement.parts[0].body == 'Hello, World!'
assert announcement.parts[0].mime_type == 'text/plain'
``` |
{
"source": "9and3/compas",
"score": 2
} |
#### File: compas_blender/artists/__init__.py
```python
import compas_blender
from compas.plugins import plugin
from compas.artists import Artist
from compas.geometry import Box
from compas.geometry import Capsule
from compas.geometry import Circle
from compas.geometry import Cone
from compas.geometry import Curve
from compas.geometry import Cylinder
from compas.geometry import Frame
from compas.geometry import Line
from compas.geometry import Point
from compas.geometry import Polygon
from compas.geometry import Polyhedron
from compas.geometry import Polyline
from compas.geometry import Sphere
from compas.geometry import Surface
from compas.geometry import Torus
from compas.geometry import Vector
from compas.datastructures import Mesh
from compas.datastructures import Network
from compas.datastructures import VolMesh
from compas.robots import RobotModel
from .artist import BlenderArtist
from .boxartist import BoxArtist
from .capsuleartist import CapsuleArtist
from .circleartist import CircleArtist
from .coneartist import ConeArtist
from .curveartist import CurveArtist
from .cylinderartist import CylinderArtist
from .frameartist import FrameArtist
from .lineartist import LineArtist
from .meshartist import MeshArtist
from .networkartist import NetworkArtist
from .pointartist import PointArtist
from .polygonartist import PolygonArtist
from .polyhedronartist import PolyhedronArtist
from .polylineartist import PolylineArtist
from .robotmodelartist import RobotModelArtist
from .sphereartist import SphereArtist
from .surfaceartist import SurfaceArtist
from .torusartist import TorusArtist
from .vectorartist import VectorArtist
from .volmeshartist import VolMeshArtist
@plugin(category='drawing-utils', pluggable_name='clear', requires=['bpy'])
def clear_blender():
print('doing it')
compas_blender.clear()
@plugin(category='drawing-utils', pluggable_name='redraw', requires=['bpy'])
def redraw_blender():
compas_blender.redraw()
@plugin(category='factories', requires=['bpy'])
def register_artists():
Artist.register(Box, BoxArtist, context='Blender')
Artist.register(Capsule, CapsuleArtist, context='Blender')
Artist.register(Circle, CircleArtist, context='Blender')
Artist.register(Cone, ConeArtist, context='Blender')
Artist.register(Curve, CurveArtist, context='Blender')
Artist.register(Cylinder, CylinderArtist, context='Blender')
Artist.register(Frame, FrameArtist, context='Blender')
Artist.register(Line, LineArtist, context='Blender')
Artist.register(Mesh, MeshArtist, context='Blender')
Artist.register(Network, NetworkArtist, context='Blender')
Artist.register(Point, PointArtist, context='Blender')
Artist.register(Polygon, PolygonArtist, context='Blender')
Artist.register(Polyhedron, PolyhedronArtist, context='Blender')
Artist.register(Polyline, PolylineArtist, context='Blender')
Artist.register(RobotModel, RobotModelArtist, context='Blender')
Artist.register(Sphere, SphereArtist, context='Blender')
Artist.register(Surface, SurfaceArtist, context='Blender')
Artist.register(Torus, TorusArtist, context='Blender')
Artist.register(Vector, VectorArtist, context='Blender')
Artist.register(VolMesh, VolMeshArtist, context='Blender')
print('Blender Artists registered.')
__all__ = [
'BlenderArtist',
'BoxArtist',
'CapsuleArtist',
'CircleArtist',
'ConeArtist',
'CurveArtist',
'CylinderArtist',
'FrameArtist',
'LineArtist',
'MeshArtist',
'NetworkArtist',
'PointArtist',
'PolygonArtist',
'PolyhedronArtist',
'PolylineArtist',
'RobotModelArtist',
'SphereArtist',
'SurfaceArtist',
'TorusArtist',
'VectorArtist',
'VolMeshArtist',
]
``` |
{
"source": "9and3r/mopidy-frontend-for-adafruit-charlcdplate",
"score": 3
} |
#### File: mopidy-frontend-for-adafruit-charlcdplate/mopidy_frontend_for_adafruit_charlcdplate/BaseScreen.py
```python
from InputManager import InputManager
class BaseScreen:
def __init__(self, core):
self.core = core
self.update = True
self.subscreens = []
self.current_subscreen_index = -1
self.subscreen_control = False
def check_and_update(self, display_object, full_control):
if self.update:
self.update_display(display_object, full_control)
self.update = False
return True
else:
return False
def update_display(self, display_object, full_control):
pass
def resume(self):
self.update = True
def input_event(self, event):
if self.subscreen_control and self.current_subscreen_index > -1 and self.current_subscreen_index < len(self.subscreens):
if event.type == 'click' and event.key == InputManager.LEFT:
self.subscreen_control = False
self.subscreens[self.current_subscreen_index].resume()
self.resume()
return True
else:
return self.subscreens[self.current_subscreen_index].on_input_event(event)
else:
return self.on_input_event(event)
def on_input_event(self, event):
pass
# Events
def playback_state_changed(self, old_state, new_state):
for subscreen in self.subscreens:
subscreen.on_playback_state_changed(old_state, new_state)
self.on_playback_state_changed(old_state, new_state)
def on_playback_state_changed(self, old_state, new_state):
pass
def track_playback_started(self, tl_track):
for subscreen in self.subscreens:
subscreen.track_playback_started(tl_track)
self.on_track_playback_started(tl_track)
def on_track_playback_started(self, tl_track):
pass
def track_playback_ended(self, tl_track, time_position):
for subscreen in self.subscreens:
subscreen.track_playback_ended(tl_track, time_position)
self.on_track_playback_ended(tl_track, time_position)
def on_track_playback_ended(self, tl_track, time_position):
pass
def track_playback_paused(self, tl_track, time_position):
for subscreen in self.subscreens:
subscreen.track_playback_paused(tl_track, time_position)
self.on_track_playback_paused(tl_track, time_position)
def on_track_playback_paused(self, tl_track, time_position):
pass
def track_playback_resumed(self, tl_track, time_position):
for subscreen in self.subscreens:
subscreen.track_playback_resumed(tl_track, time_position)
self.on_track_playback_resumed(tl_track, time_position)
def on_track_playback_resumed(self, tl_track, time_position):
pass
def seeked(self, time_position):
for subscreen in self.subscreens:
subscreen.seeked(time_position)
self.on_seeked(time_position)
def on_seeked(self, time_position):
pass
def volume_changed(self, volume):
for subscreen in self.subscreens:
subscreen.volume_changed(volume)
self.on_volume_changed(volume)
def on_volume_changed(self, volume):
pass
def stream_title_changed(self, title):
for subscreen in self.subscreens:
subscreen.stream_title_changed(title)
self.on_stream_title_changed(title)
def on_stream_title_changed(self, title):
pass
def playlists_loaded(self):
for subscreen in self.subscreens:
subscreen.on_playlists_loaded()
self.on_playlists_loaded()
def on_playlists_loaded(self):
pass
```
#### File: mopidy-frontend-for-adafruit-charlcdplate/mopidy_frontend_for_adafruit_charlcdplate/DisplayObject.py
```python
import time
class DisplayObject:
MAX_CHARS_IN_ROW = 16
TIME_TO_UPDATE = 0.05
def __init__(self):
self.line1 = ""
self.line2 = ""
self.last_update = time.clock()
self.scroll_pos1 = 0
self.scroll_pos2 = 0
self.update_indicator1 = False
self.update_indicator2 = False
self.line1_full_text1 = None
self.line2_full_text2 = None
def change_display_data(self, line1, line2):
self.set_line1(line1)
self.set_line2(line2)
def set_line1(self, line1):
self.line1 = line1
self.scroll_pos1 = 0
if len(self.line1) > DisplayObject.MAX_CHARS_IN_ROW:
self.update_indicator1 = True
self.line1_full_text1 = line1
for i in range(0, DisplayObject.MAX_CHARS_IN_ROW/2, 1):
self.line1_full_text1 += " "
else:
self.update_indicator1 = False
self.last_update = time.clock()
def set_line2(self, line2):
self.line2 = line2
self.scroll_pos2 = 0
if len (self.line2) > DisplayObject.MAX_CHARS_IN_ROW:
self.update_indicator2 = True
self.line2_full_text2 = line2
for i in range(0, DisplayObject.MAX_CHARS_IN_ROW/2, 1):
self.line2_full_text2 += " "
else:
self.update_indicator2 = False
self.last_update = time.clock()
def update(self):
if self.update_indicator1 or self.update_indicator2:
current_time = time.clock()
if current_time - DisplayObject.TIME_TO_UPDATE > self.last_update:
self.last_update = current_time
if self.update_indicator1:
self.scroll_pos1 += 1
if self.scroll_pos1 > len(self.line1_full_text1):
self.scroll_pos1 = 0
if self.update_indicator2:
self.scroll_pos2 += 1
if self.scroll_pos2 > len(self.line2_full_text2):
self.scroll_pos2 = 0
return True
return False
def getString(self):
if self.update_indicator1:
string1 = self.line1_full_text1[self.scroll_pos1:] + self.line1_full_text1[:self.scroll_pos1]
else:
string1 = self.line1
if self.update_indicator2:
string2 = self.line2_full_text2[self.scroll_pos2:] + self.line2_full_text2[:self.scroll_pos2]
else:
string2 = self.line2
return string1[0:DisplayObject.MAX_CHARS_IN_ROW] + "\n" + string2[0:DisplayObject.MAX_CHARS_IN_ROW]
```
#### File: mopidy-frontend-for-adafruit-charlcdplate/mopidy_frontend_for_adafruit_charlcdplate/Frontend.py
```python
import threading
from time import sleep
from mopidy import core
from MainScreen import MainScreen
from InputManager import InputManager
from DisplayObject import DisplayObject
import pykka
class FrontendAdafruitCharLCDPlate(pykka.ThreadingActor, core.CoreListener):
def __init__(self, config, core):
super(FrontendAdafruitCharLCDPlate, self).__init__()
self.input_manager = InputManager()
self.display_object = DisplayObject()
if True:
import Adafruit_CharLCD as LCD
self.display = LCD.Adafruit_CharLCDPlate()
else:
from web_socket_lcd_simulator import WebSockectLCDSimulator
self.display = WebSockectLCDSimulator()
self.main_screen = MainScreen(core)
self.running = True
def on_start(self):
# Add newline
self.display.set_color(1.0, 0.0, 0.0)
self.display.create_char(0, [16, 16, 16, 16, 16, 16, 0, 0])
self.display.create_char(1, [24, 24, 24, 24, 24, 24, 0, 0])
self.display.create_char(2, [28, 28, 28, 28, 28, 28, 0, 0])
self.display.create_char(3, [30, 30, 30, 30, 30, 30, 0, 0])
self.display.create_char(4, [31, 31, 31, 31, 31, 31, 0, 0])
try:
self.display.on_start()
except AttributeError:
pass
t = threading.Thread(target=self.start_working)
t.start()
def on_stop(self):
self.running = False
try:
self.display.on_stop()
except AttributeError:
pass
def send_screen_update(self):
self.display.clear()
self.display.message(self.display_object.getString())
def start_working(self):
while self.running:
self.update()
sleep(0.03)
def update(self):
# Check inputs
for event in self.input_manager.update(self.display):
print event
self.main_screen.input_event(event)
if self.main_screen.check_and_update(self.display_object, True) or self.display_object.update():
self.send_screen_update()
# Events
def playback_state_changed(self, old_state, new_state):
self.main_screen.playback_state_changed(old_state, new_state)
def track_playback_started(self, tl_track):
self.main_screen.track_playback_started(tl_track)
def track_playback_ended(self, tl_track, time_position):
self.main_screen.track_playback_ended(tl_track, time_position)
def track_playback_paused(self, tl_track, time_position):
self.main_screen.track_playback_paused(tl_track, time_position)
def track_playback_resumed(self, tl_track, time_position):
self.main_screen.track_playback_resumed(tl_track, time_position)
def seeked(self, time_position):
self.main_screen.seeked(time_position)
def volume_changed(self, volume):
self.main_screen.volume_changed(volume)
def stream_title_changed(self, title):
self.main_screen.stream_title_changed(title)
def playlists_loaded(self):
self.main_screen.playlists_loaded()
```
#### File: mopidy-frontend-for-adafruit-charlcdplate/mopidy_frontend_for_adafruit_charlcdplate/MainScreen.py
```python
import time
from mopidy import core
from BaseScreen import BaseScreen
from DisplayObject import DisplayObject
from InputManager import InputManager
from ProgressBar import ProgressBar
from Playlists import Playlists
class MainScreen(BaseScreen):
def __init__(self, core):
BaseScreen.__init__(self, core)
self.subscreens.append(NowPlayingTrack(core))
self.subscreens.append(SeekScreen(core))
self.subscreens.append(VolumeScreen(core))
self.subscreens.append(Playlists(core))
self.current_subscreen_index = 0
self.playing = core.playback.get_state().get()
def check_and_update(self, display_object, full_screen):
return self.subscreens[self.current_subscreen_index].check_and_update(display_object, self.subscreen_control)
def on_playback_state_changed(self, old_state, new_state):
if new_state == core.PlaybackState.PLAYING:
self.playing = True
else:
self.playing = False
def update_display(self, display_object, full_control):
self.subscreens[self.current_subscreen_index].update_display(display_object, self.subscreen_control)
def on_input_event(self, event):
if event.type == 'click':
if event.key == InputManager.SELECT:
if self.current_subscreen_index == len(self.subscreens) - 1:
self.subscreen_control = True
self.subscreens[self.current_subscreen_index].resume()
else:
if self.playing:
self.core.playback.pause()
else:
self.core.playback.play()
return True
elif event.key == InputManager.UP:
self.current_subscreen_index -= 1
if self.current_subscreen_index < 0:
self.current_subscreen_index = len(self.subscreens) - 1
self.subscreens[self.current_subscreen_index].resume()
return True
elif event.key == InputManager.DOWN:
self.current_subscreen_index += 1
if self.current_subscreen_index >= len(self.subscreens):
self.current_subscreen_index = 0
self.subscreens[self.current_subscreen_index].resume()
return True
else:
return self.subscreens[self.current_subscreen_index].input_event(event)
else:
return self.subscreens[self.current_subscreen_index].input_event(event)
class NowPlayingTrack(BaseScreen):
def __init__(self, core):
BaseScreen.__init__(self, core)
self.track_name = "No track"
self.tl_track = None
def update_display(self, display_object, full_control):
if self.tl_track is not None:
display_object.change_display_data(self.track_name, NowPlayingTrack.get_artist_string(self.tl_track.track))
else:
display_object.change_display_data("No track", "")
def on_track_playback_started(self, tl_track):
self.tl_track = tl_track
self.track_name = NowPlayingTrack.get_track_name(self.tl_track.track)
self.update = True
def on_track_playback_ended(self, tl_track, time_position):
self.tl_track = None
self.track_name = "No track"
self.update = True
def on_stream_title_changed(self, title):
self.track_name = title
def on_input_event(self, event):
if event.type == 'click':
if event.key == InputManager.LEFT:
self.core.playback.previous()
elif event.key == InputManager.RIGHT:
self.core.playback.next()
@staticmethod
def get_track_name(track):
if track.name is None:
return track.uri
else:
return track.name
@staticmethod
def get_track_album_name(track):
if track.album is not None and track.album.name is not None \
and len(track.album.name) > 0:
return track.album.name
else:
return "Unknow Album"
@staticmethod
def get_artist_string(track):
artists_string = ''
for artist in track.artists:
artists_string += artist.name + ', '
if len(artists_string) > 2:
artists_string = artists_string[:-2]
elif len(artists_string) == 0:
artists_string = "Unknow Artist"
return artists_string
class SeekScreen(BaseScreen):
def __init__(self, core):
BaseScreen.__init__(self, core)
self.progress_bar = ProgressBar(0, DisplayObject.MAX_CHARS_IN_ROW, 5)
self.reference_second = 0
self.second_in_song = 0
self.current_second = 0
self.track_current_second_text = None
self.track_length_text = None
self.length = None
self.paused = False
def update_current_second(self, second):
if self.current_second != second:
self.current_second = second
self.track_current_second_text = time.strftime('%M:%S', time.gmtime(self.current_second))
return True
else:
return False
def on_track_playback_started(self, tl_track):
self.second_in_song = 0
self.reference_second = int(time.time())
self.length = tl_track.track.length / 1000
self.progress_bar.set_max(self.length)
self.track_length_text = time.strftime('%M:%S', time.gmtime(self.length))
self.update_current_second(0)
self.update = True
def on_track_playback_ended(self, tl_track, time_position):
self.length = None
self.update_current_second(0)
self.update = True
def on_track_playback_paused(self, tl_track, time_position):
self.paused = True
self.reference_second = 0
self.second_in_song = time_position / 1000
self.update_current_second(self.second_in_song)
self.progress_bar.set_value(self.current_second)
self.update = True
def on_track_playback_resumed(self, tl_track, time_position):
self.paused = False
self.second_in_song = time_position / 1000
self.reference_second = int(time.time())
self.update_current_second(self.second_in_song)
self.progress_bar.set_value(self.current_second)
self.update = True
def seeked(self, time_position):
self.second_in_song = time_position / 1000
self.reference_second = int(time.time())
self.update_current_second(self.second_in_song)
self.progress_bar.set_value(self.current_second)
self.update = True
def update_display(self, display_object, full_control):
if self.length is not None:
display_object.change_display_data(" " + self.track_current_second_text + " / " + self.track_length_text, self.progress_bar.string)
else:
display_object.change_display_data("No duration", "")
def check_and_update(self, display_object, full_control):
if self.length is not None:
# Update values
if not self.paused:
self.update_current_second(int(time.time()) - self.reference_second + self.second_in_song)
self.progress_bar.set_value(self.current_second)
else:
return self.update
if self.update or self.progress_bar.update:
self.update_display(display_object, full_control)
return True
else:
return False
class VolumeScreen(BaseScreen):
def __init__(self, core):
BaseScreen.__init__(self, core)
self.volume = core.mixer.get_volume().get()
self.progress_bar = ProgressBar(100, DisplayObject.MAX_CHARS_IN_ROW, 5)
self.progress_bar.set_value(self.volume)
def update_display(self, display_object, full_control):
display_object.change_display_data('Volume ' + str(self.volume), self.progress_bar.get_string())
def on_input_event(self, event):
if event.type == 'click':
if event.key == InputManager.RIGHT:
new_volume = self.volume + 5
if new_volume > 100:
new_volume = 100
self.core.mixer.set_volume(new_volume)
if event.key == InputManager.LEFT:
new_volume = self.volume - 5
if new_volume < 0:
new_volume = 0
self.core.mixer.set_volume(new_volume)
def on_volume_changed(self, volume):
self.volume = volume
self.progress_bar.set_value(self.volume)
self.update = True
``` |
{
"source": "9andresc/dena",
"score": 4
} |
#### File: dena/binary-tree/__init__.py
```python
import importlib
import sys
sys.path.append("./")
queue_list = importlib.import_module("queue-list")
class Node(object):
def __init__(self, value):
self.value = value
self.left = None
self.right = None
class BinaryTree(object):
def __init__(self, root, traversal_style="level_order"):
self.root = root
self.traversal_style = traversal_style
def search(self, value):
def level_order(node=self.root):
nodes_queue = queue_list.Queue()
while node:
if node.value == value:
return True
if node.left:
nodes_queue.enqueue(node.left)
if node.right:
nodes_queue.enqueue(node.right)
node = nodes_queue.dequeue()
return False
def pre_order(node=self.root, found=False):
if node:
if node.value == value:
return True
found = pre_order(node.left, found)
found = pre_order(node.right, found)
return found
def in_order(node=self.root, found=False):
if node:
found = in_order(node.left, found)
if node.value == value:
return True
found = in_order(node.right, found)
return found
def post_order(node=self.root, found=False):
if node:
found = post_order(node.left, found)
found = post_order(node.right, found)
if node.value == value:
return True
return found
return locals()[self.traversal_style]()
def print(self):
def level_order(node=self.root, traversal=""):
nodes_queue = queue_list.Queue()
while node:
traversal += str(node.value) + "-"
if node.left:
nodes_queue.enqueue(node.left)
if node.right:
nodes_queue.enqueue(node.right)
node = nodes_queue.dequeue()
return traversal
def pre_order(node=self.root, traversal=""):
if node:
traversal += str(node.value) + "-"
traversal = pre_order(node.left, traversal)
traversal = pre_order(node.right, traversal)
return traversal
def in_order(node=self.root, traversal=""):
if node:
traversal = in_order(node.left, traversal)
traversal += str(node.value) + "-"
traversal = in_order(node.right, traversal)
return traversal
def post_order(node=self.root, traversal=""):
if node:
traversal = post_order(node.left, traversal)
traversal = post_order(node.right, traversal)
traversal += str(node.value) + "-"
return traversal
return locals()[self.traversal_style]()[:-1]
```
#### File: dena/hash-table/__init__.py
```python
class HashTable(object):
def __init__(self, size):
self.size = size
self.keys = [None] * self.size
self.values = [None] * self.size
def hash(self, key):
return key % self.size
def rehash(self, hash_value):
return (hash_value + 1) % self.size
def get(self, key):
hash_value = self.hash(key)
value = None
while self.keys[hash_value] != None:
if self.keys[hash_value] == key:
value = self.values[hash_value]
break
else:
hash_value = self.rehash(hash_value)
if self.keys[hash_value] == key:
break
return value
def put(self, key, value):
hash_value = self.hash(key)
if self.keys[hash_value] == None:
self.keys[hash_value] = key
self.values[hash_value] = value
else:
if self.keys[hash_value] == key:
self.values[hash_value] = value
else:
hash_value = self.rehash(hash_value)
while self.keys[hash_value] != None and self.keys[hash_value] != key:
hash_value = self.rehash(hash_value)
if self.keys[hash_value] == None:
self.keys[hash_value] = key
self.values[hash_value] = value
else:
self.values[hash_value] = value
```
#### File: tests/heap/test.py
```python
import importlib
import sys
import unittest
sys.path.append("./")
import heap
class TestHeap(unittest.TestCase):
def setUp(self):
self.heap = heap.Heap()
def test_insert(self):
"""Tests if values were correctly added"""
self.heap.insert(3)
self.heap.insert(2)
self.heap.insert(1)
self.assertEqual(self.heap.get_min(), 1)
def test_delete(self):
"""Tests if value was correctly removed"""
self.heap.insert(3)
self.heap.insert(2)
self.heap.insert(1)
self.heap.delete(0)
self.assertEqual(self.heap.get_min(), 2)
if __name__ == "__main__":
unittest.main()
``` |
{
"source": "9ary/longoverdue",
"score": 2
} |
#### File: 9ary/longoverdue/longoverdue.py
```python
import locale
import os
import re
import subprocess
import sys
import click
# List of services not to restart automatically
NO_AUTORESTART = {"dbus.service": "reboot required",
"systemd-logind.service": "will log all users out"}
FILE_BLACKLIST = []
EXT_BLACKLIST = [".cache", ".gresource"]
PATH_REGEX = re.compile(r"^(?P<path>.*?)(?: \((?:(?:path dev=(?P<devmajor>\d+),(?P<devminor>\d+)|deleted))\))?$")
locale_encoding = locale.nl_langinfo(locale.CODESET)
euid = os.geteuid()
def color(c, bold = False):
ret = "\x1b[0;"
if c >= 0:
ret += ";38;5;{}".format(c)
if bold:
ret += ";1"
ret += "m"
return ret
def decode_nuld(nuld):
return dict((i[0], i[1:]) for i in nuld.strip("\0").split("\0"))
class Process:
def __init__(self, proc):
self.pid = proc.get("p")
self.parent = proc.get("R")
self.command = proc.get("c")
self.uid = proc.get("u")
self.gid = proc.get("g")
self.user = proc.get("L")
self.unit = None
self.uunit = None
self.files = []
class File:
def __init__(self, f):
self.fd = f.get("f")
self.mode = f.get("a")
self.lock = f.get("l")
self.type = f.get("t")
self.dev = f.get("D")
self.inode = f.get("i")
self.name = re.match(PATH_REGEX, f.get("n"))["path"]
def getprocs(pids=None):
# Get and parse a list of processes that have deleted file handles
lsof = subprocess.run(["lsof", "-dDEL", "-F0"],
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
check=True)
procs = []
for l in lsof.stdout.decode(locale_encoding).splitlines():
if l[0] == "p":
if procs and not procs[-1].files:
procs.pop()
procs.append(Process(decode_nuld(l)))
elif l[0] == "f":
f = File(decode_nuld(l))
if not f.name.startswith("/usr"):
continue
if os.path.basename(f.name) in FILE_BLACKLIST:
continue
if os.path.splitext(f.name)[1] in EXT_BLACKLIST:
continue
procs[-1].files.append(f)
if procs and not procs[-1].files:
procs.pop()
if pids:
procs = [p for p in procs if p.pid in pids]
# Find the systemd unit each process belongs to
pids = [p.pid for p in procs]
units = subprocess.run(["ps", "-o", "unit=,uunit="] + pids,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
check=True)
units = (l.split() for l in units.stdout.decode(locale_encoding).splitlines())
for proc, (unit, uunit) in zip(procs, units):
proc.unit = unit
proc.uunit = uunit
return procs
@click.group(invoke_without_command=True)
@click.pass_context
@click.option("-v", "--verbose", count=True)
def main(ctx, verbose):
"""Manage running services that need updating"""
if ctx.invoked_subcommand is None:
list_()
@main.command("list")
@click.option("-v", "--verbose", count=True)
def list_(verbose):
"""List running outdated processes"""
kernel = os.uname().release
if not os.path.exists(f"/usr/lib/modules/{kernel}"):
print(f"{color(15, True)}The running kernel ({kernel}) was not found in"
f" the file system, it may have been updated{color(-1)}")
print()
procs = getprocs()
uunits = {}
services = []
others = {}
for p in procs:
if p.uunit != "-":
if not p.user in uunits:
uunits[p.user] = []
uunits[p.user].append(p)
elif p.unit.endswith(".service"):
services.append(p)
else:
if not p.user in others:
others[p.user] = []
others[p.user].append(p)
def warn(desc):
print(f"{color(15, True)}The following {desc} "
f"{color(15, True)}may be running outdated code:{color(-1)}")
def item(name, files, warning=""):
if warning != "":
warning = f" {color(3)}({warning}){color(-1)}"
print(f"{color(15)}•{color(-1)} {name}{warning}")
if verbose:
for f in files:
print(f" {color(15)}•{color(-1)} {f.name}")
if services:
warn("services")
for p in sorted(set(services), key=lambda p: p.unit):
item(f"{p.unit} ({p.command} ({p.pid}))", p.files, NO_AUTORESTART.get(p.unit, ""))
print()
for user, units in uunits.items():
warn(f"units for user {color(12, True)}{user}")
for p in sorted(set(units), key=lambda p: p.uunit):
item(f"{p.uunit} ({p.command} ({p.pid}))", p.files)
print()
for user, procs in others.items():
warn(f"processes for user {color(12, True)}{user}")
for p in sorted(set(procs), key=lambda p: p.command):
item(f"{p.command} ({p.pid})", p.files)
print()
@main.command()
def restart():
"""Restart outdated services"""
procs = getprocs()
userservices = set()
services = set()
for proc in procs:
if proc.uunit != "-":
if proc.uunit.endswith(".service"):
userservices.add(proc.uunit)
elif proc.unit.endswith(".service"):
if proc.unit not in NO_AUTORESTART:
services.add(proc.unit)
command = []
if euid == 0 and services:
try:
command = ["systemctl", "daemon-reload"]
print(" ".join(command))
subprocess.run(command, check=True)
command = ["systemctl", "restart"] + list(services)
print(" ".join(command))
subprocess.run(command, check=True)
except subprocess.CalledProcessError:
sys.exit(1)
elif euid != 0 and userservices:
try:
command = ["systemctl", "--user", "daemon-reload"]
print(" ".join(command))
subprocess.run(command, check=True)
command = ["systemctl", "--user", "restart"] + list(userservices)
print(" ".join(command))
subprocess.run(command, check=True)
except subprocess.CalledProcessError:
sys.exit(1)
@main.command()
@click.argument("regex")
def info(regex):
"""Get details on a process"""
prgrep = ["pgrep", regex]
if euid != 0:
prgrep.extend(["-u", str(euid)])
try:
pids = subprocess.run(prgrep, stdout=subprocess.PIPE, check=True)
except subprocess.CalledProcessError:
print(f"{color(15, True)}No process matched {color(12, True)}{regex}"
f"{color(15, True)}.{color(-1)}")
sys.exit(1)
pids = [pid.strip() for pid in pids.stdout.decode(locale_encoding).splitlines()]
try:
procs = getprocs(pids)
except subprocess.CalledProcessError:
print("Couldn't retrieve process info.")
sys.exit(1)
files = sorted(set((f.name for p in procs for f in p.files)))
if files:
print(f"{color(12, True)}{regex}{color(15, True)} is using the "
f"following outdated binaries:{color(-1)}")
for f in files:
print(f"{color(15)}•{color(-1)} {f}")
else:
print(f"{color(12, True)}{regex}{color(15, True)} appears to be "
f"running updated binaries.{color(-1)}")
if __name__ == "__main__":
main()
``` |
{
"source": "9at8/pyright",
"score": 4
} |
#### File: tests/samples/typedDict6.py
```python
from typing import TypedDict
Movie = TypedDict("Movie", {"name": str, "year": int})
# This should generate an error because
# the arguments are missing.
Movie2 = TypedDict()
# This should generate an error because
# the arguments are missing.
Movie3 = TypedDict("Movie3")
# This should generate an error because
# the argument type is wrong.
Movie4 = TypedDict("Movie4", 3)
# This should generate an error because
# the argument type is wrong.
Movie5 = TypedDict(3, {})
Movie6 = TypedDict("Movie6", {}, total=False)
Movie7 = TypedDict("Movie7", {}, total=True)
# This should generate an error because the total param
# accepts only True or False.
Movie8 = TypedDict("Movie8", {}, total=3)
# This should generate an error because the third arg
# is unknown.
Movie9 = TypedDict("Movie9", {}, random=3)
# This should generate an error because the third arg
# is unknown.
Movie10 = TypedDict("Movie10", {}, 3)
# This should generate an error because a fourth arg
# is not supported.
Movie11 = TypedDict("Movie11", {}, total=True, foo=3)
def get_movie_name(movie: Movie):
return movie["name"]
name2 = get_movie_name({"name": "ET", "year": 1982})
movie1: Movie = {"name": "<NAME>", "year": 1982}
movie2: Movie = {
"name": "<NAME>",
# This should generate an error because
# the type is incorrect.
"year": "1982",
}
movie3: Movie = {
# This should generate an error because
# all keys are required.
"name": "<NAME>"
}
movie4: Movie = {
# This should generate an error because
# the key name is not supported.
"name2": "<NAME>"
}
MovieNotTotal = TypedDict("MovieNotTotal", {"name": str, "year": int}, total=False)
movie5: MovieNotTotal = {"name": "Blade Runner"}
unknown_str_value: str = "blah"
a = movie5[unknown_str_value]
``` |
{
"source": "9b/app-strap",
"score": 3
} |
#### File: app/core/auth.py
```python
from . import core
from .. import mongo, logger
from ..core.forms import LoginForm, RegisterForm
from ..models.user import User
from flask import current_app as app
from flask import render_template, redirect, url_for, request
from flask_login import login_user, logout_user
from werkzeug.security import generate_password_hash
@core.route('/login', methods=['GET', 'POST'])
def login():
"""Handle the login process."""
form = LoginForm(request.form)
if request.method == 'POST' and form.validate():
c = mongo.db[app.config['USERS_COLLECTION']]
user = c.find_one({"username": form.username.data})
logger.debug("User: %s" % user)
if user and User.validate_login(user['password'], form.password.data):
user_obj = User(user)
login_user(user_obj, remember=True)
next = request.args.get('next')
return redirect(next or url_for('core.root'))
errors = ','.join([value[0] for value in form.errors.values()])
return render_template('login.html', message=errors)
@core.route('/logout')
def logout():
"""Handle the logout process."""
logout_user()
return redirect(url_for('core.login'))
@core.route('/register', methods=['GET', 'POST'])
def register():
"""Render the register page."""
form = RegisterForm(request.form)
if request.method == 'POST' and form.validate():
c = mongo.db[app.config['USERS_COLLECTION']]
user = {
"username": form.username.data,
"email": form.email.data,
"first_name": form.first_name.data,
"last_name": form.last_name.data,
'password': generate_password_hash(form.password.data)
}
logger.debug("User: %s" % user)
_id = c.insert(user)
next = request.args.get('next')
return redirect(next or url_for('core.login'))
errors = ','.join([value[0] for value in form.errors.values()])
return render_template('register.html', message=errors)
@core.route('/forgot-password')
def forgot_password():
"""Handle the forgot password process."""
# TODO: Implement a forgot password function
return redirect(url_for('core.login'))
```
#### File: app/core/generic.py
```python
from . import core
from .. import mongo, logger, celery
from flask import (
render_template, redirect, url_for, jsonify, request, Response
)
from flask_login import login_required, current_user
from flask import current_app as app
from .forms import AccountSettingsForm, ChangePasswordForm
from ..utils.helpers import paranoid_clean
from bson.objectid import ObjectId
from werkzeug.security import generate_password_hash
@core.route('/')
@login_required
def root():
"""Render the index page."""
logger.debug("User: %s" % (current_user.get_id()))
c = mongo.db[app.config['USERS_COLLECTION']]
user = c.find_one({'username': current_user.get_id()})
return render_template('index.html', name=user.get('first_name'))
@core.route('/async-test')
@login_required
def heartbeat_example():
"""Run an async job in the background."""
logger.debug("Executing the heartbeat task and returning")
celery.send_task('heartbeat')
return render_template('index.html', name="HEARTBEAT")
@core.route('/settings')
@login_required
def settings():
"""Render the settings page."""
c = mongo.db[app.config['USERS_COLLECTION']]
user = c.find_one({'username': current_user.get_id()})
if not user:
return render_template()
user['id'] = str(user['_id'])
user.pop('_id', None)
return render_template('settings.html', user=user)
@core.route('/account/settings/update', methods=['POST'])
@login_required
def update_account():
"""Update account settings."""
logger.debug("User account settings update")
form = AccountSettingsForm(request.form)
if form.validate():
if 'user_id' not in request.form:
return jsonify({'success': False,
'error': 'ID not found in edit!'})
logger.debug("Form validated")
edit_id = paranoid_clean(request.form.get('user_id'))
c = mongo.db[app.config['USERS_COLLECTION']]
item = {'first_name': form.first_name.data,
'last_name': form.last_name.data,
'email': form.email.data}
c.update({'_id': ObjectId(edit_id)}, {'$set': item})
logger.debug("User account updated")
return redirect(url_for('core.settings'))
errors = ','.join([value[0] for value in form.errors.values()])
return jsonify({'errors': errors})
@core.route('/account/settings/change-password', methods=['POST'])
@login_required
def account_change_password():
"""Update account password."""
form = ChangePasswordForm(request.form)
if form.validate():
if 'user_id' not in request.form:
return jsonify({'success': False,
'error': 'ID not found in edit!'})
edit_id = paranoid_clean(request.form.get('user_id'))
c = mongo.db[app.config['USERS_COLLECTION']]
item = {'password': <PASSWORD>_password_hash(form.password.data)}
c.update({'_id': ObjectId(edit_id)}, {'$set': item})
return redirect(url_for('core.settings'))
errors = ','.join([value[0] for value in form.errors.values()])
return jsonify({'errors': errors})
```
#### File: app/models/user.py
```python
from werkzeug.security import check_password_hash
class User():
"""User class used in the login process."""
def __init__(self, user):
self.username = user.get('username')
self.email = user.get('email')
self.first_name = user.get('first_name')
self.last_name = user.get('last_name')
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.username
def get_name(self):
return self.first_name + " " + self.last_name
@staticmethod
def validate_login(password_hash, password):
return check_password_hash(password_hash, password)
``` |
{
"source": "9b/chirp",
"score": 3
} |
#### File: app/scripts/fix-data-type.py
```python
from bson.objectid import ObjectId
def mongo_connect(host, port, database, collection):
"""Connect to a mongo instance."""
from pymongo import MongoClient
return MongoClient(host, port)[database][collection]
def main():
"""."""
db = mongo_connect('localhost', 27017, 'chirp', 'monitors')
for item in db.find(dict()):
metadata = item['metadata'][0]
db.update({'_id': ObjectId(item['_id'])}, {'$set': {'metadata': metadata}})
if __name__ == "__main__":
main()
``` |
{
"source": "9b/malpdfobj",
"score": 3
} |
#### File: 9b/malpdfobj/hash_maker.py
```python
import hashlib
import json
def get_hash_data(file, type):
if type == "md5":
output = hashlib.md5()
elif type == "sha1":
output = hashlib.sha1()
elif type == "sha256":
output = hashlib.sha256()
else:
output = "Error"
with open(file,'rb') as f:
for chunk in iter(lambda: f.read(8192), ''):
output.update(chunk)
return output.hexdigest()
#build generic object for the file hash data
def get_hash_object(file):
md5 = get_hash_data(file, "md5")
sha1 = get_hash_data(file, "sha1")
sha256 = get_hash_data(file, "sha256")
hashes = { 'md5': md5, 'sha1': sha1, 'sha256': sha256 }
return hashes
```
#### File: 9b/malpdfobj/related_entropy.py
```python
import math
import json
import os
import optparse
def H(data):
entropy = 0
for x in range(256):
p_x = float(data.count(chr(x)))/len(data)
if p_x > 0:
entropy += - p_x*math.log(p_x, 2)
return entropy
def bytes_from_file(filename, chunksize=32):
with open(filename, "rb") as f:
while True:
chunk = f.read(chunksize)
if chunk:
data = str(H(chunk)) + ',' + str(f.tell())
yield data
else:
break
def entropy_offsets(f):
total = []
for b in bytes_from_file(f):
total.append(b)
return total
def compare_ent(f1, f2, t):
count = 0
x = 0
total = []
for pair in f1:
data = pair.split(',')
ent = data[0].rstrip()
off = data[1].rstrip()
if x < len(f2):
data = f2[x].split(',')
ent_ = data[0].rstrip()
off_ = data[1].rstrip()
if count <= 5:
if ent == ent_:
count +=1
value = abs(float(ent) - float(ent_))
if float(value) < float(t):
count += 1
else:
count = 0
else:
count = 0
offset_pair = off + "," + off_
total.append(offset_pair)
x += 1
return total
def shot_caller(file):
res = entropy_offsets(file)
files = []
results = []
dir = '/home/bsdixon/PDFs/files/'
dirlist = os.listdir(dir)
for fname in dirlist:
if fname != "." or fname != "..":
files.append(dir + fname)
files.sort()
for file in files:
res2 = entropy_offsets(file)
match_points = compare_ent(res, res2, .2)
if len(match_points) > 5:
preobj = { 'file' : file, 'offsets' : match_points }
results.append(preobj)
return results
``` |
{
"source": "9bow/pytorch.github.io",
"score": 3
} |
#### File: pytorch.github.io/scripts/gen_published_versions.py
```python
import json
from urllib.request import urlopen
from typing import Any, Dict, Optional, Union
class ConfigStr:
version: str
conf_type: str
os: str
accel: str
extra: str
@staticmethod
def parse(val: str) -> "ConfigStr":
vals = val.split(",")
assert len(vals) == 5
rc = ConfigStr()
for k, v in zip(["version", "conf_type", "os", "accel", "extra"], vals):
rc.__setattr__(k, v)
return rc
def __repr__(self) -> str:
return self.__dict__.__repr__()
class LibTorchInstruction:
note: Optional[str]
versions: Union[Dict[str, str], str, None]
def __init__(self, note: Optional[str] = None, versions: Union[Dict[str, str], str, None] = None) -> None:
self.note = note
self.versions = versions
@staticmethod
def parse(val: str) -> "LibTorchInstruction":
import re
href_pattern = re.compile("<a href=\'([^']*)\'>([^<]*)</a>")
line_separator = "<br />"
lines = val.split(line_separator)
versions = {}
idx_to_delete = set()
for idx, line in enumerate(lines):
url = href_pattern.findall(line)
if len(url) == 0:
continue
# There should be only one URL per line and value inside and outside of URL shoudl match
assert len(url) == 1
assert url[0][0] == url[0][1].rstrip(), url
versions[lines[idx - 1].strip()] = url[0][0]
idx_to_delete.add(idx - 1)
idx_to_delete.add(idx)
lines = [lines[idx] for idx in range(len(lines)) if idx not in idx_to_delete]
if len(lines) == 1 and len(lines[0]) == 0:
lines = []
return LibTorchInstruction(note=line_separator.join(lines) if len(lines) > 0 else None,
versions=versions if len(versions) > 0 else None)
def __repr__(self) -> str:
return self.__dict__.__repr__()
class PyTorchInstruction:
note: Optional[str]
command: Optional[str]
def __init__(self, note: Optional[str] = None, command: Optional[str] = None) -> None:
self.note = note
self.command = command
@staticmethod
def parse(val: str) -> "PyTorchInstruction":
def is_cmd(cmd: str) -> bool:
return cmd.startswith("pip3 install") or cmd.startswith("conda install")
line_separator = "<br />"
lines = val.split(line_separator)
if is_cmd(lines[-1]):
note = line_separator.join(lines[:-1]) if len(lines) > 1 else None
command = lines[-1]
elif is_cmd(lines[0]):
note = line_separator.join(lines[1:]) if len(lines) > 1 else None
command = lines[0]
else:
note = val
command = None
return PyTorchInstruction(note=note, command=command)
def __repr__(self) -> str:
return self.__dict__.__repr__()
class PublishedAccVersion:
libtorch: Dict[str, LibTorchInstruction]
conda: Dict[str, PyTorchInstruction]
pip: Dict[str, PyTorchInstruction]
def __init__(self):
self.pip = dict()
self.conda = dict()
self.libtorch = dict()
def __repr__(self) -> str:
return self.__dict__.__repr__()
def add_instruction(self, conf: ConfigStr, val: str) -> None:
if conf.conf_type == "libtorch":
self.libtorch[conf.accel] = LibTorchInstruction.parse(val)
elif conf.conf_type == "conda":
self.conda[conf.accel] = PyTorchInstruction.parse(val)
elif conf.conf_type == "pip":
self.pip[conf.accel] = PyTorchInstruction.parse(val)
else:
raise RuntimeError(f"Unknown config type {conf.conf_type}")
class PublishedOSVersion:
linux: PublishedAccVersion
macos: PublishedAccVersion
windows: PublishedAccVersion
def __init__(self):
self.linux = PublishedAccVersion()
self.macos = PublishedAccVersion()
self.windows = PublishedAccVersion()
def add_instruction(self, conf: ConfigStr, val: str) -> None:
if conf.os == "linux":
self.linux.add_instruction(conf, val)
elif conf.os == "macos":
self.macos.add_instruction(conf, val)
elif conf.os == "windows":
self.windows.add_instruction(conf, val)
else:
raise RuntimeError(f"Unknown os type {conf.os}")
def __repr__(self) -> str:
return self.__dict__.__repr__()
class PublishedVersions:
latest_stable: str
latest_lts: str
versions: Dict[str, PublishedOSVersion] = dict()
def __init__(self, latest_stable: str, latest_lts: str) -> None:
self.latest_stable = latest_stable
self.latest_lts = latest_lts
self.versions = dict()
def parse_objects(self, objects: Dict[str, str]) -> None:
for key, val in objects.items():
conf = ConfigStr.parse(key)
if conf.version not in self.versions:
self.versions[conf.version] = PublishedOSVersion()
self.versions[conf.version].add_instruction(conf, val)
if 'stable' in self.versions:
self.versions[self.latest_stable] = self.versions.pop('stable')
if 'lts' in self.versions:
self.versions[self.latest_lts] = self.versions.pop('lts')
def get_objects(commit_hash: str = "0ba2a203045bc94d165d52e56c87ceaa463f4284") -> Dict[str, str]:
"""
Extract install commands as they are currently hardcoded
in pytorch.github.io/assets/quick-start-module.js
"""
raw_base = "raw.githubusercontent.com"
obj_start = "var object = {"
obj_end = "};"
with urlopen(f"https://{raw_base}/pytorch/pytorch.github.io/{commit_hash}/assets/quick-start-module.js") as url:
raw_data = url.read().decode("latin1")
start_idx = raw_data.find(obj_start)
end_idx = raw_data.find(obj_end, start_idx)
# Adjust start end end indexes
start_idx = raw_data.find("{", start_idx, end_idx)
end_idx = raw_data.rfind('"', start_idx, end_idx)
if any(x < 0 for x in [start_idx, end_idx]):
raise RuntimeError("Unexpected raw_data")
return json.loads(raw_data[start_idx:end_idx] + '"}')
def dump_to_file(fname: str, o: Any) -> None:
class DictEncoder(json.JSONEncoder):
def default(self, o):
return o.__dict__
with open(fname, "w") as fp:
json.dump(o, fp, indent=2, cls=DictEncoder)
def main() -> None:
install_objects = get_objects()
rc = PublishedVersions(latest_stable="1.9.0", latest_lts="lts-1.8.2")
rc.parse_objects(install_objects)
dump_to_file("published_versions.json", rc)
if __name__ == "__main__":
main()
``` |
{
"source": "9bow/PyTorch-Tutorials-KR",
"score": 2
} |
#### File: _downloads/3829e7d2fa2343bb4bd51456f33d3f84/fgsm_tutorial.py
```python
from __future__ import print_function
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import numpy as np
import matplotlib.pyplot as plt
# NOTE: 아래는 MNIST 데이터셋을 내려받을 때 "User-agent" 관련한 제한을 푸는 코드입니다.
# 더 자세한 내용은 https://github.com/pytorch/vision/issues/3497 을 참고해주세요.
from six.moves import urllib
opener = urllib.request.build_opener()
opener.addheaders = [('User-agent', 'Mozilla/5.0')]
urllib.request.install_opener(opener)
######################################################################
# 구현
# --------------
#
# 이 섹션에서는 튜토리얼의 입력 매개 변수에 대해 설명하고 공격중인 모델을
# 정의한 다음 공격을 코딩하고 일부 테스트를 실행합니다.
#
# 입력
# ~~~~~~
#
# 이 학습서에는 입력이 3 개이며 다음과 같이 정의됩니다:
#
# - **epsilons** - 실행에 사용할 엡실론의 리스트입니다. 엡실론 0의 값은 원래 테스트 셋의 모델 성능을
# 나타내므로 목록에 유지하는 것이 중요합니다. 또한 직관적으로 엡실론이 클수록 작은 변화가 더 눈에 띄지만
# 모델 정확도를 저하 시키는 측면에서 더 효과가 있습니다. 여기서 데이터의 범위는 0-1 이기 때문에
# 엡실론의 값은 1을 초과할 수 없습니다.
#
# - **pretrained_model** - `pytorch/examples/mnist <https://github.com/pytorch/examples/tree/master/mnist>`__
# 를 통해 미리 학습된 MNIST 모델의 경로.
# 튜토리얼을 간편하게 하려면 `여기 <https://drive.google.com/drive/folders/1fn83DF14tWmit0RTKWRhPq5uVXt73e0h?usp=sharing>`__ 에서 미리 학습된 모델을 다운로드하세요.
#
# - **use_cuda** - CUDA 를 사용할지 말지 정하는 이진 플래그.
# 본 튜토리얼에서는 CPU 시간이 오래 걸리지 않으므로 CUDA를 지원하는 GPU 의 여부는 중요하지 않습니다.
#
epsilons = [0, .05, .1, .15, .2, .25, .3]
pretrained_model = "data/lenet_mnist_model.pth"
use_cuda=True
######################################################################
# 공격을 받는 모델
# ~~~~~~~~~~~~~~~~~~
#
# 앞서 말한대로, 공격을 받는 모델은 `pytorch/examples/mnist <https://github.com/pytorch/examples/tree/master/mnist>`__
# 와 동일한 MNIST 모델입니다. 본인의 MNIST 모델을 학습 및 저장하는 방식으로 하거나 제공된 모델을 다운로드 해 사용하는 식으로 진행할 수 있습니다.
# 여기서 *Net* 정의 및 테스트 데이터 로더는 MNIST 예제에서 복사 하였습니다.
# 이 섹션의 목적은 모델과 데이터 로더를 정의한 다음, 모델을 초기화하고 미리 학습된 가중치를 읽어오는 것입니다.
#
# LeNet 모델 정의
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.conv2_drop = nn.Dropout2d()
self.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 10)
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), 2))
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
x = x.view(-1, 320)
x = F.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.log_softmax(x, dim=1)
# MNIST 테스트 데이터셋과 데이터로더 선언
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('../data', train=False, download=True, transform=transforms.Compose([
transforms.ToTensor(),
])),
batch_size=1, shuffle=True)
# 어떤 디바이스를 사용할지 정의
print("CUDA Available: ",torch.cuda.is_available())
device = torch.device("cuda" if (use_cuda and torch.cuda.is_available()) else "cpu")
# 모델 초기화하기
model = Net().to(device)
# 미리 학습된 모델 읽어오기
model.load_state_dict(torch.load(pretrained_model, map_location='cpu'))
# 모델을 평가 모드로 설정하기. 드롭아웃 레이어들을 위해 사용됨
model.eval()
######################################################################
# FGSM 공격
# ~~~~~~~~~~~
#
# 이제 원래 입력을 교란시켜 적대적인 예를 만드는 함수를 정의 할 수 있습니다.
# ``fgsm_attack`` 함수는 입력 파라미터로 3가지를 가집니다. 첫번째는 원본 *이미지* ( :math:`x` ),
# 두번째는 *엡실론* 으로 픽셀 단위의 작은 변화를 주는 값입니다 ( :math:`\epsilon` ).
# 마지막은 *data_grad* 로 입력 영상 ( :math:`\nabla_{x} J(\mathbf{\theta}, \mathbf{x}, y)` ) 에 대한 변화도 손실 값입니다.
# 아래 식에 따른 작은 변화가 적용된 이미지를 생성합니다.
#
# .. math:: perturbed\_image = image + epsilon*sign(data\_grad) = x + \epsilon * sign(\nabla_{x} J(\mathbf{\theta}, \mathbf{x}, y))
#
# 마지막으로 데이터의 원래 범위를 유지하기 위해, 작은 변화가 적용된 이미지가 :math:`[0,1]` 범위로 잘립니다.
#
# FGSM 공격 코드
def fgsm_attack(image, epsilon, data_grad):
# data_grad 의 요소별 부호 값을 얻어옵니다
sign_data_grad = data_grad.sign()
# 입력 이미지의 각 픽셀에 sign_data_grad 를 적용해 작은 변화가 적용된 이미지를 생성합니다
perturbed_image = image + epsilon*sign_data_grad
# 값 범위를 [0,1]로 유지하기 위해 자르기(clipping)를 추가합니다
perturbed_image = torch.clamp(perturbed_image, 0, 1)
# 작은 변화가 적용된 이미지를 리턴합니다
return perturbed_image
######################################################################
# 테스팅 함수
# ~~~~~~~~~~~~~~~~
#
# 마지막으로 본 튜토리얼의 핵심 결과는 ``테스트`` 함수에서 오게 됩니다.
# 이 테스트 기능을 호출 할 때마다 MNIST 테스트 셋에서 전체 테스트 단계를 수행하고 최종 정확도를 보고합니다.
# 그러나 이 함수에는 *엡실론* 입력도 필요합니다. 이는 ``테스트`` 함수가 :math:`\epsilon` 크기에 따라 공격자의 공격을 받는 모델의
# 정확도을 보고하기 때문입니다. 더 구체적으로 보면 테스트 셋의 각각의 샘플에서 테스트 함수는 입력 데이터에 대한 손실 변화도( :math:`data\_grad` )를 계산하고,
# ``FGSM 공격`` (:math:`perturbed\_data`) 을 받은 작은 변화가 적용된 이미지를 만들고 나서 작은 변화가 적용된 이미지가 적대적인지 확인을 합니다.
# 추가로 모델의 정확도를 테스트하기 위해서 테스트 함수는 나중에 시각화하여 볼 수 있도록 성공적으로 얻은 적대적 이미지를 저장하고 반환합니다.
#
def test( model, device, test_loader, epsilon ):
# 정확도 카운터
correct = 0
adv_examples = []
# 테스트 셋의 모든 예제에 대해 루프를 돕니다
for data, target in test_loader:
# 디바이스(CPU or GPU) 에 데이터와 라벨 값을 보냅니다
data, target = data.to(device), target.to(device)
# 텐서의 속성 중 requires_grad 를 설정합니다. 공격에서 중요한 부분입니다
data.requires_grad = True
# 데이터를 모델에 통과시킵니다
output = model(data)
init_pred = output.max(1, keepdim=True)[1] # 로그 확률의 최대값을 가지는 인덱스를 얻습니다
# 만약 초기 예측이 틀리면, 공격하지 않도록 하고 계속 진행합니다
if init_pred.item() != target.item():
continue
# 손실을 계산합니다
loss = F.nll_loss(output, target)
# 모델의 변화도들을 전부 0으로 설정합니다
model.zero_grad()
# 후방 전달을 통해 모델의 변화도를 계산합니다
loss.backward()
# 변화도 값을 모읍니다
data_grad = data.grad.data
# FGSM 공격을 호출합니다
perturbed_data = fgsm_attack(data, epsilon, data_grad)
# 작은 변화가 적용된 이미지에 대해 재분류합니다
output = model(perturbed_data)
# 올바른지 확인합니다
final_pred = output.max(1, keepdim=True)[1] # 로그 확률의 최대값을 가지는 인덱스를 얻습니다
if final_pred.item() == target.item():
correct += 1
# 0 엡실론 예제에 대해서 저장합니다
if (epsilon == 0) and (len(adv_examples) < 5):
adv_ex = perturbed_data.squeeze().detach().cpu().numpy()
adv_examples.append( (init_pred.item(), final_pred.item(), adv_ex) )
else:
# 추후 시각화를 위하 다른 예제들을 저장합니다
if len(adv_examples) < 5:
adv_ex = perturbed_data.squeeze().detach().cpu().numpy()
adv_examples.append( (init_pred.item(), final_pred.item(), adv_ex) )
# 해당 엡실론에서의 최종 정확도를 계산합니다
final_acc = correct/float(len(test_loader))
print("Epsilon: {}\tTest Accuracy = {} / {} = {}".format(epsilon, correct, len(test_loader), final_acc))
# 정확도와 적대적 예제를 리턴합니다
return final_acc, adv_examples
######################################################################
# 공격 실행
# ~~~~~~~~~~
#
# 구현의 마지막 부분은 공격을 실행하는 것입니다. 여기서 전체 테스트 스텝을 각 *엡실론* 값에 실행합니다.
# 각 엡실론마다 최종 정확도와 성공적인 일부 적대 사례를 저장하여 다음 섹션에 표시합니다.
# 엡실론 값이 증가함에 따라 출력된 정확도가 어떻게 감소하는지 보십시오.
# 또한, :math:`\epsilon=0` 인 경우에는 공격이 없는 원본 테스트 정확도임을 보입니다.
#
accuracies = []
examples = []
# 각 엡실론에 대해 테스트 함수를 실행합니다
for eps in epsilons:
acc, ex = test(model, device, test_loader, eps)
accuracies.append(acc)
examples.append(ex)
######################################################################
# 결과
# -------
#
# 정확도 vs 엡실론
# ~~~~~~~~~~~~~~~~~~~
#
# 첫 번째 결과는 정확도 vs 엡실론 을 도식화 한 것 입니다.
# 앞에서 언급했듯이, 엡실론이 증가함에 따라 우리는 테스트 정확도가 감소할 것으로 예상합니다.
# 이는 학습을 더 진행해 갈수록 엡실론이 클수록 손실을 극대화 할 방향으로 진행되기 때문입니다.
# 엡실론 값이 선형적으로 분포하더라도 곡선의 추세는 선형의 형태가 아닙니다.
# 예를 들면, math:`\epsilon=0.05` 에서의 정확도가 :math:`\epsilon=0` 보다 약 4% 낮지만
# :math:`\epsilon=0.2` 에서의 정확도는 :math:`\epsilon=0.15` 보다 약 25% 정도 낮습니다.
# 또한, :math:`\epsilon=0.25` 와 :math:`\epsilon=0.3` 사이의 모델 정확도는 랜덤으로
# 10개중 1개를 선택했을 때의 정확도와 유사한 수준입니다.
#
plt.figure(figsize=(5,5))
plt.plot(epsilons, accuracies, "*-")
plt.yticks(np.arange(0, 1.1, step=0.1))
plt.xticks(np.arange(0, .35, step=0.05))
plt.title("Accuracy vs Epsilon")
plt.xlabel("Epsilon")
plt.ylabel("Accuracy")
plt.show()
######################################################################
# 샘플 적대적 예제들
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
# 공짜 점심은 없다는 것을 기억하시나요? 이 경우에는 엡실론이 증가할수록 테스트 정확도는 떨어집니다.
# **그러나** 작은 변화는 더 쉽게 인식할 수 있게 됩니다.
# 실제로 정확도 저하와 공격자가 고려해야 하는 이해도 사이에는 상충 관계(tradeoff)가 있습니다.
# 여기서 우리는 각 엡실론 값에서 성공적인 대적 사례를 보이는 몇 가지 예를 보겠습니다.
# 아래 이미지의 첫번째로 열은 :math:`\epsilon=0` 인 예제들로 작은 변화가 없는 원본의 "깨끗한" 이미지들을 나타냅니다.
# 각 이미지의 위의 글자는 "원래 분류 결과 -> 적대적 분류 결과"를 나타냅니다.
# :math:`\epsilon=0.15` 에서 작은 변화가 눈에 띄기 시작하고 :math:`\epsilon=0.3` 에서는 확실해 보입니다.
# 그러나 모든 경우에 대해서 노이즈가 추가되었더라도 사람은 올바르게 분류를 수행할 수 있습니다.
#
# 각 엡실론에서 적대적 샘플의 몇 가지 예를 도식화합니다
cnt = 0
plt.figure(figsize=(8,10))
for i in range(len(epsilons)):
for j in range(len(examples[i])):
cnt += 1
plt.subplot(len(epsilons),len(examples[0]),cnt)
plt.xticks([], [])
plt.yticks([], [])
if j == 0:
plt.ylabel("Eps: {}".format(epsilons[i]), fontsize=14)
orig,adv,ex = examples[i][j]
plt.title("{} -> {}".format(orig, adv))
plt.imshow(ex, cmap="gray")
plt.tight_layout()
plt.show()
######################################################################
# 다음 단계는?
# -----------------
#
# 이번 튜토리얼에서 적대적 머신 러닝에 대한 통찰을 얻을 수 있었기를 바랍니다.
# 튜토리얼의 내용으로부터 앞으로 더 많은 것들을 알아나갈 수 있습니다.
# 튜토리얼의 적대적 공격 예제는 본 분야의 초급 단계이며
# 적대적 상황으로부터 ML 모델을 공격하고 방어하는 방법에 대한 많은 후속 아이디어가 있습니다.
# 사실 NIPS 2017 에서 적대적 공격과 방어에 대한 경쟁(competition)이 있었고 여기서 사용된
# 다양한 방법들은 다음 논문에 정리 되어 있습니다: `적대적 공격과 방어 경쟁 <https://arxiv.org/pdf/1804.00097.pdf>`__.
# 방어에 대한 연구는 자연스럽게 교란 및 해킹 목적으로 제작된 입력에 대해 머신 러닝 모델을
# 보다 *견고하게(robust)* 만드는 아이디어로 이어집니다.
#
# 또 다른 방향은 다른 도메인에서의 적의 공격과 방어입니다. 적대적 연구는 이미지 도메인에 제한되어 있지 않습니다.
# `여기 <https://arxiv.org/pdf/1801.01944.pdf>`__ 에서 음성-텍스트 변환 모델에서의 공격도 확인할 수 있습니다.
# 그러나 적대적 머신 러닝 분야에 대해서 많은 것을 알기 위한 최고의 방법은 많이 시도해보는 것입니다.
# NIPS 2017 경쟁에서 소개된 다양한 공격 방법을 직접 구현해 보고, FGSM 과 어떤 점이 다른지 연구해 보세요.
# 그리고 나서 직접 만든 공격으로부터 모델을 방어해 보세요.
#
```
#### File: PyTorch-Tutorials-KR/intermediate_source/mario_rl_tutorial.py
```python
import torch
from torch import nn
from torchvision import transforms as T
from PIL import Image
import numpy as np
from pathlib import Path
from collections import deque
import random, datetime, os, copy
# Gym은 강화학습을 위한 OpenAI 툴킷입니다.
import gym
from gym.spaces import Box
from gym.wrappers import FrameStack
# OpenAI Gym을 위한 NES 에뮬레이터
from nes_py.wrappers import JoypadSpace
# OpenAI Gym에서의 슈퍼 마리오 환경 세팅
import gym_super_mario_bros
######################################################################
# 강화학습 개념
# """"""""""""""""""
#
# **환경(Environment)** : 에이전트가 상호작용하며 스스로 배우는 세계입니다.
#
# **행동(Action)** :math:`a` : 에이전트가 환경에 어떻게 응답하는지 행동을 통해 나타냅니다.
# 가능한 모든 행동의 집합을 *행동 공간* 이라고 합니다.
#
# **상태(State)** :math:`s` : 환경의 현재 특성을 상태를 통해 나타냅니다.
# 환경이 있을 수 있는 모든 가능한 상태 집합을 *상태 공간* 이라고 합니다.
#
# **포상(Reward)** :math:`r` : 포상은 환경에서 에이전트로 전달되는 핵심 피드백입니다.
# 에이전트가 학습하고 향후 행동을 변경하도록 유도하는 것입니다.
# 여러 시간 단계에 걸친 포상의 합을 **리턴(Return)** 이라고 합니다.
#
# **최적의 행동-가치 함수(Action-Value function)** :math:`Q^*(s,a)` : 상태 :math:`s`
# 에서 시작하면 예상되는 리턴을 반환하고, 임의의 행동 :math:`a`
# 를 선택합니다. 그리고 각각의 미래의 단계에서 포상의 합을 극대화하는 행동을 선택하도록 합니다.
# :math:`Q` 는 상태에서 행동의 “품질”
# 을 나타냅니다. 우리는 이 함수를 근사 시키려고 합니다.
#
######################################################################
# 환경(Environment)
# """"""""""""""""""""
#
# 환경 초기화하기
# ------------------------
#
# 마리오 게임에서 환경은 튜브, 버섯, 그 이외 다른 여러 요소들로 구성되어 있습니다.
#
# 마리오가 행동을 취하면, 환경은 변경된 (다음)상태, 포상 그리고
# 다른 정보들로 응답합니다.
#
# 슈퍼 마리오 환경 초기화하기
env = gym_super_mario_bros.make("SuperMarioBros-1-1-v0")
# 상태 공간을 2가지로 제한하기
# 0. 오른쪽으로 걷기
# 1. 오른쪽으로 점프하기
env = JoypadSpace(env, [["right"], ["right", "A"]])
env.reset()
next_state, reward, done, info = env.step(action=0)
print(f"{next_state.shape},\n {reward},\n {done},\n {info}")
######################################################################
# 환경 전처리 과정 거치기
# ------------------------
#
# ``다음 상태(next_state)`` 에서 환경 데이터가 에이전트로 반환됩니다.
# 앞서 살펴보았듯이, 각각의 상태는 ``[3, 240, 256]`` 의 배열로 나타내고 있습니다.
# 종종 상태가 제공하는 것은 에이전트가 필요로 하는 것보다 더 많은 정보입니다.
# 예를 들어, 마리오의 행동은 파이프의 색깔이나 하늘의 색깔에 좌우되지 않습니다!
#
# 아래에 설명할 클래스들은 환경 데이터를 에이전트에 보내기 전 단계에서 전처리 과정에 사용할
# **래퍼(Wrappers)** 입니다.
#
# ``GrayScaleObservation`` 은 RGB 이미지를 흑백 이미지로 바꾸는 일반적인 래퍼입니다.
# ``GrayScaleObservation`` 클래스를 사용하면 유용한 정보를 잃지 않고 상태의 크기를 줄일 수 있습니다.
# ``GrayScaleObservation`` 를 적용하면 각각 상태의 크기는
# ``[1, 240, 256]`` 이 됩니다.
#
# ``ResizeObservation`` 은 각각의 상태(Observation)를 정사각형 이미지로 다운 샘플링합니다.
# 이 래퍼를 적용하면 각각 상태의 크기는 ``[1, 84, 84]`` 이 됩니다.
#
# ``SkipFrame`` 은 ``gym.Wrapper`` 으로부터 상속을 받은 사용자 지정 클래스이고,
# ``step()`` 함수를 구현합니다. 왜냐하면 연속되는 프레임은 큰 차이가 없기 때문에
# n개의 중간 프레임을 큰 정보의 손실 없이 건너뛸 수 있기 때문입니다.
# n번째 프레임은 건너뛴 각 프레임에 걸쳐 누적된 포상을
# 집계합니다.
#
# ``FrameStack`` 은 환경의 연속 프레임을
# 단일 관찰 지점으로 바꾸어 학습 모델에 제공할 수 있는 래퍼입니다.
# 이렇게 하면 마리오가 착지 중이였는지 또는 점프 중이었는지
# 이전 몇 프레임의 움직임 방향에 따라 확인할 수
# 있습니다.
#
class SkipFrame(gym.Wrapper):
def __init__(self, env, skip):
"""모든 `skip` 프레임만 반환합니다."""
super().__init__(env)
self._skip = skip
def step(self, action):
"""행동을 반복하고 포상을 더합니다."""
total_reward = 0.0
done = False
for i in range(self._skip):
# 포상을 누적하고 동일한 작업을 반복합니다.
obs, reward, done, info = self.env.step(action)
total_reward += reward
if done:
break
return obs, total_reward, done, info
class GrayScaleObservation(gym.ObservationWrapper):
def __init__(self, env):
super().__init__(env)
obs_shape = self.observation_space.shape[:2]
self.observation_space = Box(low=0, high=255, shape=obs_shape, dtype=np.uint8)
def permute_orientation(self, observation):
# [H, W, C] 배열을 [C, H, W] 텐서로 바꿉니다.
observation = np.transpose(observation, (2, 0, 1))
observation = torch.tensor(observation.copy(), dtype=torch.float)
return observation
def observation(self, observation):
observation = self.permute_orientation(observation)
transform = T.Grayscale()
observation = transform(observation)
return observation
class ResizeObservation(gym.ObservationWrapper):
def __init__(self, env, shape):
super().__init__(env)
if isinstance(shape, int):
self.shape = (shape, shape)
else:
self.shape = tuple(shape)
obs_shape = self.shape + self.observation_space.shape[2:]
self.observation_space = Box(low=0, high=255, shape=obs_shape, dtype=np.uint8)
def observation(self, observation):
transforms = T.Compose(
[T.Resize(self.shape), T.Normalize(0, 255)]
)
observation = transforms(observation).squeeze(0)
return observation
# 래퍼를 환경에 적용합니다.
env = SkipFrame(env, skip=4)
env = GrayScaleObservation(env)
env = ResizeObservation(env, shape=84)
env = FrameStack(env, num_stack=4)
######################################################################
# 앞서 소개한 래퍼를 환경에 적용한 후,
# 최종 래핑 상태는 왼쪽 아래 이미지에 표시된 것처럼 4개의 연속된 흑백 프레임으로
# 구성됩니다. 마리오가 행동을 할 때마다,
# 환경은 이 구조의 상태로 응답합니다.
# 구조는 ``[4, 84, 84]`` 크기의 3차원 배열로 구성되어 있습니다.
#
# .. figure:: /_static/img/mario_env.png
# :alt: picture
#
#
######################################################################
# 에이전트(Agent)
# """""""""""""""""
#
# ``Mario`` 라는 클래스를 이 게임의 에이전트로 생성합니다.
# 마리오는 다음과 같은 기능을 할 수 있어야 합니다.
#
# - **행동(Act)** 은 (환경의) 현재 상태를 기반으로
# 최적의 행동 정책에 따라 정해집니다.
#
# - 경험을 **기억(Remember)** 하는 것.
# 경험은 (현재 상태, 현재 행동, 포상, 다음 상태) 로 이루어져 있습니다.
# 마리오는 그의 행동 정책을 업데이트 하기 위해 *캐시(caches)* 를 한 다음, 그의 경험을 *리콜(recalls)* 합니다.
#
# - **학습(Learn)** 을 통해 시간이 지남에 따라 더 나은 행동 정책을 택합니다.
#
class Mario:
def __init__():
pass
def act(self, state):
"""상태가 주어지면, 입실론-그리디 행동(epsilon-greedy action)을 선택해야 합니다."""
pass
def cache(self, experience):
"""메모리에 경험을 추가합니다."""
pass
def recall(self):
"""메모리로부터 경험을 샘플링합니다."""
pass
def learn(self):
"""일련의 경험들로 실시간 행동 가치(online action value) (Q) 함수를 업데이트 합니다."""
pass
######################################################################
# 이번 섹션에서는 마리오 클래스의 매개변수를 채우고,
# 마리오 클래스의 함수들을 정의하겠습니다.
#
######################################################################
# 행동하기(Act)
# --------------
#
# 주어진 상태에 대해, 에이전트는 최적의 행동을 이용할 것인지
# 임의의 행동을 선택하여 분석할 것인지 선택할 수 있습니다.
#
# 마리오는 임의의 행동을 선택했을 때 ``self.exploration_rate`` 를 활용합니다.
# 최적의 행동을 이용한다고 했을 때, 그는 최적의 행동을 수행하기 위해
# (``학습하기(Learn)`` 섹션에서 구현된) ``MarioNet`` 이 필요합니다.
#
class Mario:
def __init__(self, state_dim, action_dim, save_dir):
self.state_dim = state_dim
self.action_dim = action_dim
self.save_dir = save_dir
self.use_cuda = torch.cuda.is_available()
# 마리오의 DNN은 최적의 행동을 예측합니다 - 이는 학습하기 섹션에서 구현합니다.
self.net = MarioNet(self.state_dim, self.action_dim).float()
if self.use_cuda:
self.net = self.net.to(device="cuda")
self.exploration_rate = 1
self.exploration_rate_decay = 0.99999975
self.exploration_rate_min = 0.1
self.curr_step = 0
self.save_every = 5e5 # Mario Net 저장 사이의 경험 횟수
def act(self, state):
"""
주어진 상태에서, 입실론-그리디 행동(epsilon-greedy action)을 선택하고, 스텝의 값을 업데이트 합니다.
입력값:
state(LazyFrame): 현재 상태에서의 단일 상태(observation)값을 말합니다. 차원은 (state_dim)입니다.
출력값:
action_idx (int): Mario가 수행할 행동을 나타내는 정수 값입니다.
"""
# 임의의 행동을 선택하기
if np.random.rand() < self.exploration_rate:
action_idx = np.random.randint(self.action_dim)
# 최적의 행동을 이용하기
else:
state = state.__array__()
if self.use_cuda:
state = torch.tensor(state).cuda()
else:
state = torch.tensor(state)
state = state.unsqueeze(0)
action_values = self.net(state, model="online")
action_idx = torch.argmax(action_values, axis=1).item()
# exploration_rate 감소하기
self.exploration_rate *= self.exploration_rate_decay
self.exploration_rate = max(self.exploration_rate_min, self.exploration_rate)
# 스텝 수 증가하기
self.curr_step += 1
return action_idx
######################################################################
# 캐시(Cache)와 리콜(Recall)하기
# ------------------------------
#
# 이 두가지 함수는 마리오의 “메모리” 프로세스 역할을 합니다.
#
# ``cache()``: 마리오가 행동을 할 때마다, 그는
# ``경험`` 을 그의 메모리에 저장합니다. 그의 경험에는 현재 *상태* 에 따른 수행된
# *행동* , 행동으로부터 얻은 *포상* , *다음 상태*,
# 그리고 게임 *완료* 여부가 포함됩니다.
#
# ``recall()``: Mario는 자신의 기억에서 무작위로 일련의 경험을 샘플링하여
# 게임을 학습하는 데 사용합니다.
#
class Mario(Mario): # 연속성을 위한 하위 클래스입니다.
def __init__(self, state_dim, action_dim, save_dir):
super().__init__(state_dim, action_dim, save_dir)
self.memory = deque(maxlen=100000)
self.batch_size = 32
def cache(self, state, next_state, action, reward, done):
"""
Store the experience to self.memory (replay buffer)
입력값:
state (LazyFrame),
next_state (LazyFrame),
action (int),
reward (float),
done (bool))
"""
state = state.__array__()
next_state = next_state.__array__()
if self.use_cuda:
state = torch.tensor(state).cuda()
next_state = torch.tensor(next_state).cuda()
action = torch.tensor([action]).cuda()
reward = torch.tensor([reward]).cuda()
done = torch.tensor([done]).cuda()
else:
state = torch.tensor(state)
next_state = torch.tensor(next_state)
action = torch.tensor([action])
reward = torch.tensor([reward])
done = torch.tensor([done])
self.memory.append((state, next_state, action, reward, done,))
def recall(self):
"""
메모리에서 일련의 경험들을 검색합니다.
"""
batch = random.sample(self.memory, self.batch_size)
state, next_state, action, reward, done = map(torch.stack, zip(*batch))
return state, next_state, action.squeeze(), reward.squeeze(), done.squeeze()
######################################################################
# 학습하기(Learn)
# -----------------
#
# 마리오는 `DDQN 알고리즘 <https://arxiv.org/pdf/1509.06461>`__
# 을 사용합니다. DDQN 두개의 ConvNets ( :math:`Q_{online}` 과
# :math:`Q_{target}` ) 을 사용하고, 독립적으로 최적의 행동-가치 함수에
# 근사 시키려고 합니다.
#
# 구현을 할 때, 특징 생성기에서 ``특징들`` 을 :math:`Q_{online}` 와 :math:`Q_{target}`
# 에 공유합니다. 그러나 각각의 FC 분류기는
# 가지고 있도록 설계합니다. :math:`\theta_{target}` (:math:`Q_{target}`
# 의 매개변수 값) 는 역전파에 의해 값이 업데이트 되지 않도록 고정되었습니다.
# 대신, :math:`\theta_{online}` 와 주기적으로 동기화를 진행합니다.
# 이것에 대해서는 추후에 다루도록 하겠습니다.)
#
# 신경망
# ~~~~~~~~~~~~~~~~~~
class MarioNet(nn.Module):
"""작은 cnn 구조
입력 -> (conv2d + relu) x 3 -> flatten -> (dense + relu) x 2 -> 출력
"""
def __init__(self, input_dim, output_dim):
super().__init__()
c, h, w = input_dim
if h != 84:
raise ValueError(f"Expecting input height: 84, got: {h}")
if w != 84:
raise ValueError(f"Expecting input width: 84, got: {w}")
self.online = nn.Sequential(
nn.Conv2d(in_channels=c, out_channels=32, kernel_size=8, stride=4),
nn.ReLU(),
nn.Conv2d(in_channels=32, out_channels=64, kernel_size=4, stride=2),
nn.ReLU(),
nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1),
nn.ReLU(),
nn.Flatten(),
nn.Linear(3136, 512),
nn.ReLU(),
nn.Linear(512, output_dim),
)
self.target = copy.deepcopy(self.online)
# Q_target 매개변수 값은 고정시킵니다.
for p in self.target.parameters():
p.requires_grad = False
def forward(self, input, model):
if model == "online":
return self.online(input)
elif model == "target":
return self.target(input)
######################################################################
# TD 추정 & TD 목표값
# ~~~~~~~~~~~~~~~~~~~~~~~~~~
#
# 학습을 하는데 두 가지 값들이 포함됩니다.
#
# **TD 추정** - 주어진 상태 :math:`s` 에서 최적의 예측 :math:`Q^*`.
#
# .. math::
#
#
# {TD}_e = Q_{online}^*(s,a)
#
# **TD 목표** - 현재의 포상과 다음상태 :math:`s'` 에서 추정된 :math:`Q^*` 의 합.
#
# .. math::
#
#
# a' = argmax_{a} Q_{online}(s', a)
#
# .. math::
#
#
# {TD}_t = r + \gamma Q_{target}^*(s',a')
#
# 다음 행동 :math:`a'` 가 어떨지 모르기 때문에
# 다음 상태 :math:`s'` 에서 :math:`Q_{online}` 값이 최대가 되도록 하는
# 행동 :math:`a'` 를 사용합니다.
#
# 여기에서 변화도 계산을 비활성화하기 위해
# ``td_target()`` 에서 `@torch.no_grad() <https://pytorch.org/docs/stable/generated/torch.no_grad.html#no-grad>`__
# 데코레이터(decorator)를 사용합니다.
# (:math:`\theta_{target}` 의 역전파 계산이 필요로 하지 않기 때문입니다.)
#
class Mario(Mario):
def __init__(self, state_dim, action_dim, save_dir):
super().__init__(state_dim, action_dim, save_dir)
self.gamma = 0.9
def td_estimate(self, state, action):
current_Q = self.net(state, model="online")[
np.arange(0, self.batch_size), action
] # Q_online(s,a)
return current_Q
@torch.no_grad()
def td_target(self, reward, next_state, done):
next_state_Q = self.net(next_state, model="online")
best_action = torch.argmax(next_state_Q, axis=1)
next_Q = self.net(next_state, model="target")[
np.arange(0, self.batch_size), best_action
]
return (reward + (1 - done.float()) * self.gamma * next_Q).float()
######################################################################
# 모델을 업데이트 하기.
# ~~~~~~~~~~~~~~~~~~~~~~
#
# 마리오가 재생 버퍼에서 입력을 샘플링할 때, :math:`TD_t`
# 와 :math:`TD_e` 를 계산합니다. 그리고 이 손실을 이용하여 :math:`Q_{online}` 역전파하여
# 매개변수 :math:`\theta_{online}` 를 업데이트합니다. (:math:`\alpha` 는
# ``optimizer`` 에 전달되는 학습률 ``lr`` 입니다.)
#
# .. math::
#
#
# \theta_{online} \leftarrow \theta_{online} + \alpha \nabla(TD_e - TD_t)
#
# :math:`\theta_{target}` 은 역전파를 통해 업데이트 되지 않습니다.
# 대신, 주기적으로 :math:`\theta_{online}` 의 값을 :math:`\theta_{target}`
# 로 복사합니다.
#
# .. math::
#
#
# \theta_{target} \leftarrow \theta_{online}
#
#
class Mario(Mario):
def __init__(self, state_dim, action_dim, save_dir):
super().__init__(state_dim, action_dim, save_dir)
self.optimizer = torch.optim.Adam(self.net.parameters(), lr=0.00025)
self.loss_fn = torch.nn.SmoothL1Loss()
def update_Q_online(self, td_estimate, td_target):
loss = self.loss_fn(td_estimate, td_target)
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
return loss.item()
def sync_Q_target(self):
self.net.target.load_state_dict(self.net.online.state_dict())
######################################################################
# 체크포인트를 저장합니다.
# ~~~~~~~~~~~~~~~~~~~~~~~
#
class Mario(Mario):
def save(self):
save_path = (
self.save_dir / f"mario_net_{int(self.curr_step // self.save_every)}.chkpt"
)
torch.save(
dict(model=self.net.state_dict(), exploration_rate=self.exploration_rate),
save_path,
)
print(f"MarioNet saved to {save_path} at step {self.curr_step}")
######################################################################
# 모든 기능을 종합해봅시다.
# ~~~~~~~~~~~~~~~~~~~~~~~~~~
#
class Mario(Mario):
def __init__(self, state_dim, action_dim, save_dir):
super().__init__(state_dim, action_dim, save_dir)
self.burnin = 1e4 # 학습을 진행하기 전 최소한의 경험값.
self.learn_every = 3 # Q_online 업데이트 사이의 경험 횟수.
self.sync_every = 1e4 # Q_target과 Q_online sync 사이의 경험 수
def learn(self):
if self.curr_step % self.sync_every == 0:
self.sync_Q_target()
if self.curr_step % self.save_every == 0:
self.save()
if self.curr_step < self.burnin:
return None, None
if self.curr_step % self.learn_every != 0:
return None, None
# 메모리로부터 샘플링을 합니다.
state, next_state, action, reward, done = self.recall()
# TD 추정값을 가져옵니다.
td_est = self.td_estimate(state, action)
# TD 목표값을 가져옵니다.
td_tgt = self.td_target(reward, next_state, done)
# 실시간 Q(Q_online)을 통해 역전파 손실을 계산합니다.
loss = self.update_Q_online(td_est, td_tgt)
return (td_est.mean().item(), loss)
######################################################################
# 기록하기
# --------------
#
import numpy as np
import time, datetime
import matplotlib.pyplot as plt
class MetricLogger:
def __init__(self, save_dir):
self.save_log = save_dir / "log"
with open(self.save_log, "w") as f:
f.write(
f"{'Episode':>8}{'Step':>8}{'Epsilon':>10}{'MeanReward':>15}"
f"{'MeanLength':>15}{'MeanLoss':>15}{'MeanQValue':>15}"
f"{'TimeDelta':>15}{'Time':>20}\n"
)
self.ep_rewards_plot = save_dir / "reward_plot.jpg"
self.ep_lengths_plot = save_dir / "length_plot.jpg"
self.ep_avg_losses_plot = save_dir / "loss_plot.jpg"
self.ep_avg_qs_plot = save_dir / "q_plot.jpg"
# 지표(Metric)와 관련된 리스트입니다.
self.ep_rewards = []
self.ep_lengths = []
self.ep_avg_losses = []
self.ep_avg_qs = []
# 모든 record() 함수를 호출한 후 이동 평균(Moving average)을 계산합니다.
self.moving_avg_ep_rewards = []
self.moving_avg_ep_lengths = []
self.moving_avg_ep_avg_losses = []
self.moving_avg_ep_avg_qs = []
# 현재 에피스드에 대한 지표를 기록합니다.
self.init_episode()
# 시간에 대한 기록입니다.
self.record_time = time.time()
def log_step(self, reward, loss, q):
self.curr_ep_reward += reward
self.curr_ep_length += 1
if loss:
self.curr_ep_loss += loss
self.curr_ep_q += q
self.curr_ep_loss_length += 1
def log_episode(self):
"에피스드의 끝을 표시합니다."
self.ep_rewards.append(self.curr_ep_reward)
self.ep_lengths.append(self.curr_ep_length)
if self.curr_ep_loss_length == 0:
ep_avg_loss = 0
ep_avg_q = 0
else:
ep_avg_loss = np.round(self.curr_ep_loss / self.curr_ep_loss_length, 5)
ep_avg_q = np.round(self.curr_ep_q / self.curr_ep_loss_length, 5)
self.ep_avg_losses.append(ep_avg_loss)
self.ep_avg_qs.append(ep_avg_q)
self.init_episode()
def init_episode(self):
self.curr_ep_reward = 0.0
self.curr_ep_length = 0
self.curr_ep_loss = 0.0
self.curr_ep_q = 0.0
self.curr_ep_loss_length = 0
def record(self, episode, epsilon, step):
mean_ep_reward = np.round(np.mean(self.ep_rewards[-100:]), 3)
mean_ep_length = np.round(np.mean(self.ep_lengths[-100:]), 3)
mean_ep_loss = np.round(np.mean(self.ep_avg_losses[-100:]), 3)
mean_ep_q = np.round(np.mean(self.ep_avg_qs[-100:]), 3)
self.moving_avg_ep_rewards.append(mean_ep_reward)
self.moving_avg_ep_lengths.append(mean_ep_length)
self.moving_avg_ep_avg_losses.append(mean_ep_loss)
self.moving_avg_ep_avg_qs.append(mean_ep_q)
last_record_time = self.record_time
self.record_time = time.time()
time_since_last_record = np.round(self.record_time - last_record_time, 3)
print(
f"Episode {episode} - "
f"Step {step} - "
f"Epsilon {epsilon} - "
f"Mean Reward {mean_ep_reward} - "
f"Mean Length {mean_ep_length} - "
f"Mean Loss {mean_ep_loss} - "
f"Mean Q Value {mean_ep_q} - "
f"Time Delta {time_since_last_record} - "
f"Time {datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S')}"
)
with open(self.save_log, "a") as f:
f.write(
f"{episode:8d}{step:8d}{epsilon:10.3f}"
f"{mean_ep_reward:15.3f}{mean_ep_length:15.3f}{mean_ep_loss:15.3f}{mean_ep_q:15.3f}"
f"{time_since_last_record:15.3f}"
f"{datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S'):>20}\n"
)
for metric in ["ep_rewards", "ep_lengths", "ep_avg_losses", "ep_avg_qs"]:
plt.plot(getattr(self, f"moving_avg_{metric}"))
plt.savefig(getattr(self, f"{metric}_plot"))
plt.clf()
######################################################################
# 게임을 실행시켜봅시다!
# """""""""""""""""""
#
# 이번 예제에서는 10개의 에피소드에 대해 학습 루프를 실행시켰습니다.하지만 마리오가 진정으로
# 세계를 학습하기 위해서는 적어도 40000개의 에피소드에 대해 학습을 시킬 것을 제안합니다!
#
use_cuda = torch.cuda.is_available()
print(f"Using CUDA: {use_cuda}")
print()
save_dir = Path("checkpoints") / datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
save_dir.mkdir(parents=True)
mario = Mario(state_dim=(4, 84, 84), action_dim=env.action_space.n, save_dir=save_dir)
logger = MetricLogger(save_dir)
episodes = 10
for e in range(episodes):
state = env.reset()
# 게임을 실행시켜봅시다!
while True:
# 현재 상태에서 에이전트 실행하기
action = mario.act(state)
# 에이전트가 액션 수행하기
next_state, reward, done, info = env.step(action)
# 기억하기
mario.cache(state, next_state, action, reward, done)
# 배우기
q, loss = mario.learn()
# 기록하기
logger.log_step(reward, loss, q)
# 상태 업데이트하기
state = next_state
# 게임이 끝났는지 확인하기
if done or info["flag_get"]:
break
logger.log_episode()
if e % 20 == 0:
logger.record(episode=e, epsilon=mario.exploration_rate, step=mario.curr_step)
######################################################################
# 결론
# """""""""""""""
#
# 이 튜토리얼에서는 PyTorch를 사용하여 게임 플레이 AI를 훈련하는 방법을 살펴보았습니다. `OpenAI gym <https://gym.openai.com/>`__
# 에 있는 어떤 게임이든 동일한 방법으로 AI를 훈련시키고 게임을 진행할 수 있습니다. 이 튜토리얼이 도움이 되었기를 바라며,
# `Github 저장소 <https://github.com/yuansongFeng/MadMario/>`__ 에서 편하게 저자들에게 연락을 하셔도 됩니다!
``` |
{
"source": "9b/pastycake",
"score": 2
} |
#### File: pastycake/example/config.py
```python
from pastycake.mongodb_backend import MongoBackend
from pastycake.mailer import Mailer
from pastycake.pastie_source import PastieSource
backend = MongoBackend(host='127.0.0.3', username='abc',
password='<PASSWORD>')
def _my_awesome_kw_filter(text):
#TODO: investigate why the file-level re import doesn't seem to work
import re
res = []
tmp = re.search('username', text, re.I)
if tmp:
res.append(tmp.group())
tmp = re.search('password', text, re.I)
if tmp:
res.append(tmp.group())
tmp = re.search('p[0Oo]rn', text, re.I)
if tmp:
res = []
return None if 2 != len(res) else ','.join(res)
keywords = ['foo', 'bar', _my_awesome_kw_filter]
listeners = [Mailer('foo@bar')]
sources = [PastieSource()]
```
#### File: pastycake/pastycake/mailer.py
```python
import smtplib
import socket
import sys
import louie as L
from email.mime.text import MIMEText
from .notifier import Notifier
class Mailer(Notifier):
def __init__(self, recv, sender=None):
self._recv = recv
self._sender = sender
L.connect(self._handle_match, signal='match', sender=L.Any)
def _handle_match(self, *args, **kwargs):
self.sendmail(url=kwargs.get('url', ''),
matcher=kwargs.get('match', ''),
data=kwargs.get('data', ''))
def sendmail(self, url, matcher, data):
sender = self._sender or "pastycake@" + socket.gethostname()
recv = self._recv
subject = "[PastyCake] " + url + " matched " + matcher
try:
text = str(data)
except:
text = ''
msg = MIMEText(text)
msg['subject'] = subject
msg['From'] = sender
msg['To'] = recv
server = smtplib.SMTP("localhost")
try:
server.sendmail(sender, recv, msg.as_string())
server.close()
except smtplib.SMTPException as e:
print >> sys.stderr, "Unable to send email. Error: %s" % e
```
#### File: pastycake/pastycake/storage_backend.py
```python
import abc
class StorageBackend:
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def already_visited_url(self, url):
'''
@return True if the url has been visited already, False otherwise
'''
raise NotImplemented()
@abc.abstractmethod
def save_url(self, url, match_text=None):
'''
store the url (together with match_text) as having been visited.
'''
raise NotImplemented()
@abc.abstractmethod
def connect(self, *condetails, **kwargs):
'''
connect with the given condetails (and/or kwargs) to the backend.
'''
raise NotImplemented()
@abc.abstractmethod
def connected(self):
'''
@return True if a valid connection was established, False otherwise
'''
``` |
{
"source": "9b/pyhottop",
"score": 3
} |
#### File: pyhottop/cli/config.py
```python
__author__ = "<NAME>"
__copyright__ = "Copyright, Split Key Coffee"
__credits__ = ["<NAME>"]
__license__ = "MIT"
__version__ = "0.1.0"
__maintainer__ = "<NAME> (<EMAIL>)"
__email__ = "<EMAIL>"
__status__ = "BETA"
import sys
from pyhottop.pyhottop import Hottop, SerialConnectionError
from argparse import ArgumentParser
def main():
"""Run the core."""
parser = ArgumentParser()
subs = parser.add_subparsers(dest='cmd')
setup_parser = subs.add_parser('test')
setup_parser.add_argument('--interface', default=None,
help='Manually pass in the USB connection.')
args = parser.parse_args()
if args.cmd == 'test':
ht = Hottop()
try:
if args.interface:
ht.connect(interface=args.interface)
ht.connect()
except SerialConnectionError as e:
print("[!] Serial interface not accessible: %s" % str(e))
sys.exit(1)
print("[*] Successfully connected to the roaster!")
if __name__ == '__main__':
main()
``` |
{
"source": "9b/pynetinfo",
"score": 2
} |
#### File: netinfo/cli/client.py
```python
import json
import logging
import os
import sys
from collections import OrderedDict
from argparse import ArgumentParser
from netinfo import Netinfo
CONFIG_PATH = os.path.expanduser('~/.config/backscatter')
CONFIG_FILE = os.path.join(CONFIG_PATH, 'config.json')
CONFIG_DEFAULTS = {'version': 'v0', 'api_key': ''}
URL = 'http://localhost:7777'
def main():
"""Run the core."""
parser = ArgumentParser()
subs = parser.add_subparsers(dest='cmd')
setup_parser = subs.add_parser('enrich', description="Enrich addresses with data.")
setup_parser.add_argument('-q', '--query', dest='query', required=True,
help='Query to search with.', type=str)
setup_parser.add_argument('-t', '--query-type', dest='query_type', required=True,
help='Query type to search with.', type=str)
args = parser.parse_args()
if not args.cmd:
parser.print_help()
ni = Netinfo(URL)
if args.cmd == 'enrich':
response = ni.enrich(query=args.query, query_type=args.query_type)
print(json.dumps(response, indent=4))
``` |
{
"source": "9b/split-key-roast",
"score": 2
} |
#### File: app/core/history.py
```python
from . import core
from .. import mongo
from ..libs.utils import paranoid_clean, now_date, load_date
from bson.objectid import ObjectId
from flask import current_app as app
from flask import render_template, jsonify, request
from flask_login import login_required, current_user
@core.route('/history')
@login_required
def history():
"""Render the history page."""
c = mongo.db[app.config['HISTORY_COLLECTION']]
items = c.find({'user': current_user.get_id()})
output = list()
for x in items:
x['id'] = str(x['_id'])
x['rest_days'] = (now_date(False) - load_date(x['date'])).days
output.append(x)
output.sort(key=lambda x: x['end_time'], reverse=True)
return render_template('history.html', history=output)
@core.route('/history/remove-item', methods=['POST'])
@login_required
def remove_history():
"""Remove a roast from history."""
args = request.get_json()
if 'id' not in args:
return jsonify({'success': False, 'error': 'ID not found in request!'})
c = mongo.db[app.config['HISTORY_COLLECTION']]
remove_id = paranoid_clean(args.get('id'))
c.remove({'_id': ObjectId(remove_id)})
return jsonify({'success': True})
```
#### File: split-key-roast/app/__init__.py
```python
from flask import current_app as app
from flask import Flask, redirect, url_for
from flask_login import LoginManager, current_user
from flask_pymongo import PyMongo
from flask_socketio import SocketIO
from .models.const import creatives
from .models.user import User
from .libs.utils import now_date
from pyhottop.pyhottop import Hottop
# from libs.hottop_thread import Hottop
import copy
import eventlet
import logging
import os
import random
import socketio
import sys
from redis import Redis
mgr = socketio.RedisManager('redis://' + os.environ.get('REDIS_HOST'))
sio = SocketIO(client_manager=mgr)
login_manager = LoginManager()
mongo = PyMongo()
ht = Hottop()
logger = logging.getLogger("cloud_cafe")
logger.setLevel(logging.DEBUG)
shandler = logging.StreamHandler(sys.stdout)
fmt = '\033[1;32m%(levelname)-5s %(module)s:%(funcName)s():'
fmt += '%(lineno)d %(asctime)s\033[0m| %(message)s'
shandler.setFormatter(logging.Formatter(fmt))
logger.addHandler(shandler)
eventlet.monkey_patch()
# Must import post monkey patching to avoid issues with requests library
import twitter
def tweet_hook(func):
"""Decorate to run tweets if the integration is enabled."""
def wrapper(*args, **kwargs):
results = func(*args, **kwargs)
c = mongo.db[app.config['USERS_COLLECTION']]
user = c.find_one({"username": current_user.get_id()})
integrations = user.get('integrations')
bot = integrations.get('twitter_bot')
if not bot.get('status'):
return results
# if app.config['SIMULATE_ROAST']:
# return results
creative_ref = copy.deepcopy(creatives)
action = func.__name__
base = creative_ref.get(func.__name__)
creative = None
media = None
if action == 'on_start_monitor' and bot.get('tweet_roast_begin'):
state = results['state']
creative = base[random.randint(0, len(base) - 1)]
creative += " %s grams of %s " % (
state['input_weight'], state['coffee'])
if action == 'on_stop_monitor' and bot.get('tweet_roast_complete'):
state = results['state']
creative = base[random.randint(0, len(base) - 1)]
creative += " Total time: %s " % (state['duration'])
if (action in ['on_first_crack', 'on_second_crack', 'on_drop']) \
and (bot.get('tweet_roast_progress')):
state = results['state']
last = state['last']
creative = base[random.randint(0, len(base) - 1)]
creative += " State: ET %d, BT %d, Time %s " % (
last['environment_temp'], last['bean_temp'],
results['state']['duration'])
if (action == 'on_shutdown' and bot.get('tweet_roast_complete')):
creative = base[random.randint(0, len(base) - 1)]
creative += " "
media_path = os.path.dirname(__file__) + "/resources/tmp/"
media = media_path + now_date(str=True) + "-roast.png"
if not creative:
# Didn't trigger any of the actions or they weren't enabled
return results
tags = 0
tag_count = random.randint(2, 8)
hashtags = creative_ref.get('hash_tags')
while len(creative) <= 250:
if tags == tag_count:
break
hashtag = hashtags[random.randint(0, len(hashtags) - 1)]
creative += hashtag + " "
hashtags.remove(hashtag)
tags += 1
# Tweeting code
api = twitter.Api(consumer_key=str(bot.get('consumer_key')),
consumer_secret=str(bot.get('consumer_secret')),
access_token_key=str(bot.get('access_token_key')),
access_token_secret=str(bot.get('access_token_secret')))
try:
creative = str(creative, "utf-8")
except:
creative = str(creative)
try:
if not media:
api.PostUpdate(creative)
else:
api.PostUpdate(creative, media=open(media, 'rb'))
except Exception as e:
logger.error(str(e))
return results
return wrapper
@login_manager.user_loader
def load_user(username):
"""Create a manager to reload sessions.
:param username: Username of the logged in user
:type username: str
:returns: User
"""
from flask import current_app as app
c = mongo.db[app.config['USERS_COLLECTION']]
u = c.find_one({"username": username})
if not u:
return None
return User(u)
@login_manager.unauthorized_handler
def unauthorized():
"""Redirect unauthorized users to the login page."""
return redirect(url_for('core.login'))
def create_app(debug=False, simulate=False):
"""Create an application context with blueprints."""
app = Flask(__name__, static_folder='./resources')
app.config['SECRET_KEY'] = 'iqR2cYJp93PuuO8VbK1Z'
app.config['MONGO_DBNAME'] = 'cloud_cafe'
app.config['BREWS_COLLECTION'] = 'brews'
app.config['HISTORY_COLLECTION'] = 'history'
app.config['INVENTORY_COLLECTION'] = 'inventory'
app.config['PROFILE_COLLECTION'] = 'profiles'
app.config['USERS_COLLECTION'] = 'accounts'
app.config['SIMULATE_ROAST'] = simulate
app.config['MONGO_URI'] = os.environ.get('MONGO_URI')
app.config['REDIS_HOST'] = os.environ.get('REDIS_HOST')
app.redis = Redis(host='redis')
login_manager.init_app(app)
mongo.init_app(app)
sio.init_app(app)
from .core import core as core_blueprint
app.register_blueprint(core_blueprint)
if simulate:
ht.set_simulate(True)
return app
```
#### File: 9b/split-key-roast/server.py
```python
import socket
import sys
from app import create_app, sio
from argparse import ArgumentParser
def main():
"""Go."""
parser = ArgumentParser()
subs = parser.add_subparsers(dest='cmd')
setup_parser = subs.add_parser('run')
setup_parser.add_argument('--debug', action='store_true',
help='Run in debug mode.')
setup_parser.add_argument('--simulate', action='store_true',
help='Run in simulation mode.')
args = parser.parse_args()
kwargs = {'simulate': args.simulate, 'debug': args.debug}
app = create_app(**kwargs)
try:
app.redis.setex('testasdf', 1, 42)
except Exception as e:
raise Exception("failed to contact redis", e)
sio.run(app, host="0.0.0.0", port=80)
if __name__ == '__main__':
main()
``` |
{
"source": "9bstudios/mc_lifesaver",
"score": 3
} |
#### File: mc_lifesaver/lxserv/ls_resetPrefs_safety.py
```python
import lx, modo, lifesaver
class ResetPrefsCommandClass(lifesaver.CommanderClass):
def commander_arguments(self):
args = []
for i in lifesaver.KEEPERS:
args.append({
'name': i[0],
'datatype': 'boolean',
'label': i[1],
'default': True
})
return args
def commander_execute(self, msg, flags):
args = self.commander_args()
if True not in [v for k, v in args.iteritems()]:
modo.dialogs.alert("Abort", "Nothing was selected. Nothing will be deleted.")
return
if modo.dialogs.yesNo("Confirmation", "Are you sure you want to permanently delete your saved preferences?") == "yes":
clearCmd = 'lifesaver.clearPrefs'
for i in lifesaver.KEEPERS:
clearCmd += " " + str(lx.eval('lifesaver.preference %s ?' % i[3]))
lx.eval(clearCmd)
modo.dialogs.alert("Preferences Deleted", "Backup configs deleted. Changes take effect the next time MODO restarts.")
else:
modo.dialogs.alert("Abort", "Preferences reset aborted. Nothing will be deleted.")
return
lx.bless(ResetPrefsCommandClass, 'lifesaver.resetPrefsSafety')
``` |
{
"source": "9bstudios/mc_noodles",
"score": 3
} |
#### File: mc_noodles/commander/Commander.py
```python
import lx, lxu, traceback
from lxifc import UIValueHints, Visitor
from operator import ior
from Var import *
class CommanderClass(lxu.command.BasicCommand):
"""Wrapper for lxu.command.BasicCommand. Improves and simplifies common
command UI implementations, like popups, sPresetText fields, and
Form Command Lists. Allows for virtually any type of command.
See README.md for more examples.
Example:
****************
# Extend the commander.CommandClass
class MyGreatCommandClass(commander.CommandClass):
# Optional method returns any command argument definitions
commander_arguments(self):
return[{
commander.NAME: 'myStringArgument',
commander.DATATYPE: 'string'
}]
# Required method contains the actual command code.
# Note: traceback is included by default; no need to add.
commander_execute(self):
args = commander_args()
lx.out(args['myStringArgument'])
# Bless the class as normal.
lx.bless(MyGreatCommandClass, "myGreatCommand")
****************
"""
def __init__(self):
# Since we run our own __init__(), we need to explicitly run the
# base class's __init__() as well.
lxu.command.BasicCommand.__init__(self)
# NOTE re: default argument values.
# When a command is run for the first time, MODO presents the user
# with a dialog containing blank fields for each argument. After first
# run, the command will remember the previous values used.
# In many cases, however, you may want to present a new user with sensible
# default values for arguments--not the blank fields provided by default.
# To this end, you can use the cmd_DialogInit() method. Define your
# defaults there, and MODO will always present the user with those
# defaults.
# But there's a problem: you can't have it both ways. Either you use
# cmd_DialogInit() to set the same default values every time the command
# is run, or you remember the last values and use those. You can't
# have a default value for first run, and then remember recent values
# thereafter.
# And yes, you sort of can by testing for dyna_IsSet(), but no. You can't.
# Not for popups. Popups with dynamic contents will always default to
# blank "...", no matter what you do.
# The commander workaround is to store our own argument default values
# in a class variable called _commander_stored_values. We then manually
# use the stored values in cmd_DialogInit(), and viola! Sensible
# default values that also remember recently-used values... even for
# popups menus. Yay.
# So here we go. If _commander_stored_values hasn't been initilized yet,
# we need to initialize it. (And no, you can't just put it outside of
# __init__() just below the class declaration, lest your sublcasses
# start trying to use each other's default arguments. Trust me.)
try:
self._commander_stored_values
except AttributeError:
self.commander_default_values_init()
# Loop through command arguments defined in commander_arguments()
# and initialize.
for n, argument in enumerate(self.commander_arguments()):
# Arguments need a valid name and datatype. Without those, we die.
if not argument.get(DATATYPE):
return lx.symbol.e_FAILED
if not argument.get(NAME):
return lx.symbol.e_FAILED
datatype = getattr(lx.symbol, 'sTYPE_' + argument[DATATYPE].upper())
if not datatype:
return lx.symbol.e_FAILED
# Add the argument as normal.
self.dyna_Add(argument[NAME], datatype)
# If this is the first time running the command, the class variable
# _commander_stored_values will be empty. In that case, populate it.
if n >= len(self._commander_stored_values):
self.commander_default_values_set(argument.get(VALUE))
# If a list of flags is included in the argument, set them.
flags = []
for flag in argument.get(FLAGS, []):
flags.append(getattr(lx.symbol, 'fCMDARG_' + flag.upper()))
if flags:
self.basic_SetFlags(n, reduce(ior, flags))
# CommandClass can implement the commander_notifiers() method to update
# FormCommandLists and Popups. If implemented, add the notifiers.
self.not_svc = lx.service.NotifySys()
self.notifiers = []
self.notifier_tuples = tuple([i for i in self.commander_notifiers()])
for i in self.notifier_tuples:
self.notifiers.append(None)
def commander_arguments(self):
"""To be overridden by subclasses.
Should return a list of dictionaries, one for each argument."""
return []
def commander_notifiers(self):
"""To be overridden by subclasses.
Should return a list of tuples, e
[('notifier.editAction',''), ("select.event", "item +ldt"), ("tagger.notifier", "")]"""
return []
def commander_execute(self, msg, flags):
"""To be overridden by subclasses.
This is the main command execution code. It is already wrapped in
a try/except statement with traceback, so you don't need to add that."""
pass
def commander_query(self, arg_index):
"""To be overridden by subclasses.
Should return a value based on the arg_index being queried. For toggle
buttons and checkmarks, this should be a boolean. Can also return strings
or floats as required."""
return False
@classmethod
def commander_default_values_init(cls):
"""Initialize the class variable _commander_stored_values.
You should never need to touch this."""
cls._commander_stored_values = []
@classmethod
def commander_default_values_set(cls, value):
"""Add an argument to the class variable _commander_stored_values.
You should never need to touch this."""
cls._commander_stored_values.append(value)
def commander_arg_value(self, index, default=None):
"""Return a command argument value by index.
If no argument value exists, returns the default parameter.
NOTE: The commander_args() method is simpler to use than this method.
You should probably use that one unless you have a reason to find a specific
argument by index.
:param index: (int) index of argument to retrieve
:param default: value to return if argument is not set
:returns: argument value (str, int, float, or boolean as appropriate)"""
# If no value is set, return the default.
if not self.dyna_IsSet(index):
return default
# If it's a string, use dyna_String to grab it.
if self.commander_arguments()[index][DATATYPE].lower() in sTYPE_STRINGs:
return self.dyna_String(index)
# If the value is a vector, use dyna_String to grab it, then parse it
# into a list of float vlues.
elif self.commander_arguments()[index][DATATYPE].lower() in sTYPE_STRING_vectors:
return [float(i) for i in self.dyna_String(index).split(" ")]
# If the value is an integer, use dyna_Int to grab it.
elif self.commander_arguments()[index][DATATYPE].lower() in sTYPE_INTEGERs:
return self.dyna_Int(index)
# If the value is a float, use dyna_Float to grab it.
elif self.commander_arguments()[index][DATATYPE].lower in sTYPE_FLOATs:
return self.dyna_Float(index)
# If the value is a boolean, use dyna_Bool to grab it.
elif self.commander_arguments()[index][DATATYPE].lower() in sTYPE_BOOLEANs:
return self.dyna_Bool(index)
# If something bonkers is going on, use the default.
return default
def commander_args(self):
"""Returns a dictionary of arguments in name:value pairs."""
args = {}
for i in range(len(self.commander_arguments())):
name = self.commander_arguments()[i][NAME]
value = self.commander_arg_value(i)
args[name] = value
return args
def cmd_NotifyAddClient(self, argument, object):
"""Add notifier clients as needed.
You should never need to touch this."""
for i, tup in enumerate(self.notifier_tuples):
if self.notifiers[i] is None:
self.notifiers[i] = self.not_svc.Spawn (self.notifier_tuples[i][0], self.notifier_tuples[i][1])
self.notifiers[i].AddClient(object)
def cmd_NotifyRemoveClient(self, object):
"""Remove notifier clients as needed.
You should never need to touch this."""
for i, tup in enumerate(self.notifier_tuples):
if self.notifiers[i] is not None:
self.notifiers[i].RemoveClient(object)
def cmd_Flags(self):
"""Set command flags. This method can be overridden if special flags
are needed."""
return lx.symbol.fCMD_POSTCMD | lx.symbol.fCMD_MODEL | lx.symbol.fCMD_UNDO
def arg_UIHints(self, index, hints):
"""Adds pretty labels to arguments in command dialogs. If no label parameter
is explicitly included, we create a pseudo-label by capitalizing the
argument name and replacing underscores with spaces.
Labels can either be literal strings or method/function objects. In the
latter case, the method or function will be called when needed.
If any popup fields of type sPresetText are present,
adds the appropriate hint.
You should never need to touch this."""
args = self.commander_arguments()
if index < len(args):
# If an explicit label is provided, use it.
label = args[index].get(LABEL)
# If not, make a pretty version of the arg name.
if not label:
label = args[index].get(NAME).replace("_", " ").title()
# Labels can be functions. If so, run the function to get the string.
elif hasattr(label, '__call__'):
label = label()
# Apply the label.
hints.Label(label)
# If the popup type is sPresetText, apply the appropriate class.
if args[index].get(VALUES_LIST_TYPE) == sPresetText:
hints.Class("sPresetText")
def arg_UIValueHints(self, index):
"""Popups and sPresetText arguments fire this method whenever
they update. Note that the 'hints' parameter can be a literal list
or tuple, but can also be a method or function.
For dynamic lists,
be sure to pass in the generator method or function object itself,
not its result. (i.e. pass in 'myGreatFunction', NOT 'myGreatFunction()')
You should never need to touch this."""
args = self.commander_arguments()
if index < len(args):
arg = args[index]
arg_data = None
# Try to grab the values_list for the argument.
if arg.get(VALUES_LIST) is not None:
arg_data = arg.get(VALUES_LIST)
# If our values_list is empty, don't bother.
if not arg_data:
return
# If the values_list is a list/tuple, use it as-is.
if isinstance(arg_data, (list, tuple)):
values = arg_data
# If the values_list is a method/function, fire it and use the result.
elif hasattr(arg_data, '__call__'):
values = arg_data()
# In some rare cases you may want to manually instantiate your own
# popup class as a subclass of UIValueHints. In those cases, we
# ignore the below and just use yours.
elif issubclass(arg_data, UIValueHints):
return arg_data()
# If values is None or "" or someother nonsense, return an empty list.
if not values:
values = []
# Argument can be a normal popup, an sPresetText popup, or a
# Form Command List. We'll need to return a different class
# depending on the 'values_list_type'.
if args[index].get(VALUES_LIST_TYPE) == POPUP:
return PopupClass(values)
elif args[index].get(VALUES_LIST_TYPE) == sPresetText:
return PopupClass(values)
elif args[index].get(VALUES_LIST_TYPE) == FCL:
return FormCommandListClass(values)
def cmd_DialogInit(self):
"""Sets default values for arguments in command dialogs as
explained in __init__() above. If you change this, you run the risk
of causing the universe to implode on itself.
You should never need to touch this."""
for n, argument in enumerate(self.commander_arguments()):
# If we already have a value, use it.
# This is especially important when a command is run with args
# via command line or form button.
if self.dyna_IsSet(n) and self.dyna_String(n):
continue
datatype = argument.get(DATATYPE, '').lower()
stored_value = self._commander_stored_values[n]
default_value = self.commander_arguments()[n].get(VALUE)
# If there's no default and nothing stored, we're done here.
if default_value == None and not stored_value:
continue
# The correct attr_Set... method depends on datatype.
if datatype in sTYPE_STRINGs + sTYPE_STRING_vectors:
self.attr_SetString(n, str(stored_value))
elif datatype in sTYPE_INTEGERs + sTYPE_BOOLEANs:
self.attr_SetInt(n, int(stored_value))
elif datatype in sTYPE_FLOATs:
self.attr_SetFlt(n, float(stored_value))
def basic_Execute(self, msg, flags):
"""Stores recent command values for next run and wraps commander_execute
in a try/except statement with traceback.
Do NOT override this method. Use commander_execute() instead.
You should never need to touch this."""
for n, argument in enumerate(self.commander_arguments()):
self._commander_stored_values[n] = self.commander_arg_value(n)
try:
self.commander_execute(msg, flags)
except:
lx.out(traceback.format_exc())
def cmd_Query(self, index, vaQuery):
"""Returns a value when a queriable argument is queried. It's a bit weird
to use, so commander wraps it up for you. Implement `commander_query` in
your own sublcass to and return whatever you like based on the arg_index.
You should never need to touch this."""
# Create the ValueArray object
va = lx.object.ValueArray()
va.set(vaQuery)
args = self.commander_arguments()
# If index out of range, bail
if index > len(args):
return lx.result.OK
# If it's not a query, bail
is_query = 'query' in args[index].get(FLAGS, [])
if not is_query:
return lx.result.OK
# If it's a Form Command List (FCL), bail
is_fcl = args[index].get(VALUES_LIST_TYPE) == FCL
if is_fcl:
return lx.result.OK
# To keep things simpler for commander users, let them return
# a value using only an index (no ValueArray nonsense)
commander_query_result = self.commander_query(index)
# Need to add the proper datatype based on result from commander_query
if isinstance(commander_query_result, basestring):
va.AddString(commander_query_result)
elif isinstance(commander_query_result, int):
va.AddInt(commander_query_result)
elif isinstance(commander_query_result, float):
va.AddFloat(commander_query_result)
return lx.result.OK
class FormCommandListClass(UIValueHints):
"""Special class for creating Form Command Lists. This is instantiated
by CommanderClass objects if an FCL argument provided.
Expects a list of valid MODO commands to be provided to init.
NOTE: Any invalid command will crash MODO.
You should never need to touch this."""
def __init__(self, items):
self._items = items
def uiv_Flags(self):
return lx.symbol.fVALHINT_FORM_COMMAND_LIST
def uiv_FormCommandListCount(self):
return len(self._items)
def uiv_FormCommandListByIndex(self,index):
return self._items[index]
class PopupClass(UIValueHints):
"""Special class for creating popups and sPresetText fields. Accepts
either a simple list of values, or a list of (ugly, pretty) tuples:
[1, 2, 3]
or
[(1, "The Number One"), (2, "The Number Two"), (3, "The Number Three")]
You should never need to touch this."""
def __init__(self, items):
self._internal = []
self._user = []
# If we have items to add to the lists, add them.
if items and isinstance(items, (list, tuple)):
for item in items:
# If the list item is a list or tuple, assume the format (ugly, pretty)
if isinstance(item, (list, tuple)):
self._internal.append(str(item[0]))
self._user.append(str(item[1]))
# Otherwise just use the value for both Ugly and Pretty
else:
self._internal.append(str(item))
self._user.append(str(item))
def uiv_Flags(self):
return lx.symbol.fVALHINT_POPUPS
def uiv_PopCount(self):
return len(self._internal)
def uiv_PopUserName(self,index):
return self._user[index]
def uiv_PopInternalName(self,index):
return self._internal[index]
``` |
{
"source": "9bstudios/mecco_bling",
"score": 2
} |
#### File: mecco_bling/bling/GetMatcapImage.py
```python
import lx, lxu
def getMatcapImage(matcapName):
scene_svc = lx.service.Scene()
scene = lxu.select.SceneSelection().current()
shadeloc_graph = lx.object.ItemGraph(scene.GraphLookup(lx.symbol.sGRAPH_SHADELOC))
matcap_item = scene.ItemLookup(matcapName)
for x in range(shadeloc_graph.FwdCount(matcap_item)):
next_item = shadeloc_graph.FwdByIndex(matcap_item, x)
if next_item.Type():
next_item_type = next_item.Type()
if next_item_type == scene_svc.ItemTypeLookup(lx.symbol.sITYPE_VIDEOSTILL):
return scene.ItemLookup(next_item.Ident())
return False
```
#### File: mecco_bling/lxserv/bling_matcapAdd.py
```python
import lx, bling, os, lxu
CMD_NAME = "bling.matcapAdd"
class CommandClass(bling.CommanderClass):
_commander_default_values = []
_icon = None
_imageCache = bling.imageCache()
def commander_arguments(self):
return [
{
'name': 'matcap',
'datatype': 'string',
'label': 'Matcap',
'values_list_type': 'popup',
'values_list': bling.MatcapListPop,
'flags': ['query']
}
]
def cmd_IconImage(self, w, h):
image_path = self.commander_arg_value(0)
if image_path:
TN = self._imageCache.GetImageTN(image_path)
return TN
def commander_execute(self, msg, flags):
image = self.commander_arg_value(0)
MatcapListPop = bling.MatcapListPop()
scnSel = lxu.select.SceneSelection().current()
scnSrv = lx.service.Scene()
render = scnSel.ItemLookup('Render')
if image == bling.NONE:
lx.eval("bling.matcapRemove")
MatcapListPop.setSelected()
elif image == bling.OPEN_FOLDER:
lx.eval('file.open {%s}' % bling.matcap_folder())
elif image == bling.UPDATE:
lx.eval("bling.matcapRemove")
MatcapListPop.getMatcapListPop()
image = MatcapListPop.getSelected()
if os.path.isfile(image):
lx.eval("bling.matcapRemove")
MatcapListPop.setSelected(image)
matCapObj = scnSel.ItemAdd(scnSrv.ItemTypeLookup('matcapShader'))
matCapObj.SetName(lx.eval("user.value bling_matcap_item_name ?"))
parentGraph = scnSel.GraphLookup('parent')
itemGraph = lx.object.ItemGraph(parentGraph)
childrenCount = itemGraph.RevCount(render)
itemGraph.SetLink(matCapObj, -1, render, -1)
lx.eval('clip.addStill {%s}' % image)
lx.eval('item.channel videoStill$colorspace "nuke-default:sRGB"')
lx.eval('select.item {%s} set' % matCapObj.Ident())
imageName = os.path.basename(image)
lx.eval('matcap.image {%s:videoStill001}' % imageName[:imageName.rfind('.')])
chan = scnSel.Channels('edit', 0.0)
chnWrite = lx.object.ChannelWrite(chan)
for channel in (('glOnly', 1), ('gamma', 1.0)):
idx = matCapObj.ChannelLookup(channel[0])
if type(channel[1]) == int:
return chnWrite.Integer(matCapObj, idx, channel[1])
elif type(channel[1]) == float:
return chnWrite.Double(matCapObj, idx, channel[1])
try:
# Since we currently can not target a GL window, we
# are wrapping this in a try just in case there is no available
# GL window, or we are focused on a UV window
lx.eval('!!view3d.shadingStyle advgl')
except:
pass
lx.bless(CommandClass, CMD_NAME)
```
#### File: mecco_bling/lxserv/bling_matcapPieSlot.py
```python
#lxserv/bling_matcapPieSlot.py
# # python
#
# import lx, bling, os, lxu
#
# CMD_NAME = "bling.matcapPieSlot"
#
# class CommandClass(bling.CommanderClass):
# _commander_default_values = []
# _pieMenus = [None] * 8
#
# def commander_arguments(self):
# return [
# {
# 'name': 'slot',
# 'datatype': 'integer',
# 'label': 'Slot',
# 'values_list_type': 'popup',
# 'values_list': range(1,9),
# 'flags': []
# }, {
# 'name': 'matcap',
# 'datatype': 'string',
# 'label': 'Matcap',
# 'values_list_type': 'popup',
# 'values_list': bling.MatcapListPop,
# 'flags': ['query']
# }
# ]
#
# @classmethod
# def set_pie(cls, index, value):
# cls._pieMenus[index] = value
#
# def commander_execute(self, msg, flags):
# index = self.commander_arg_value(0)
# value = self.commander_arg_value(1)
#
# lx.eval('user.value bling_pie_slot_%s {%s}' % (index, value))
#
# self.set_pie(index, value)
#
# lx.bless(CommandClass, CMD_NAME)
``` |
{
"source": "9bstudios/mecco_cropper",
"score": 2
} |
#### File: mecco_cropper/lxserv/crop.py
```python
import lx
import lxu.command
import lxifc
import traceback
import modo
import cropper
DEFAULT_PASSNAME = 'crop'
SUFFIX = '_cropper'
def get_render_region():
return {
'left': modo.Scene().renderItem.channel('regX0').get(),
'right': modo.Scene().renderItem.channel('regX1').get(),
'top': modo.Scene().renderItem.channel('regY0').get(),
'bottom': modo.Scene().renderItem.channel('regY1').get()
}
def get_target_frame():
render_region = get_render_region()
return [
int(cropper.resXChannel().get()) * abs(render_region['right'] - render_region['left']),
int(cropper.resYChannel().get()) * abs(render_region['bottom'] - render_region['top']),
]
def get_target_offset():
proportional_aperture = get_proportional_aperture()
frame = [
int(cropper.resXChannel().get()),
int(cropper.resYChannel().get())
]
offset = [
modo.Scene().renderCamera.channel('offsetX').get(),
modo.Scene().renderCamera.channel('offsetY').get()
]
render_region = get_render_region()
x_step = 1
y_step = x_step
if frame[0] == frame[1]:
x_step = proportional_aperture[1]
y_step = proportional_aperture[1]
elif frame[0] > frame[1]:
mdf = float(frame[0]) / frame[1]
x_step = proportional_aperture[0]
y_step = proportional_aperture[0] / mdf
elif frame[0] < frame[1]:
mdf = float(frame[1]) / frame[0]
x_step = proportional_aperture[1] / mdf
y_step = proportional_aperture[1]
offset = [
((render_region['left']+render_region['right'])/2 - .5) * x_step + offset[0],
((render_region['top']+render_region['bottom'])/2 - .5) * -y_step + offset[1],
]
return offset
def deactivate_pass():
graph_kids = modo.Scene().item(cropper.GROUP_NAME).itemGraph('itemGroups').forward()
passes = [i for i in graph_kids if i.type == lx.symbol.a_ACTIONCLIP]
for pass_ in passes:
pass_.actionClip.SetActive(0)
def active_pass():
try:
modo.Scene().item(cropper.GROUP_NAME)
except LookupError:
return None
graph_kids = modo.Scene().item(cropper.GROUP_NAME).itemGraph('itemGroups').forward()
passes = [i for i in graph_kids if i.type == lx.symbol.a_ACTIONCLIP]
for pass_ in passes:
if pass_.actionClip.Active():
return pass_
return None
def activate_latest_pass():
try:
graph_kids = modo.Scene().item(cropper.GROUP_NAME).itemGraph('itemGroups').forward()
except (NameError, LookupError):
return
passes = [i for i in graph_kids if i.type == lx.symbol.a_ACTIONCLIP]
max(passes, key=lambda p: p.index).actionClip.SetActive(1)
def get_proportional_aperture():
frame = [
int(cropper.resXChannel().get()),
int(cropper.resYChannel().get())
]
ratio = float(max(frame)) / min(frame)
aperture = [
modo.Scene().renderCamera.channel('apertureX').get(),
modo.Scene().renderCamera.channel('apertureY').get()
]
apr_ratio = float(max(aperture)) / min(aperture)
if ratio <= apr_ratio:
if aperture[0] > aperture[1]:
aperture[0] = aperture[1] * ratio
elif aperture[0] < aperture[1]:
aperture[1] = aperture[0] * ratio
return aperture
def get_target_aperture():
target_frame = get_target_frame()
proportional_aperture = get_proportional_aperture()
render_region = get_render_region()
region_size = [
render_region['right'] - render_region['left'],
render_region['bottom'] - render_region['top']
]
target_aperture = [
proportional_aperture[0] * region_size[0],
proportional_aperture[1] * region_size[1]
]
return target_aperture
class Cropper(lxu.command.BasicCommand):
def __init__(self):
lxu.command.BasicCommand.__init__(self)
self.dyna_Add('name', lx.symbol.sTYPE_STRING)
def basic_Execute(self, msg, flags):
try:
self.CMD_EXE(msg, flags)
except Exception:
lx.out(traceback.format_exc())
def CMD_EXE(self, msg, flags):
pass_name = self.dyna_String(0) if self.dyna_IsSet(0) else DEFAULT_PASSNAME
tracerCam = cropper.get_tracer_camera(SUFFIX) if cropper.get_tracer_camera(SUFFIX) else cropper.create_tracer_camera(SUFFIX, True)
modo.Scene().renderItem.channel('region').set(False)
lx.eval("view3d.renderCamera")
try:
modo.Scene().item(cropper.GROUP_NAME)
except LookupError:
lx.eval('group.create {} pass empty'.format(cropper.GROUP_NAME))
channels_list = [
cropper.resXChannel(),
cropper.resYChannel(),
modo.Scene().renderItem.channel('cameraIndex'),
tracerCam.channel('offsetX'),
tracerCam.channel('offsetY'),
tracerCam.channel('apertureX'),
tracerCam.channel('apertureY')
]
for channel in channels_list:
if channel not in modo.Scene().item(cropper.GROUP_NAME).groupChannels:
modo.Scene().item(cropper.GROUP_NAME).addChannel(channel)
lx.eval('group.layer group:{%s} name:{%s} grpType:pass' % (cropper.GROUP_NAME, pass_name))
target_frame = get_target_frame()
target_offset = get_target_offset()
target_aperture = get_target_aperture()
modo.Scene().renderItem.channel('resX').set(target_frame[0])
modo.Scene().renderItem.channel('resY').set(target_frame[1])
lx.eval('render.camera {%s}' % tracerCam.id)
tracerCam.channel('offsetX').set(target_offset[0])
tracerCam.channel('offsetY').set(target_offset[1])
tracerCam.channel('apertureX').set(target_aperture[0])
tracerCam.channel('apertureY').set(target_aperture[1])
lx.eval('edit.apply')
notifier = cropper.CropperNotify()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
class CropperToggle(lxu.command.BasicCommand):
def __init__(self):
lxu.command.BasicCommand.__init__(self)
self.dyna_Add('quick', lx.symbol.sTYPE_BOOLEAN)
self.basic_SetFlags(0, lx.symbol.fCMDARG_OPTIONAL)
def basic_Execute(self, msg, flags):
if active_pass():
deactivate_pass()
elif modo.Scene().renderItem.channel('region').get():
arg = ' {%s}' % DEFAULT_PASSNAME if self.dyna_Bool(0) else ''
lx.eval('cropper.crop{}'.format(arg))
else:
activate_latest_pass()
class CropperDisable(lxu.command.BasicCommand):
def __init__(self):
lxu.command.BasicCommand.__init__(self)
def basic_Execute(self, msg, flags):
if active_pass():
deactivate_pass()
class CropperClearAll(lxu.command.BasicCommand):
def __init__(self):
lxu.command.BasicCommand.__init__(self)
def basic_ButtonName(self):
return "Delete All Crops"
def basic_Execute(self, msg, flags):
try:
modo.Scene().removeItems(modo.Scene().item(cropper.GROUP_NAME))
except:
pass
hitlist = set()
for i in modo.Scene().iterItems():
if i.hasTag(cropper.CAM_TAG):
if SUFFIX in i.getTags()[cropper.CAM_TAG]:
hitlist.add(i)
if i.hasTag(cropper.CAM_TAG):
i.setTag(cropper.CAM_TAG, None)
for hit in hitlist:
modo.Scene().removeItems(hit)
notifier = cropper.CropperNotify()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
lx.bless(CropperToggle, "cropper.toggleButton")
lx.bless(CropperDisable, "cropper.disable")
lx.bless(Cropper, "cropper.crop")
lx.bless(CropperClearAll, "cropper.clearAll")
``` |
{
"source": "9bstudios/mecco_dara",
"score": 2
} |
#### File: 9bstudios/mecco_dara/github_update_dara.py
```python
import sys, traceback
import requests, pprint, os, zipfile, shutil, glob, xml.etree.ElementTree, getpass
import json
from os.path import expanduser
#from git import Repo
BASE_URL = "https://api.github.com/repos/pixelfondue/%s/releases/latest"
BASE_PATH = os.path.dirname(os.path.realpath(__file__))
print "base path:", BASE_PATH
config_file_path = os.path.join(BASE_PATH, "_github_credentials")
print "config file path:", config_file_path
KIT_NAME = "mecco_dara"
DARA_PATH = os.path.join(BASE_PATH, KIT_NAME)
print "dara path:", DARA_PATH
DARA_KITS_PATH = os.path.join(DARA_PATH, "Kits")
print "dara kits path:", DARA_KITS_PATH
DARA_WIP_PATH = os.path.join(BASE_PATH, "wip")
print "dara WIP path:", DARA_WIP_PATH
DARA_RELEASES_PATH = os.path.join(BASE_PATH, "releases")
print "dara releases path:", DARA_RELEASES_PATH
KITS = [
'mecco_neatFreak',
'mecco_solo',
'mecco_tabbyCat',
'mecco_bling',
'mecco_cropper',
'mc_noodles',
'mc_lifesaver',
'mecco_flipper',
'mecco_ignition',
'mecco_kelvin',
'mecco_metermade',
'mecco_passify',
'mecco_renderMonkey',
'mecco_replay',
'mecco_snap',
'mecco_tagger',
'mecco_wheely',
'mecco_Zen'
]
def set_github_credentials():
global USERNAME
global PASSWORD
try:
config_file = open(config_file_path)
config = json.load(config_file)
USERNAME = config['GITHUB_USERNAME']
PASSWORD = config['GITHUB_PASSWORD']
except:
print "Username:"
USERNAME = raw_input()
if 'PYCHARM' in os.environ:
PASSWORD = raw_input()
else:
PASSWORD = getpass.getpass('Password: ')
config = {'GITHUB_USERNAME':USERNAME, 'GITHUB_PASSWORD':PASSWORD}
config_file = open(config_file_path, 'w')
json.dump(config, config_file)
finally:
print "username:", USERNAME
print "password:", PASSWORD[0] + "..."
def download_file(kit, url):
tmp_filename = os.path.join(DARA_KITS_PATH, kit + "_" + os.path.basename(url) + "_partial")
r = requests.get(url, stream=True, auth=(USERNAME, PASSWORD))
if r.status_code == 200:
with open(tmp_filename, 'wb') as f:
for chunk in r:
f.write(chunk)
complete_filename = tmp_filename.replace("_partial", ".zip")
if os.path.exists(complete_filename):
os.remove(complete_filename)
os.rename(tmp_filename, complete_filename)
return complete_filename
def delete_dir_contents(directory):
for the_file in os.listdir(directory):
file_path = os.path.join(directory, the_file)
try:
if os.path.isfile(file_path):
os.unlink(file_path)
elif os.path.isdir(file_path): shutil.rmtree(file_path)
except Exception as e:
print(e)
def extract_zip_file(src, dest):
zip_ref = zipfile.ZipFile(src, 'r')
extracted_folder_name = zip_ref.namelist()[0]
zip_ref.extractall(dest)
zip_ref.close()
return extracted_folder_name
def make_dirs():
# create Kits foler if it doesn't exist:
if not os.path.exists(DARA_KITS_PATH):
os.makedirs(DARA_KITS_PATH)
# create releases foler if it doesn't exist:
if not os.path.exists(DARA_RELEASES_PATH):
os.makedirs(DARA_RELEASES_PATH)
# download and extract
def download_releases():
for kit in KITS:
try:
rest_api_response = requests.get(BASE_URL % kit, auth=(USERNAME, PASSWORD))
rest_api_response.raise_for_status()
except requests.exceptions.HTTPError as err:
print err
sys.exit(1)
data = rest_api_response.json()
target_path = os.path.join(DARA_KITS_PATH, kit)
target_cfg = os.path.join(target_path, "index.cfg")
if os.path.exists(target_cfg) and os.path.isfile(target_cfg):
repo_version = data['tag_name']
config_xml = xml.etree.ElementTree.parse(target_cfg).getroot()
local_version = config_xml.attrib["version"]
if local_version == repo_version:
print "up to date %s..." % data['zipball_url']
continue
if os.path.exists(target_path):
shutil.rmtree(target_path)
print "downloading %s..." % data['zipball_url']
zip_file_path = download_file(kit, data['zipball_url'])
extracted_folder_name = extract_zip_file(zip_file_path, DARA_KITS_PATH)
extracted_folder_name = os.path.join(DARA_KITS_PATH, extracted_folder_name)
# retrieve actual kit name (just in case it's not the same as the github repo name)
index_file = os.path.join(extracted_folder_name, "index.cfg")
index_xml = xml.etree.ElementTree.parse(index_file).getroot()
real_kit_name = index_xml.attrib["kit"]
os.rename(extracted_folder_name, target_path)
os.remove(zip_file_path)
# duplicate dara folder
temp_directory = os.path.join(DARA_RELEASES_PATH, "tmp")
shutil.copytree(DARA_PATH, temp_directory)
# # delete cruft
for directory,subdirs,files in os.walk(temp_directory):
if '.gitignore' in files:
os.unlink(os.path.join(temp_directory, directory, '.gitignore'))
if '.gitmodules' in files:
os.unlink(os.path.join(temp_directory, directory, '.gitmodules'))
if '.gitattributes' in files:
os.unlink(os.path.join(temp_directory, directory, '.gitattributes'))
if '.git' in subdirs:
shutil.rmtree(os.path.join(temp_directory, directory, '.git'))
for pyc_file in [f for f in files if f.lower().endswith('.pyc')]:
try:
os.unlink(pyc_file)
except:
print traceback.print_exc()
# retrieve dara version
index_file = os.path.join(temp_directory, "index.cfg")
index_xml = xml.etree.ElementTree.parse(index_file).getroot()
dara_version = index_xml.attrib["version"]
release_dirname = os.path.join(DARA_RELEASES_PATH, KIT_NAME + "_" + str(dara_version))
if os.path.isdir(release_dirname):
shutil.rmtree(release_dirname)
os.rename(temp_directory, release_dirname)
# zip release directory
release_zipname = release_dirname + ".zip"
temp_file = os.path.join(DARA_RELEASES_PATH, "tmp")
shutil.make_archive(temp_file, 'zip', release_dirname)
if os.path.isfile(release_zipname):
os.unlink(release_zipname)
os.rename(temp_file + ".zip", release_zipname)
shutil.rmtree(release_dirname)
# update/clone wip
def update_wip():
try:
os.mkdir(DARA_WIP_PATH)
except:
pass
for kit in KITS:
try:
repo_url = 'https://%s:%[email protected]/adamohern/%s' % (USERNAME, PASSWORD, kit)
dest_path = os.path.join(DARA_WIP_PATH, kit)
if os.path.exists(dest_path):
print 'Update', kit
# repo = Repo(dest_path)
# origin = repo.remotes.origin
# origin.pull(rebase=True)
# origin.push()
os.chdir(dest_path)
os.system("git pull --rebase")
os.system("git push")
else:
print "Cloning", kit
#Repo.clone_from(repo_url, os.path.join(DARA_WIP_PATH, kit))
os.system("git clone {0} {1}".format(repo_url, dest_path))
except requests.exceptions.HTTPError as err:
print err
sys.exit(1)
continue
data = rest_api_response.json()
target_path = os.path.join(DARA_KITS_PATH, kit)
target_cfg = os.path.join(target_path, "index.cfg")
if os.path.exists(target_cfg) and os.path.isfile(target_cfg):
repo_version = data['tag_name']
config_xml = xml.etree.ElementTree.parse(target_cfg).getroot()
local_version = config_xml.attrib["version"]
if local_version == repo_version:
print "up to date %s..." % data['zipball_url']
continue
if os.path.exists(target_path):
shutil.rmtree(target_path)
print "downloading %s..." % data['zipball_url']
zip_file_path = download_file(kit, data['zipball_url'])
extracted_folder_name = extract_zip_file(zip_file_path, DARA_KITS_PATH)
extracted_folder_name = os.path.join(DARA_KITS_PATH, extracted_folder_name)
# retrieve actual kit name (just in case it's not the same as the github repo name)
index_file = os.path.join(extracted_folder_name, "index.cfg")
index_xml = xml.etree.ElementTree.parse(index_file).getroot()
real_kit_name = index_xml.attrib["kit"]
os.rename(extracted_folder_name, target_path)
os.remove(zip_file_path)
# duplicate dara folder
temp_directory = os.path.join(DARA_RELEASES_PATH, "tmp")
shutil.copytree(DARA_PATH, temp_directory)
# # delete cruft
for directory, subdirs, files in os.walk(temp_directory):
if '.gitignore' in files:
os.unlink(os.path.join(temp_directory, directory, '.gitignore'))
if '.gitmodules' in files:
os.unlink(os.path.join(temp_directory, directory, '.gitmodules'))
if '.gitattributes' in files:
os.unlink(os.path.join(temp_directory, directory, '.gitattributes'))
if '.git' in subdirs:
shutil.rmtree(os.path.join(temp_directory, directory, '.git'))
for pyc_file in [f for f in files if f.lower().endswith('.pyc')]:
os.unlink(pyc_file)
# retrieve dara version
index_file = os.path.join(temp_directory, "index.cfg")
index_xml = xml.etree.ElementTree.parse(index_file).getroot()
dara_version = index_xml.attrib["version"]
release_dirname = os.path.join(DARA_RELEASES_PATH, KIT_NAME + "_" + str(dara_version))
if os.path.isdir(release_dirname):
shutil.rmtree(release_dirname)
os.rename(temp_directory, release_dirname)
# zip release directory
release_zipname = release_dirname + ".zip"
temp_file = os.path.join(DARA_RELEASES_PATH, "tmp")
shutil.make_archive(temp_file, 'zip', release_dirname)
if os.path.isfile(release_zipname):
os.unlink(release_zipname)
os.rename(temp_file + ".zip", release_zipname)
shutil.rmtree(release_dirname)
if __name__ == '__main__':
try:
set_github_credentials()
make_dirs()
download_releases()
update_wip()
except BaseException as e:
print traceback.print_exc()
raise
finally:
raw_input('(Press <Enter> to close)')
``` |
{
"source": "9bstudios/mecco_flipper",
"score": 2
} |
#### File: mecco_flipper/Scripts/mecco_utils_modo.py
```python
import sys
import lx
import lxu
from mecco_utils_contexts import catch
# returns current scene as an lxu.object.Scene instance
GetScene = lxu.select.SceneSelection().current
def GetItemsOfType(nameFilter, *itemTypes):
""" Returns all items in scene of *itemTypes (item type strings or ints),
matching nameFilter string. Empty string or None will match all items. """
scene = GetScene()
items = []
nameFilter = str() or nameFilter
for itemType in itemTypes:
with catch('item type "%s" not found' % itemType, False, LookupError):
if type(itemType) == str:
itemType = svc_scene.ItemTypeLookup(itemType)
if type(svc_scene.ItemTypename(itemType)) is type(None):
raise LookupError
num = scene.ItemCount(itemType)
for n in xrange(num):
item = scene.ItemByIndex(itemType, n)
if nameFilter in item.UniqueName():
items.append(item)
return items
def InitXfrms(item):
""" Initializes zero-transforms for a given item.
item = lx.object.Item or
lxu.object.Item instance """
with catch("InitXfrms %s" % item.UniqueName(), True):
#get a chanWrite interface
scene = GetScene()
chanRead = scene.Channels(lx.symbol.s_ACTIONLAYER_EDIT, 0.0)
chanWrite = lx.object.ChannelWrite(chanRead)
#get a locator interface for item
loc = lx.object.Locator(item)
#scale
try:
scl = loc.GetTransformItem(lx.symbol.iXFRM_SCALE)
except LookupError:
scl = loc.AddTransformItem(lx.symbol.iXFRM_SCALE)[0]
#position
try:
pos = loc.GetTransformItem(lx.symbol.iXFRM_POSITION)
except LookupError:
pos = loc.AddTransformItem(lx.symbol.iXFRM_POSITION)[0]
#rotation
try:
rot = loc.GetTransformItem(lx.symbol.iXFRM_ROTATION)
except LookupError:
rot = loc.AddTransformItem(lx.symbol.iXFRM_ROTATION)[0]
#write zeroes...
for chanIdx in range(2, 5):
chanWrite.Double(scl, chanIdx, 1.0)
chanWrite.Double(pos, chanIdx, 0.0)
chanWrite.Double(rot, chanIdx, 0.0)
def MakeInstance(item, transform):
""" Creates an instance of input item based on the input transform
item = lx.object.Item or
lxu.object.Item instance
transforms = transform for new instances
A transform is a tuple of tuples for the scale, rotation
and position of the new instance:
(
(scl_x, scl_y, scl_z),
(rot_x, rot_y, rot_z),
(pos_x, pos_y, pos_x),
)
returns the new instance
"""
scene = GetScene()
chanRead = scene.Channels(lx.symbol.s_ACTIONLAYER_EDIT, 0.0)
chanWrite = lx.object.ChannelWrite(chanRead)
#create a new instance of the mesh item
inst = scene.ItemInstance(item)
#set the instance to be a child of the mesh
inst.SetParent(item)
#initialize transforms for the instance
InitXfrms(inst)
#get a locator interface for the instance
loc = lx.object.Locator(inst)
t_items = ( loc.GetTransformItem(lx.symbol.iXFRM_SCALE),
loc.GetTransformItem(lx.symbol.iXFRM_ROTATION),
loc.GetTransformItem(lx.symbol.iXFRM_POSITION))
for a, b in enumerate(t_items):
#a = (0, 1, 2)
#b = transform item
b = lx.object.Item(b)
for xfrmIdx, chanIdx in zip(range(3), range(2,5)):
# lx.out("chanIdx: %s" % chanIdx)
# lx.out("xfrmIdx: %s" % xfrmIdx)
chanWrite.Double(b, chanIdx, transform[a][xfrmIdx])
return inst
``` |
{
"source": "9bstudios/mecco_metermade",
"score": 2
} |
#### File: Scripts/lxserv/mecco_metermade_getRig.py
```python
import lx
import lxu.command
import traceback
class getRig(lxu.command.BasicCommand):
def __init__(self):
lxu.command.BasicCommand.__init__(self)
#command accepts an argument
self.dyna_Add('arg1', lx.symbol.sTYPE_STRING)
def cmd_Flags (self):
#make the command undoable
return lx.symbol.fCMD_MODEL | lx.symbol.fCMD_UNDO
def CMD_EXE(self, msg, flags):
arg1 = self.dyna_String(0, 0.0)
fullpath = lx.eval("query platformservice alias ? {kit_mecco_metermade:metermade/%s.lxp}" % arg1)
lx.eval("preset.do {%s}" % fullpath)
def basic_Execute(self, msg, flags):
try:
self.CMD_EXE(msg, flags)
except Exception:
lx.out(traceback.format_exc())
def basic_Enable(self,msg):
return True
lx.bless(getRig, "mecco.metermade.getRig")
``` |
{
"source": "9bstudios/mecco_neatFreak",
"score": 2
} |
#### File: mecco_neatFreak/lxserv/neatFreak_cleanupShaderTree.py
```python
import lx, lxu, modo, traceback
NAME_CMD = "neatFreak.cleanupShaderTree"
# Returns a list of all mesh layers containing any of the provided pTag(s)
# of type i_POLYTAG, e.g. lx.symbol.i_POLYTAG_MATERIAL.
# pTag can be a tag or list of tags.
def get_layers_by_pTag(pTags,i_POLYTAG=lx.symbol.i_POLYTAG_MATERIAL):
"""Returns a list of all mesh layers containing any of the provided pTag(s)
of type i_POLYTAG, e.g. lx.symbol.i_POLYTAG_MATERIAL.
"""
# If signle value is passed put into list
if not isinstance(pTags,list):
pTags = [pTags]
scene = modo.Scene()
mm = set()
# Collect result meshes in mm
for m in scene.meshes:
# For each polygon tag
for i in range(m.geometry.internalMesh.PTagCount(i_POLYTAG)):
tag = m.geometry.internalMesh.PTagByIndex(i_POLYTAG,i)
# If need to be found in i_POLYTAG_PIC (polygon belongs to each selection set in tag)
if i_POLYTAG == lx.symbol.i_POLYTAG_PICK:
# Add mesh if one of selection sets present in pTags
if [i for i in tag.split(";") if i in pTags]:
mm.add(m)
else:
# Add mesh if tag exists in pTags
if tag in pTags:
mm.add(m)
return list(mm)
# Returns an lx.symbol.i_POLYTAG_* symbol based on a mask
# item's lx.symbol.sICHAN_MASK_PTYP channel string.
def get_i_POLYTAG(sICHAN_MASK_PTYP):
"""Returns an lx.symbol.i_POLYTAG_* symbol based on a mask
item's lx.symbol.sICHAN_MASK_PTYP channel string."""
# Return polygon tag type corresponding to channel string
return {
'':lx.symbol.i_POLYTAG_MATERIAL,
'Material':lx.symbol.i_POLYTAG_MATERIAL,
'Selection Set':lx.symbol.i_POLYTAG_PICK,
'Part':lx.symbol.i_POLYTAG_PART
}[sICHAN_MASK_PTYP]
# Returns all items in the scene of type itype.
def get_items_by_type(itype):
"""Returns all items in the scene of type itype."""
scene_service = lx.service.Scene()
current_scene = lxu.select.SceneSelection().current()
items = []
# lookup the item type
item_type = scene_service.ItemTypeLookup(itype)
# get a count of itype items in the scene
numitems = current_scene.ItemCount(item_type)
for x in range(numitems):
items.append(current_scene.ItemByIndex(item_type, x))
return items
# Standard command implementation
class CMD_neatFreak(lxu.command.BasicCommand):
_first_run = True
def __init__(self):
lxu.command.BasicCommand.__init__(self)
self.dyna_Add("emptyGroups", lx.symbol.sTYPE_BOOLEAN)
self.dyna_Add("unusedGroups", lx.symbol.sTYPE_BOOLEAN)
self.dyna_Add("unusedIClips", lx.symbol.sTYPE_BOOLEAN)
self.dyna_Add("unusedTLocs", lx.symbol.sTYPE_BOOLEAN)
def cmd_Flags(self):
return lx.symbol.fCMD_POSTCMD | lx.symbol.fCMD_MODEL | lx.symbol.fCMD_UNDO
def arg_UIHints(self, index, hints):
if index == 0:
hints.Label("Delete empty groups")
if index == 1:
hints.Label("Delete unused groups")
if index == 2:
hints.Label("Delete unused image clips")
if index == 3:
hints.Label("Delete unused texture locators")
def cmd_DialogInit(self):
if self._first_run:
# At first run check all checkboxes
self.attr_SetInt(0, 1)
self.attr_SetInt(1, 1)
self.attr_SetInt(2, 1)
self.attr_SetInt(3, 1)
self.after_first_run()
@classmethod
def after_first_run(cls):
cls._first_run = False
def basic_Execute(self, msg, flags):
try:
scene = modo.scene.current()
hitlist = set()
for m in scene.iterItems(lx.symbol.sITYPE_MASK):
del_empty = self.dyna_Bool(0)
del_unused = self.dyna_Bool(1)
# delete empty groups
if not m.children() and del_empty:
hitlist.add(m)
if del_unused:
# type of poly tag (material, selection set, etc)
i_POLYTAG = get_i_POLYTAG(m.channel(lx.symbol.sICHAN_MASK_PTYP).get())
# poly tag ("myGreatMaterialTag")
sICHAN_MASK_PTAG = m.channel(lx.symbol.sICHAN_MASK_PTAG).get()
# delete obsolete (unused) polytag groups
if (sICHAN_MASK_PTAG and not get_layers_by_pTag(sICHAN_MASK_PTAG,i_POLYTAG)):
hitlist.add(m)
# Loop through all image clips
for imageClip in scene.items( itype=lx.symbol.sITYPE_VIDEOSTILL ):
del_unused_image_clips = self.dyna_Bool(2)
# delete unused image clips
if del_unused_image_clips:
# We will get the 'shadeLoc' graph and check if there are any connections.
graph = imageClip.itemGraph('shadeLoc')
# If no connections are found for this graph, we delete the clip item from the scene.
if len(graph.forward()) is 0 and len(graph.reverse()) is 0:
lx.out("Deleting clip: %s" % imageClip.name)
hitlist.add(imageClip)
# delete unused texture locators
del_unused_texture_locators = self.dyna_Bool(3)
if del_unused_texture_locators:
shadeloc_graph = lx.object.ItemGraph(scene.GraphLookup(lx.symbol.sGRAPH_SHADELOC))
texlocs = get_items_by_type(lx.symbol.sITYPE_TEXTURELOC)
if texlocs:
for texloc in texlocs:
if (shadeloc_graph.FwdCount(texloc) == 0) and (shadeloc_graph.RevCount(texloc) == 0):
lx.out("Deleting texture locator: %s" % texloc.Ident().name)
hitlist.add(texloc.Ident())
for hit in hitlist:
# TD SDK removeItems() method crashes on some groups. This is more robust.
lx.eval("item.delete item:{%s}" % hit.id)
except:
traceback.print_exc()
lx.bless(CMD_neatFreak, NAME_CMD)
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.