metadata
dict | text
stringlengths 60
3.49M
|
|---|---|
{
"source": "JetBrains-Research/commit_message_generation",
"score": 2
}
|
#### File: commit_message_generation/tests/test_metrics.py
```python
import pytest
import torch
import numpy as np
from src.utils.metrics import accuracy_MRR
def test_top1_match():
scores = torch.tensor([[0.5, 0, 0.3, 0.2, 0.4], [1.0, -100, -200, -100, 0]], dtype=torch.float)
labels = torch.tensor([0, 0], dtype=torch.long)
acc_top1, acc_top5, MRR_top5 = accuracy_MRR(scores, labels, 5, shift=False)
assert np.allclose([acc_top1, acc_top5, MRR_top5], [1.0, 1.0, 1.0], rtol=1e-05, atol=1e-08)
def test_top3_match():
scores = torch.tensor([[0.5, 0, 0.3, 0.2, 0.4], [1.0, -100, -200, -100, 0]], dtype=torch.float)
labels = torch.tensor([0, 2], dtype=torch.long)
acc_top1, acc_top3, MRR_top3 = accuracy_MRR(scores, labels, 3, shift=False)
assert np.allclose([acc_top1, acc_top3, MRR_top3], [0.5, 0.5, 0.5], rtol=1e-05, atol=1e-08)
def test_top5_match():
scores = torch.tensor([[0.5, 0, 0.3, 0.2, 0.4], [1.0, -100, -200, -100, 0]], dtype=torch.float)
labels = torch.tensor([1, 2], dtype=torch.long)
acc_top1, acc_top5, MRR_top5 = accuracy_MRR(scores, labels, 5, shift=False)
assert np.allclose([acc_top1, acc_top5, MRR_top5], [0.0, 1.0, 0.2], rtol=1e-05, atol=1e-08)
def test_different_batch_sizes():
# batch size 4
scores = torch.tensor(
[
[[0.5, 0, 0.3], [1.0, -100, -200], [0.5, 0, 0.3]],
[[0.5, 0, 0.3], [1.0, -100, -200], [0.5, 0, 0.3]],
[[0.5, 0, 0.3], [1.0, -100, -200], [0.5, 0, 0.3]],
[[0.5, 0, 0.3], [1.0, -100, -200], [0.5, 0, 0.3]],
],
dtype=torch.float,
)
labels = torch.tensor([[0, 2, -100], [1, 1, -100], [2, 1, 3], [1, 2, -100]], dtype=torch.long)
acc_top1, acc_top2, MRR_top2 = accuracy_MRR(scores, labels, 2, shift=False)
assert np.allclose(
[acc_top1, acc_top2, MRR_top2], [0.5 / 4, (1 + 2 / 3) / 4, (0.75 + 1 / 3) / 4], rtol=1e-05, atol=1e-08
)
# batch size 2
first_half = np.array(accuracy_MRR(scores[:2], labels[:2], 2, shift=False))
second_half = np.array(accuracy_MRR(scores[2:], labels[2:], 2, shift=False))
res = (first_half + second_half) / 2
assert np.allclose(res, [0.5 / 4, (1 + 2 / 3) / 4, (0.75 + 1 / 3) / 4], rtol=1e-05, atol=1e-08)
# batch size 1
results = []
for i in range(4):
results.append(np.array(accuracy_MRR(scores[i], labels[i], 2, shift=False)))
assert np.allclose(np.mean(results, axis=0), [0.5 / 4, (1 + 2 / 3) / 4, (0.75 + 1 / 3) / 4], rtol=1e-05, atol=1e-08)
def test_with_shift():
scores = torch.tensor([[0.5, 0, 0.3, 0.2, 0.4], [1.0, -100, -200, -101, 0], [1, 2, 0, 4, 5]], dtype=torch.float)
labels = torch.tensor([0, 0, 1], dtype=torch.long)
acc_top1, acc_top3, MRR_top3 = accuracy_MRR(scores, labels, 3, ignore_index=-100, shift=True)
assert np.allclose([acc_top1, acc_top3, MRR_top3], [0.5, 1.0, (1 + 1 / 3) / 2], rtol=0, atol=1e-06)
```
|
{
"source": "JetBrains-Research/contrastive-learning-framework",
"score": 2
}
|
#### File: models/self_supervised/utils.py
```python
from os import listdir
from os.path import isdir, join
import torch
from code2seq.data.vocabulary import Vocabulary
from pl_bolts.optimizers.lr_scheduler import linear_warmup_decay
from torch.optim import Adam
from torch_cluster import knn
from torchmetrics.functional import auroc
from models import encoder_models
def exclude_from_wt_decay(named_params, weight_decay, skip_list=("bias", "bn")):
params = []
excluded_params = []
for name, param in named_params:
if not param.requires_grad:
continue
elif any(layer_name in name for layer_name in skip_list):
excluded_params.append(param)
else:
params.append(param)
return [{"params": params, "weight_decay": weight_decay}, {"params": excluded_params, "weight_decay": 0.0}]
def configure_optimizers(
model,
learning_rate: float,
weight_decay: float,
warmup_epochs: int,
max_epochs: int,
exclude_bn_bias: bool,
train_iters_per_epoch: int
):
if exclude_bn_bias:
params = exclude_from_wt_decay(model.named_parameters(), weight_decay=weight_decay)
else:
params = model.parameters()
optimizer = Adam(params, lr=learning_rate, weight_decay=weight_decay)
warmup_steps = train_iters_per_epoch * warmup_epochs
total_steps = train_iters_per_epoch * max_epochs
scheduler = {
"scheduler": torch.optim.lr_scheduler.LambdaLR(
optimizer,
linear_warmup_decay(warmup_steps, total_steps, cosine=True),
),
"interval": "step",
"frequency": 1,
}
return [optimizer], [scheduler]
def init_model(config):
if config.name in ["transformer", "gnn", "code-transformer"]:
encoder = encoder_models[config.name](config)
elif config.name == "code2class":
_vocabulary = Vocabulary(
join(
config.data_folder,
config.dataset.name,
config.dataset.dir,
config.vocabulary_name
),
config.dataset.max_labels,
config.dataset.max_tokens
)
encoder = encoder_models[config.name](config=config, vocabulary=_vocabulary)
else:
raise ValueError(f"Unknown model: {config.name}")
return encoder
@torch.no_grad()
def roc_auc(queries, keys, labels):
features, labels = prepare_features(queries, keys, labels)
logits, mask = clone_classification_step(features, labels)
logits = scale(logits)
logits = logits.reshape(-1)
mask = mask.reshape(-1)
return auroc(logits, mask)
def compute_f1(conf_matrix):
assert conf_matrix.shape == (2, 2)
tn, fn, fp, tp = conf_matrix.reshape(-1).tolist()
f1 = tp / (tp + 0.5 * (fp + fn))
return f1
def compute_map_at_k(preds):
avg_precisions = []
k = preds.shape[1]
for pred in preds:
positions = torch.arange(1, k + 1, device=preds.device)[pred > 0]
if positions.shape[0]:
avg = torch.arange(1, positions.shape[0] + 1, device=positions.device) / positions
avg_precisions.append(avg.sum() / k)
else:
avg_precisions.append(torch.tensor(0.0, device=preds.device))
return torch.stack(avg_precisions).mean().item()
def validation_metrics(outputs, task: str = "poj_104"):
features = torch.cat([out["features"] for out in outputs])
_, hidden_size = features.shape
labels = torch.cat([out["labels"] for out in outputs]).reshape(-1)
if task == "poj_104":
ks = [100, 200, 500]
elif task == "codeforces":
ks = [5, 10, 15]
else:
raise ValueError(f"Unknown task {task}")
logs = {}
for k in ks:
if k < labels.shape[0]:
top_ids = knn(x=features, y=features, k=k + 1)
top_ids = top_ids[1, :].reshape(-1, k + 1)
top_ids = top_ids[:, 1:]
top_labels = labels[top_ids]
preds = torch.eq(top_labels, labels.reshape(-1, 1))
logs[f"val_map@{k}"] = compute_map_at_k(preds)
return logs
def clone_classification_step(features, labels):
logits = torch.matmul(features, features.T)
mask = torch.eq(labels, labels.T)
return logits, mask
def prepare_features(queries, keys, labels):
features = torch.cat([queries, keys], dim=0)
labels = labels.contiguous().view(-1, 1)
labels = labels.repeat(2, 1)
return features, labels
def scale(x):
x = torch.clamp(x, min=-1, max=1)
return (x + 1) / 2
def compute_num_samples(train_data_path: str):
num_samples = 0
for class_ in listdir(train_data_path):
class_path = join(train_data_path, class_)
if isdir(class_path):
num_files = len([_ for _ in listdir(class_path)])
num_samples += num_files * (num_files - 1) // 2
return num_samples
```
#### File: contrastive-learning-framework/preprocess/tokenize.py
```python
from argparse import ArgumentParser
from os import listdir, remove
from os.path import splitext, join, isdir, exists
import youtokentome as yttm
from omegaconf import DictConfig, OmegaConf
def tokenize(config: DictConfig):
data_path = join(config.data_folder, config.dataset.name, config.dataset.dir)
model_path = join(data_path, config.dataset.tokenizer_name)
buffer_path = "text.yttm"
if exists(buffer_path):
remove(buffer_path)
for file in listdir(join(data_path, config.train_holdout)):
transformed_files_path = join(data_path, config.train_holdout, file)
if isdir(transformed_files_path):
for transformed_file in listdir(transformed_files_path):
file_path = join(transformed_files_path, transformed_file)
_, ext = splitext(file_path)
if ext in [".cpp", ".c"]:
with open(file_path, "r", encoding="utf8", errors='ignore') as file_:
text = file_.read() + "\n"
with open(buffer_path, "a") as buffer_:
buffer_.write(text)
_ = yttm.BPE.train(
data="text.yttm",
model=model_path,
pad_id=config.dataset.pad_id,
unk_id=config.dataset.unk_id,
bos_id=config.dataset.bos_id,
eos_id=config.dataset.eos_id,
vocab_size=config.dataset.vocab_size,
n_threads=config.num_workers
)
remove("text.yttm")
if __name__ == "__main__":
arg_parser = ArgumentParser()
arg_parser.add_argument("--config_path", type=str)
args = arg_parser.parse_args()
config_ = OmegaConf.load(args.config_path)
tokenize(config=config_)
```
|
{
"source": "JetBrains-Research/docs-fine-tuning",
"score": 3
}
|
#### File: docs-fine-tuning/approaches/abstract_approach.py
```python
import os
from abc import ABC, abstractmethod
import numpy as np
import pandas as pd
from text_models import AbstractModel
from data_processing.util import get_corpus
from typing import List
import matplotlib.pyplot as plt
class AbstractApproach(ABC):
def __init__(self, train: pd.DataFrame, test: pd.DataFrame):
self.train = train
self.test = test
self.train["id_num"] = np.arange(len(self.train.index))
self.test["id_num"] = np.arange(len(self.test.index))
self.train_corpus = get_corpus(train)
self.test_corpus = get_corpus(test)
self.embeddings = None
self.test_embs = None
self.results = None
self.test_size = None
self.TP = None
def evaluate_all(
self,
from_scratch_model: AbstractModel,
pretrained_model: AbstractModel,
finetuned_model: AbstractModel,
topns: List[int],
):
res_dict = {
"topn": topns,
"TASK": self.evaluate(from_scratch_model, topns),
"PT+TASK": self.evaluate(pretrained_model, topns),
"PT+DOC+TASK": self.evaluate(finetuned_model, topns),
}
self.results = pd.DataFrame.from_dict(res_dict)
print(self.results)
def save_results(self, save_to_path, model_name, graph=False):
if self.results is None:
raise ValueError("No results to save")
self.results.to_csv(os.path.join(save_to_path, model_name + ".csv"))
if graph:
self.results.plot(
x="topn",
y=["TASK", "PT+TASK", "PT+DOC+TASK"],
kind="line",
marker="o",
figsize=(7, 5),
title=model_name,
ylabel="success rate",
grid=True,
)
plt.savefig(os.path.join(save_to_path, model_name + ".png"))
def evaluate(self, model: AbstractModel, topns: List[int]) -> np.ndarray:
self.embeddings = model.get_embeddings(self.train_corpus)
self.test_embs = model.get_embeddings(self.test_corpus)
self.setup_approach()
self.test_size = 0
self.TP = np.zeros(len(topns))
def eval_sample(query_report):
if query_report.id != query_report.disc_id: # not in master ids
dupl_ids = self.get_duplicated_ids(query_report.id_num, max(topns))
for i, topn in enumerate(topns):
self.TP[i] += np.any(self.train.iloc[dupl_ids[:topn]]["disc_id"] == query_report.disc_id)
self.test_size += 1
self.train = self.train.append(query_report, ignore_index=True)
self.update_history(query_report.id_num)
self.test.apply(eval_sample, axis=1)
self.embeddings = None
self.test_embs = None
return self.TP / self.test_size
@abstractmethod
def setup_approach(self):
raise NotImplementedError()
@abstractmethod
def get_duplicated_ids(self, query_num: int, topn: int) -> np.ndarray:
raise NotImplementedError()
@abstractmethod
def update_history(self, query_num: int):
raise NotImplementedError()
```
#### File: docs-fine-tuning/approaches/intersection.py
```python
import numpy as np
import pandas as pd
from nltk import FreqDist
from approaches import AbstractApproach
from text_models import AbstractModel
class IntersectionApproach(AbstractApproach):
def __init__(self, train: pd.DataFrame, test: pd.DataFrame, min_count: int):
super(IntersectionApproach, self).__init__(train, test)
self.min_count = min_count
def setup_approach(self):
freq_dict = FreqDist()
for report in self.train_corpus:
freq_dict.update(report)
for report in self.test_corpus:
freq_dict.update(report)
self.test_corpus = [
list(filter(lambda x: freq_dict[x] >= self.min_count, report)) for report in self.test_corpus
]
self.train_corpus = [
list(filter(lambda x: freq_dict[x] >= self.min_count, report)) for report in self.train_corpus
]
def get_duplicated_ids(self, query_num, topn):
counts = []
for report in self.train_corpus:
count = len(set(report) & set(self.test_corpus[query_num]))
counts.append(count)
return np.argsort(counts)[::-1][:topn]
def update_history(self, query_num: int):
self.train_corpus.append(self.test_corpus[query_num])
class UtilModel(AbstractModel):
def __init__(self):
super(IntersectionApproach.UtilModel, self).__init__(0, 0)
def get_embeddings(self, corpus):
return None
```
#### File: docs-fine-tuning/text_models/bert.py
```python
import tempfile
import numpy as np
import torch
from gensim.test.utils import get_tmpfile
from tokenizers import BertWordPieceTokenizer
from torch.utils.data import DataLoader
from tqdm import tqdm
from transformers import AutoTokenizer, AutoModel, AutoModelForMaskedLM
from transformers import BertModel, BertConfig, BertForMaskedLM, BertTokenizerFast
from transformers import TrainingArguments, Trainer
from data_processing.util import get_corpus_properties
from text_models import AbstractModel
from text_models.datasets import BertModelDataset, BertModelMLMDataset
class BertModelMLM(AbstractModel):
def __init__(
self,
vector_size=384,
epochs=5,
batch_size=16,
mask_probability=0.15,
max_len=512,
pretrained_model="bert-base-uncased",
tmp_file=get_tmpfile("pretrained_vectors.txt"),
device="cpu",
seed=42,
save_to_path="./",
models_suffixes=None,
):
super().__init__(vector_size, epochs, pretrained_model, seed, save_to_path, models_suffixes)
self.tokenizer = None
self.device = torch.device(device)
self.tmp_file = tmp_file or get_tmpfile("pretrained_vectors.txt")
self.batch_size = batch_size
self.mask_probability = mask_probability
self.vocab_size = None
self.max_len = max_len
name = "BERT"
def train_from_scratch(self, corpus):
train_sentences = [" ".join(doc) for doc in corpus]
self.model, self.tokenizer = BertModelMLM.create_bert_model(train_sentences, self.tmp_file, self.max_len)
inputs = self.tokenizer(
train_sentences, max_length=self.max_len, padding="max_length", truncation=True, return_tensors="pt"
)
dataset = BertModelMLMDataset(
inputs, mask_id=4, cls_id=0, sep_id=2, pad_id=1, mask_probability=self.mask_probability
)
self.__train(dataset)
def train_pretrained(self, corpus):
self.tokenizer = AutoTokenizer.from_pretrained(self.pretrained_model)
self.model = AutoModelForMaskedLM.from_pretrained(self.pretrained_model)
sentences = [" ".join(sentence) for sentence in corpus]
inputs = self.tokenizer(
sentences, max_length=self.max_len, padding="max_length", truncation=True, return_tensors="pt"
)
dataset = BertModelMLMDataset(inputs, mask_probability=self.mask_probability)
self.__train(dataset)
def train_finetuned(self, base_corpus, extra_corpus):
sentences = [" ".join(sentence) for sentence in extra_corpus]
inputs = self.tokenizer(
sentences, max_length=self.max_len, padding="max_length", truncation=True, return_tensors="pt"
)
dataset = BertModelMLMDataset(inputs, mask_probability=self.mask_probability)
self.__train(dataset)
@staticmethod
def get_model_type_by_task(task):
if task == "mlm":
return BertForMaskedLM
if task == "sts":
return BertModel
raise ValueError("Unsupported task")
@staticmethod
def create_bert_model(train_sentences, tmp_file, max_len, task="mlm"):
model_type = BertModelMLM.get_model_type_by_task(task)
vocab_size, _ = get_corpus_properties([sentence.split(" ") for sentence in train_sentences])
with open(tmp_file, "w") as fp:
fp.write("\n".join(train_sentences))
tokenizer = BertWordPieceTokenizer(
clean_text=True, handle_chinese_chars=False, strip_accents=False, lowercase=True
)
tokenizer.train(
files=[tmp_file],
vocab_size=vocab_size,
min_frequency=1,
wordpieces_prefix="##",
special_tokens=["[CLS]", "[PAD]", "[SEP]", "[UNK]", "[MASK]"],
)
save_to_path = tempfile.mkdtemp()
tokenizer.save_model(save_to_path)
tokenizer = BertTokenizerFast.from_pretrained(save_to_path, max_len=max_len + 2)
bert_config = BertConfig(
vocab_size=vocab_size,
max_position_embeddings=max_len + 2,
hidden_size=768, # maybe vector_size
num_attention_heads=12,
num_hidden_layers=6,
type_vocab_size=1,
)
dumb_model = model_type(bert_config)
return dumb_model, tokenizer
def __train(self, dataset):
args = TrainingArguments(
output_dir=self.save_to_path, per_device_train_batch_size=self.batch_size, num_train_epochs=self.epochs
)
trainer = Trainer(model=self.model, args=args, train_dataset=dataset)
trainer.train()
def get_doc_embedding(self, doc):
return self.get_embeddings([doc])[0]
def get_embeddings(self, corpus):
descriptions = [" ".join(doc) for doc in corpus]
encoded_input = self.tokenizer(
descriptions, max_length=self.max_len, padding="max_length", truncation=True, return_tensors="pt"
)
dataset = BertModelDataset(encoded_input)
loader = DataLoader(dataset, batch_size=self.batch_size, shuffle=False)
result = []
loop = tqdm(loader, leave=True)
for batch in loop:
input_ids = batch["input_ids"].to(self.device)
attention_mask = batch["attention_mask"].to(self.device)
with torch.no_grad():
model_output = self.model(input_ids, attention_mask=attention_mask)
sentence_embeddings = BertModelMLM.__mean_pooling(model_output, attention_mask)
result += sentence_embeddings.tolist()
return np.array(result).astype(np.float32)
@staticmethod
def __mean_pooling(model_output, attention_mask):
token_embeddings = model_output[0]
input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
def save(self, path):
self.tokenizer.save_pretrained(path)
self.model.save_pretrained(path)
@classmethod
def load(cls, path):
bertModel = BertModelMLM()
model = AutoModel.from_pretrained(path)
tokenizer = AutoTokenizer.from_pretrained(path)
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") # TODO
bertModel.model = model
bertModel.device = device
bertModel.tokenizer = tokenizer
bertModel.model.to(device)
return bertModel
```
#### File: text_models/datasets/bert_mlm.py
```python
import torch
import numpy as np
from text_models.datasets import BertModelDataset
class BertModelMLMDataset(BertModelDataset):
def __init__(self, encodings, mask_id=103, cls_id=102, sep_id=101, pad_id=0, mask_probability=0.15):
super(BertModelMLMDataset, self).__init__(encodings)
self.encodings["labels"] = self.encodings.input_ids.detach().clone()
self.mask_proba = mask_probability
self.mask_id = mask_id
self.cls_id = cls_id
self.sep_id = sep_id
self.pad_id = pad_id
self.masked = np.full(self.__len__(), False)
def __getitem__(self, idx):
if self.masked[idx] == False:
inputs = self.encodings.input_ids[idx]
rand = torch.rand(inputs.shape)
mask_arr = (
(rand < self.mask_proba) * (inputs != self.cls_id) * (inputs != self.sep_id) * (inputs != self.pad_id)
)
inputs[mask_arr] = self.mask_id
self.encodings.input_ids[idx] = inputs
self.masked[idx] = True
return super().__getitem__(idx)
```
|
{
"source": "JetBrains-Research/embeddings-for-trees",
"score": 3
}
|
#### File: embeddings_for_trees/data/vocabulary.py
```python
from argparse import ArgumentParser
from collections import Counter
from json import JSONDecodeError, loads
from typing import Counter as CounterType, Optional
from typing import Dict
from commode_utils.vocabulary import BaseVocabulary, build_from_scratch
from embeddings_for_trees.utils.common import AST
class Vocabulary(BaseVocabulary):
NODE = "nodeType"
@staticmethod
def process_raw_sample(raw_sample: str, counters: Dict[str, CounterType[str]]):
try:
sample = loads(raw_sample)
except JSONDecodeError:
with open(Vocabulary._log_filename, "a") as log_file:
log_file.write(raw_sample + "\n")
return
counters[Vocabulary.LABEL].update(sample[Vocabulary.LABEL].split(Vocabulary._separator))
for node in sample[AST]:
counters[Vocabulary.TOKEN].update(node[Vocabulary.TOKEN].split(Vocabulary._separator))
counters[Vocabulary.NODE].update([node[Vocabulary.NODE]])
class TypedVocabulary(Vocabulary):
TYPE = "tokenType"
def __init__(
self,
vocabulary_file: str,
max_labels: Optional[int] = None,
max_tokens: Optional[int] = None,
max_types: Optional[int] = None,
):
super().__init__(vocabulary_file, max_labels, max_tokens)
self._type_to_id = {self.PAD: 0, self.UNK: 1, self.SOS: 2, self.EOS: 3}
self._type_to_id.update(
(token[0], i + 4) for i, token in enumerate(self._counters[self.TYPE].most_common(max_types))
)
@property
def type_to_id(self) -> Dict[str, int]:
return self._type_to_id
@staticmethod
def process_raw_sample(raw_sample: str, counters: Dict[str, CounterType[str]]):
try:
sample = loads(raw_sample)
except JSONDecodeError:
with open(TypedVocabulary._log_filename, "a") as log_file:
log_file.write(raw_sample + "\n")
return
if TypedVocabulary.TYPE not in counters:
counters[TypedVocabulary.TYPE] = Counter()
counters[TypedVocabulary.LABEL].update(sample[TypedVocabulary.LABEL].split(TypedVocabulary._separator))
for node in sample[AST]:
counters[TypedVocabulary.TOKEN].update(node[TypedVocabulary.TOKEN].split(TypedVocabulary._separator))
counters[TypedVocabulary.NODE].update([node[TypedVocabulary.NODE]])
counters[TypedVocabulary.TYPE].update(node[TypedVocabulary.TYPE].split(TypedVocabulary._separator))
if __name__ == "__main__":
arg_parse = ArgumentParser()
arg_parse.add_argument("data", type=str, help="Path to file with data")
arg_parse.add_argument("--typed", action="store_true", help="Use typed vocabulary")
args = arg_parse.parse_args()
_vocab_cls = TypedVocabulary if args.typed else Vocabulary
build_from_scratch(args.data, _vocab_cls)
```
#### File: embeddings-for-trees/embeddings_for_trees/typed_treelstm.py
```python
from argparse import ArgumentParser
from typing import cast
import torch
from commode_utils.common import print_config
from omegaconf import OmegaConf, DictConfig
from embeddings_for_trees.data.jsonl_data_module import JsonlTypedASTDatamodule
from embeddings_for_trees.models import TypedTreeLSTM2Seq
from embeddings_for_trees.utils.common import filter_warnings
from embeddings_for_trees.utils.test import test
from embeddings_for_trees.utils.train import train
def configure_arg_parser() -> ArgumentParser:
arg_parser = ArgumentParser()
arg_parser.add_argument("mode", help="Mode to run script", choices=["train", "test"])
arg_parser.add_argument("-c", "--config", help="Path to YAML configuration file", type=str)
return arg_parser
def train_typed_treelstm(config: DictConfig):
filter_warnings()
if config.print_config:
print_config(config, fields=["model", "data", "train", "optimizer"])
# Load data module
data_module = JsonlTypedASTDatamodule(config.data, config.data_folder)
data_module.prepare_data()
data_module.setup()
# Load model
typed_treelstm2seq = TypedTreeLSTM2Seq(
config.model, config.optimizer, data_module.vocabulary, config.train.teacher_forcing
)
train(typed_treelstm2seq, data_module, config)
def test_typed_treelstm(config: DictConfig):
filter_warnings()
# Load data module
data_module = JsonlTypedASTDatamodule(config.data, config.data_folder)
data_module.prepare_data()
data_module.setup()
# Load model
typed_treelstm2seq = TypedTreeLSTM2Seq.load_from_checkpoint(config.checkpoint, map_location=torch.device("cpu"))
test(typed_treelstm2seq, data_module, config.seed)
if __name__ == "__main__":
__arg_parser = configure_arg_parser()
__args = __arg_parser.parse_args()
__config = cast(DictConfig, OmegaConf.load(__args.config))
if __args.mode == "train":
train_typed_treelstm(__config)
else:
test_typed_treelstm(__config)
```
|
{
"source": "JetBrains-Research/extract-method-experiments",
"score": 3
}
|
#### File: ml-framework/src/dataset_importer.py
```python
import os
import pandas as pd
class TrainImporter:
def __init__(self, config):
self.path_to_positive = os.path.join(config.get('datasets_dir_path'), config.get('positive_dataset_name'))
self.path_to_negative = os.path.join(config.get('datasets_dir_path'), config.get('negative_dataset_name'))
self.quantile_to_negative = config.get('quantile_to_negative')
self.df_pos = pd.read_csv(self.path_to_positive, delimiter=';').dropna()
self.df_neg = pd.read_csv(self.path_to_negative, delimiter=';').dropna()
def make_binary(self):
"""
Makes and returns a pair x, y which correspond to features(x) and targets(y) dataframe,
each sample has target label of 1 or 0, suitable for binary classification.
"""
negatives = self.df_neg[self.df_neg.Score <= self.df_neg.Score.quantile(
self.quantile_to_negative)] # Filter only lower part, up to specified quantile
negatives = negatives.assign(label=lambda value: 0) # Set label to zero, meaning negative
negatives = negatives.drop(columns=['Score'])
positives = self.df_pos.assign(label=lambda value: 1) # Set label to one, meaning positive
whole_df = pd.concat([positives, negatives], ignore_index=True).drop(columns='RepositoryName').sample(frac=1)
x = whole_df.drop(columns=['label'])
y = whole_df.label
return x, y
class TestImporter:
def __init__(self, config):
pos_path = os.path.join(config.get('datasets_dir_path'), config.get('positive_dataset_name'))
neg_path = os.path.join(config.get('datasets_dir_path'), config.get('negative_dataset_name'))
positives = pd.read_csv(pos_path, delimiter=';').dropna().drop(columns=['RepositoryName'])
negatives = pd.read_csv(neg_path, delimiter=';').dropna().drop(columns=['RepositoryName', 'Score'])
self.df = pd.concat([positives, negatives], ignore_index=True)
def make_test(self):
return self.df.drop(columns=['label']), self.df.label
```
#### File: ml-framework/src/trainer.py
```python
from sklearn.metrics import classification_report
from .dataset_importer import TrainImporter, TestImporter
from .trainmodel import TrainModel, TestModel
from .utils import import_train_configuration, import_test_configuration
def train_by_config(config_path):
config = import_train_configuration(config_file=config_path)
dataset_importer = TrainImporter(config)
x, y = dataset_importer.make_binary()
print('Imported the dataset')
model = TrainModel(config)
print('Created the model')
model.train(x, y)
print('Training finished')
model.save_training_config(config_path)
# saving model in pmml can cause errors, use with care
# model.save_pmml()
def test_by_config(config_path):
config = import_test_configuration(config_path)
dataset_importer = TestImporter(config)
x, y = dataset_importer.make_test()
model = TestModel(config.get('model_path'))
model.test(x, y)
model.save_testing_config(config_path)
# model.save_pmml()
```
|
{
"source": "JetBrains-Research/fine-tuning-ml-models",
"score": 2
}
|
#### File: fine-tuning-ml-models/experiments/fine_tune_and_calc_results.py
```python
from argparse import ArgumentParser
from time import time_ns
import os
from scripts.fine_tune import train_and_test
from scripts.dump_results import extract
from scripts.save_metrics import calculate_and_dump_metrics
from scripts.utils import PREPROCESSED_DATASETS_DIR, RESULTS_DIR, EXPERIMENT_MODEL_DIR, CODE2SEQ_VOCABULARY
def run_models_and_save_results(project_name: str, model_path: str) -> None:
dataset_path = os.path.join(PREPROCESSED_DATASETS_DIR, project_name)
run_name = f"{project_name}_{time_ns()}"
result_folder = os.path.join(RESULTS_DIR, run_name)
os.makedirs(result_folder)
new_model_folder = os.path.join(EXPERIMENT_MODEL_DIR, run_name, "new")
os.makedirs(new_model_folder)
new_path, new_before, new_after = train_and_test(dataset_path, new_model_folder)
with open(os.path.join(result_folder, "new_after.jsonl"), "w") as f:
print(*new_after, file=f)
vocabulary = os.path.join(dataset_path, "vocabulary.pkl")
new_after_names = extract(new_path, dataset_path, vocabulary, os.path.join(result_folder, "new_after_names.txt"))
calculate_and_dump_metrics(new_after_names, os.path.join(result_folder, "new_after_metrics.csv"))
trained_model_folder = os.path.join(EXPERIMENT_MODEL_DIR, run_name, "trained")
os.makedirs(trained_model_folder)
trained_path, trained_before, trained_after = train_and_test(dataset_path, trained_model_folder, model_path)
with open(os.path.join(result_folder, "trained_before.jsonl"), "w") as f:
print(*trained_before, file=f)
trained_before_names = extract(
model_path, dataset_path, CODE2SEQ_VOCABULARY, os.path.join(result_folder, "trained_before_names.txt")
)
calculate_and_dump_metrics(trained_before_names, os.path.join(result_folder, "trained_before_metrics.csv"))
with open(os.path.join(result_folder, "trained_after.jsonl"), "w") as f:
print(*trained_after, file=f)
trained_after_names = extract(
trained_path, dataset_path, CODE2SEQ_VOCABULARY, os.path.join(result_folder, "trained_after_names.txt")
)
calculate_and_dump_metrics(trained_after_names, os.path.join(result_folder, "trained_after_metrics.csv"))
def evaluate_on_many_datasets(filename: str, model_path: str) -> None:
"""Evaluate models on each project's dataset"""
with open(filename, "r") as projects_file:
for project in projects_file:
run_models_and_save_results(project.strip(), model_path)
if __name__ == "__main__":
arg_parser = ArgumentParser()
arg_parser.add_argument("projects_file", type=str, help="A path to file with list of preprocessed projects' names")
arg_parser.add_argument("model", type=str, help="Path to pretrained code2seq model")
args = arg_parser.parse_args()
evaluate_on_many_datasets(args.projects_file, args.model)
```
|
{
"source": "JetBrains-Research/gorshochek",
"score": 3
}
|
#### File: scripts/postprocessing/delete_duplicates.py
```python
import shutil
from argparse import ArgumentParser
from os import remove, listdir
from os.path import join, exists, dirname
def get_path(file: str, dataset_path: str) -> str:
file_ = file.rsplit(".", 1)[0]
file_path = join(dataset_path, file_)
return file_path
def delete_duplicates(duplicates_file_path: str):
with open(duplicates_file_path, "r") as f:
duplicates_text = f.read().strip()
duplicates = []
for duplicates_batch in duplicates_text.split("\n\n"):
duplicates += [duplicates_batch.split("\n")]
for batch in duplicates:
parent_dirs = [dirname(file) for file in batch]
unique_parents = list(set(parent_dirs))
if len(unique_parents) == 1:
# Remove all duplicates which came from the same origin
parent_dir = dirname(batch[0])
# Remove dir if all files are not duplicates of each other
if len(listdir(parent_dir)) > len(batch):
# Leave only single file
for file in batch[1:]:
if exists(file):
remove(file)
else:
shutil.rmtree(parent_dir)
else:
# Remove duplicates came from different origins,
# leaving only the first one. Later we will move all
# transformed files which are not duplicates to the dir
# corresponding to the file which was not deleted
for file in batch[1:]:
if exists(file):
remove(file)
for batch in duplicates:
# Some duplicates came from different origins
parent_dirs = [dirname(file) for file in batch]
unique_parents = list(set(parent_dirs))
if len(unique_parents) > 1:
base_dir = parent_dirs[0]
for i, file in enumerate(listdir(base_dir)):
shutil.move(join(base_dir, file), join(base_dir, f"transformation_{i}.cpp"))
num_default = len(listdir(base_dir))
files_to_move = []
# Collect the remaining files from the dirs where duplicates were found
for parent in unique_parents:
if exists(parent):
files_to_move += [join(parent, file) for file in listdir(parent)]
for i, file in enumerate(files_to_move):
shutil.move(file, join(base_dir, f"transformation_{i + num_default}.cpp"))
if __name__ == "__main__":
arg_parser = ArgumentParser()
arg_parser.add_argument(
"--duplicates_file_path",
type=str,
default=join("data", "codeforces_augmented", "duplicates.txt")
)
args = arg_parser.parse_args()
delete_duplicates(duplicates_file_path=args.duplicates_file_path)
```
|
{
"source": "JetBrains-Research/graph-code-nets",
"score": 3
}
|
#### File: graph-code-nets/data_processing/commode_utils_extension.py
```python
import os
import random
from commode_utils.filesystem import get_lines_offsets, count_lines_in_file
from bisect import bisect_left
def get_files_offsets(data_dir: str, debug: bool) -> list:
files_offsets = list()
files = os.listdir(data_dir)
if not debug:
random.shuffle(files)
for file_name in os.listdir(data_dir):
files_offsets.append(get_lines_offsets(os.path.join(data_dir, file_name)))
return files_offsets
def get_files_count_lines(data_dir: str) -> list:
files_pref_sum_lines = list()
cumulative_sum = 0
for file_name in os.listdir(data_dir):
cumulative_sum += count_lines_in_file(os.path.join(data_dir, file_name))
files_pref_sum_lines.append(cumulative_sum)
return files_pref_sum_lines
def get_file_index(files_count_lines: list, index: int) -> tuple[int, int]:
left_bound = bisect_left(files_count_lines, index)
return left_bound, index - files_count_lines[left_bound]
```
#### File: graph-code-nets/models/encoder_gru.py
```python
import pytorch_lightning as pl
import torch
class EncoderGRU(pl.LightningModule):
def __init__(self, model_config: dict):
super().__init__()
self.hidden_dim = model_config["hidden_dim"]
self.num_layers = model_config["num_layers"]
self.dropout_rate = model_config["dropout_rate"]
self.rnn = torch.nn.GRU(
input_size=self.hidden_dim,
hidden_size=self.hidden_dim // 2,
num_layers=self.num_layers,
batch_first=True,
dropout=self.dropout_rate,
bidirectional=True,
)
def forward(self, states: torch.Tensor) -> torch.Tensor: # type: ignore[override]
return self.rnn(states)
```
#### File: graph-code-nets/models/wraped_model.py
```python
import numpy as np
import models.util as util
import torch
import torch.nn.functional as F
from models import two_pointer_fcn, encoder_gru
import pytorch_lightning as pl
from models.util import (
sparse_categorical_accuracy,
sparse_softmax_cross_entropy_with_logits,
)
class VarMisuseLayer(pl.LightningModule):
def __init__(self, config: dict, vocab_dim: int):
super().__init__()
self._model_config = config["model"]
self._data_config = config["data"]
self._training_config = config["training"]
self._vocab_dim = vocab_dim
self._device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self._embedding = torch.nn.Embedding(
self._vocab_dim, self._model_config["base"]["hidden_dim"]
)
base_config = self._model_config["base"]
inner_model = self._model_config["configuration"]
self._prediction = two_pointer_fcn.TwoPointerFCN(base_config)
if inner_model == "rnn":
self._model = encoder_gru.EncoderGRU(
util.join_dicts(base_config, self._model_config["rnn"]),
)
else:
raise ValueError("Unknown model component provided:", inner_model)
def forward( # type: ignore[override]
self, tokens: torch.Tensor, token_mask: torch.Tensor, edges: torch.Tensor
) -> torch.Tensor:
original_shape = list(
np.append(np.array(tokens.shape), self._model_config["base"]["hidden_dim"])
)
flat_tokens = tokens.type(torch.long).flatten().to(self._device)
subtoken_embeddings = self._embedding(flat_tokens)
subtoken_embeddings = torch.reshape(subtoken_embeddings, original_shape)
subtoken_embeddings *= torch.unsqueeze(torch.clamp(tokens, 0, 1), -1).to(
self._device
)
states = torch.mean(subtoken_embeddings, 2)
predictions = torch.transpose(self._prediction(self._model(states)[0]), 1, 2)
return predictions
def training_step(self, batch: torch.Tensor, batch_idx: int) -> torch.Tensor: # type: ignore[override]
return self._shared_eval_step(batch, batch_idx, "train")
def validation_step(self, batch: torch.Tensor, batch_idx: int) -> torch.Tensor: # type: ignore[override]
return self._shared_eval_step(batch, batch_idx, "val")
def test_step(self, batch: torch.Tensor, batch_idx: int) -> torch.Tensor: # type: ignore[override]
return self._shared_eval_step(batch, batch_idx, "test")
def _shared_eval_step(
self, batch: torch.Tensor, batch_idx: int, step: str
) -> torch.Tensor:
tokens, edges, error_loc, repair_targets, repair_candidates = batch
token_mask = torch.clamp(torch.sum(tokens, -1), 0, 1)
pointer_preds = self(tokens, token_mask, edges)
is_buggy, loc_predictions, target_probs = self._shared_loss_acs_calc(
pointer_preds, token_mask, error_loc, repair_targets, repair_candidates
)
losses = self.test_get_losses(
is_buggy, loc_predictions, target_probs, error_loc
)
accuracies = self.test_get_accuracies(
is_buggy, loc_predictions, target_probs, error_loc
)
total_loss: torch.Tensor = sum(losses.values()) # type: ignore[assignment]
self.log(
step + "_loss",
losses,
prog_bar=True,
on_epoch=True,
batch_size=self._data_config["batch_size"],
)
self.log(
step + "_acc",
accuracies,
prog_bar=True,
on_epoch=True,
batch_size=self._data_config["batch_size"],
)
return total_loss
def configure_optimizers(self) -> torch.optim.Optimizer:
return torch.optim.Adam(
self.parameters(), lr=self._training_config["learning_rate"]
)
def _shared_loss_acs_calc(
self,
predictions: torch.Tensor,
token_mask: torch.Tensor,
error_locations: torch.Tensor,
repair_targets: torch.Tensor,
repair_candidates: torch.Tensor,
) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
seq_mask = token_mask.float()
predictions += (1.0 - torch.unsqueeze(seq_mask, 1)) * torch.finfo(
torch.float32
).min
is_buggy = torch.clamp(error_locations, 0, 1).float()
loc_predictions = predictions[:, 0]
pointer_logits = predictions[:, 1]
candidate_mask = torch.zeros(pointer_logits.size())
for e in repair_candidates:
candidate_mask[e[0]][e[1]] = 1
candidate_mask = candidate_mask.to(self._device)
pointer_logits += (1.0 - candidate_mask) * torch.finfo(torch.float32).min
pointer_probs = F.softmax(pointer_logits, dim=-1)
target_mask = torch.zeros(pointer_probs.size())
for e in repair_targets:
target_mask[e[0]][e[1]] = 1
target_mask = target_mask.to(self._device)
target_probs = torch.sum(target_mask * pointer_probs, -1)
return is_buggy, loc_predictions, target_probs
def test_get_losses(
self,
is_buggy: torch.Tensor,
loc_predictions: torch.Tensor,
target_probs: torch.Tensor,
error_locations: torch.Tensor,
) -> dict[str, torch.Tensor]:
loc_loss = sparse_softmax_cross_entropy_with_logits(
error_locations, loc_predictions
)
loc_loss = torch.mean(loc_loss)
target_loss = torch.sum(is_buggy * -torch.log(target_probs + 1e-9)) / (
1e-9 + torch.sum(is_buggy)
)
return {"loc_loss": loc_loss, "target_loss": target_loss}
def test_get_accuracies(
self,
is_buggy: torch.Tensor,
loc_predictions: torch.Tensor,
target_probs: torch.Tensor,
error_locations: torch.Tensor,
) -> dict[str, torch.Tensor]:
rep_accuracies = (target_probs >= 0.5).type(torch.float32).to(self._device)
loc_accuracies = sparse_categorical_accuracy(error_locations, loc_predictions)
no_bug_pred_acc = torch.sum((1 - is_buggy) * loc_accuracies) / (
1e-9 + torch.sum(1 - is_buggy)
)
if torch.sum(1 - is_buggy) == 0:
no_bug_pred_acc = torch.tensor(1)
bug_loc_acc = torch.sum(is_buggy * loc_accuracies) / (
1e-9 + torch.sum(is_buggy)
)
target_loc_acc = torch.sum(is_buggy * rep_accuracies) / (
1e-9 + torch.sum(is_buggy)
)
joint_acc = torch.sum(is_buggy * loc_accuracies * rep_accuracies) / (
1e-9 + torch.sum(is_buggy)
)
return {
"no_bug_pred_acc": no_bug_pred_acc,
"bug_loc_acc": bug_loc_acc,
"target_loc_acc": target_loc_acc,
"joint_acc": joint_acc,
}
```
|
{
"source": "JetBrains-Research/jpt-nb-corpus",
"score": 3
}
|
#### File: notebook_analyzer/processors/cell_processor.py
```python
from abc import ABC
class CellProcessor(ABC):
task_mapping = {}
cell = {}
def process_cell(self, tasks) -> dict:
functions = [
function for function, executing in tasks.items()
if (function in self.task_mapping.keys() and executing is True)
]
for function in functions:
self.cell[function] = self.task_mapping[function](self.cell)
return self.cell
```
#### File: test/scripts/functions.py
```python
from api_functions import api_function1, api_function2
from package3 import api_function3
# API Packages
import package1, package2
import package3
from package4 import api_class1
# Defined functions
def defined_function_1(d_f_arg1, d_f_arg2):
a = api_function1(d_f_arg1)
b = (api_function2(d_f_arg2, d_f_arg1), api_function3())
def defined_function_2(d_f_arg1, d_f_arg2, d_f_arg3):
api_function1()
package1.p1_function1(d_f_arg1, d_f_arg2, d_f_arg3)
a, b = api_class1.cl1_function1(1, 2, '3')
def defined_function_3():
package1.p1_function1()
package3.p3_function1()
```
|
{
"source": "JetBrains-Research/Lupa",
"score": 4
}
|
#### File: jupyter/data/out_5.py
```python
import numpy as np
import plt.pyplot as plt
x = np.linspace(-2, 2, 9).reshape((3,3))
print(x / 2)
print('hello')
def foo(x: int = 1):
assert(isinstance(x, np.ndarray))
return x * x / 2
print(foo(x))
class A:
def __init__(self):
self.string = "It's class A"
def create_a():
a = A()
return a
lots_of_A = [create_a().string for _ in range(100)]
print(lots_of_A[3:5])
```
#### File: psi/decoratorPsiAnalyzerTestData/in_1_stdlib.py
```python
from functools import lru_cache, cached_property, total_ordering, singledispatch, wraps
@lru_cache
def some_cached_function():
pass
@total_ordering
class SomeClass:
@cached_property
def some_cached_property(self):
pass
@singledispatch
def fun(arg, verbose=False):
if verbose:
print("Let me just say,", end=" ")
print(arg)
@fun.register
def _(arg: int, verbose=False):
if verbose:
print("Strength in numbers, eh?", end=" ")
print(arg)
@fun.register
def _(arg: list, verbose=False):
if verbose:
print("Enumerate this:")
for i, elem in enumerate(arg):
print(i, elem)
@fun.register(complex)
def _(arg, verbose=False):
if verbose:
print("Better than complicated.", end=" ")
print(arg.real, arg.imag)
def my_decorator(f):
@wraps(f)
def wrapper(*args, **kwargs):
print('Calling decorated function')
return f(*args, **kwargs)
return wrapper
```
#### File: src/second_package/main.py
```python
from first_package.main import some_function
def another_function():
for x in range(0, 10):
if some_function(x):
print('True!')
```
#### File: scripts/data_collection/repositories_table.py
```python
import enum
from datetime import datetime
from typing import List, Optional, Tuple
from data_collection.db_connect import DatabaseConn
from psycopg2 import sql
from psycopg2.sql import Identifier, Literal
class RepositoriesTableNames(str, enum.Enum):
TABLE = 'kotlin_repositories_updates'
REPO_ID = 'repository_id'
USERNAME = 'username'
REPO_NAME = 'repo_name'
LAST_PULL_DATE = 'last_pull_date'
LAST_ANALYSIS_DATE = 'last_analysis_date'
class RepositoriesTable:
def __init__(self, conn: DatabaseConn):
self._conn = conn
def create(self):
if self._conn is not None:
self._conn.execute(
sql.SQL(f"""
create table if not exists {RepositoriesTableNames.TABLE.value} (
{RepositoriesTableNames.REPO_ID.value} serial primary key,
{RepositoriesTableNames.USERNAME.value} varchar(64) not null,
{RepositoriesTableNames.REPO_NAME.value} varchar(255) not null,
{RepositoriesTableNames.LAST_PULL_DATE.value} date not null,
{RepositoriesTableNames.LAST_ANALYSIS_DATE.value} date,
unique ({RepositoriesTableNames.USERNAME.value}, {RepositoriesTableNames.REPO_NAME.value}))"""))
def update_pull_date(self, username: str, repo_name: str, last_pull_date: datetime.date):
if self._conn is not None:
query = sql.SQL("""
update {table_name}
set {pull_date_col} = {pull_date}
where {username_col} = {username}
and {repo_name_col} = {repo_name}""")
self._conn.execute(self.format_sql(query, username, repo_name, last_pull_date))
def insert(self, username: str, repo_name: str, last_pull_date: datetime.date):
if self._conn is not None:
query = sql.SQL("""
insert into {table_name}({username_col}, {repo_name_col}, {pull_date_col})
values ({username}, {repo_name}, {pull_date})""")
self._conn.execute(self.format_sql(query, username, repo_name, last_pull_date))
def exists_repository(self, username: str, repo_name: str) -> bool:
if self._conn is None:
return False
query = sql.SQL("""
select {pull_date_col} from {table_name}
where {username_col} = {username} and {repo_name_col} = {repo_name}
""")
return bool(self._conn.execute(
self.format_sql(query, username, repo_name), has_res=True))
def select_repositories_to_analyse(self) -> Optional[List[Tuple[str]]]:
if self._conn is None:
return None
query = sql.SQL("""
select {username_col}, {repo_name_col} from {table_name}
where {pull_date_col} > {analysis_date_col}
or {analysis_date_col} is null""")
return self._conn.execute(self.format_sql(query), has_res=True)
@staticmethod
def format_sql(query: sql.SQL, username: str = None, repo_name: str = None, last_pull_date=None) -> sql.Composed:
return query.format(table_name=Identifier(RepositoriesTableNames.TABLE.value),
username_col=Identifier(RepositoriesTableNames.USERNAME.value),
repo_name_col=Identifier(RepositoriesTableNames.REPO_NAME.value),
pull_date_col=Identifier(RepositoriesTableNames.LAST_PULL_DATE.value),
analysis_date_col=Identifier(RepositoriesTableNames.LAST_ANALYSIS_DATE.value),
username=Literal(username),
repo_name=Literal(repo_name),
pull_date=sql.Literal(last_pull_date))
```
#### File: plugin_runner/python_version/test_determine_python_version.py
```python
from pathlib import Path
from test.plugin_runner.python_version import SETUP_FILES_TEST_DATA_FOLDER
from typing import Optional, Set
from plugin_runner.python_version.determine_python_version import (
_try_to_determine_version_using_classifiers,
_try_to_find_version_in_setup_file,
)
from plugin_runner.python_version.python_classifiers import PythonVersion
import pytest
FIND_VERSION_IN_SETUP_FILE_TEST_DATA = [
('empty_file.py', None),
('without_python_classifiers.py', None),
('python_3_only_classifier_1.py', PythonVersion.PYTHON_3),
('python_3_only_classifier_2.py', PythonVersion.PYTHON_3),
('python_2_only_classifier_1.py', PythonVersion.PYTHON_2),
('python_2_only_classifier_2.py', PythonVersion.PYTHON_2),
('python_3_classifiers_1.py', PythonVersion.PYTHON_3),
('python_3_classifiers_2.py', PythonVersion.PYTHON_3),
('python_2_classifiers_1.py', PythonVersion.PYTHON_2),
('python_2_classifiers_2.py', PythonVersion.PYTHON_3),
]
@pytest.mark.parametrize(('file_name', 'expected_version'), FIND_VERSION_IN_SETUP_FILE_TEST_DATA)
def test_try_to_find_version_in_setup_file(file_name: Path, expected_version: PythonVersion):
file_path = SETUP_FILES_TEST_DATA_FOLDER / file_name
assert _try_to_find_version_in_setup_file(file_path) == expected_version
DETERMINE_VERSION_USING_CLASSIFIERS_TEST_DATA = [
(
{
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
'Programming Language :: Python :: 3.9',
},
PythonVersion.PYTHON_3,
),
(
{
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
},
PythonVersion.PYTHON_2,
),
(
{
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
'Programming Language :: Python :: 3.9',
},
PythonVersion.PYTHON_MIXED,
),
(
{
'Operating System :: POSIX',
'Topic :: Software Development',
'Programming Language :: Python',
'License :: OSI Approved',
},
None,
),
(set(), None),
]
@pytest.mark.parametrize(('classifiers', 'expected_versions'), DETERMINE_VERSION_USING_CLASSIFIERS_TEST_DATA)
def test_try_to_determine_version_using_classifiers(classifiers: Set[str], expected_versions: Optional[PythonVersion]):
assert _try_to_determine_version_using_classifiers(classifiers) == expected_versions
```
#### File: utils/python/test_pypi_utils.py
```python
from distutils.version import Version
from typing import Optional, Set
from httpretty import httpretty
import pkg_resources
import pytest
from utils.python.pypi_utils import (
PYPI_PACKAGE_METADATA_URL,
PYPI_VERSION_METADATA_URL,
check_package_exists,
get_available_versions,
get_package_classifiers,
)
@pytest.fixture
def _httpretty_fixture():
httpretty.enable(allow_net_connect=False)
yield
httpretty.disable()
GET_AVAILABLE_VERSIONS_TEST_DATA = [
(
'numpy',
"""
{
"releases": {
"1.2.3": {},
"3.4.5": {},
"6.7.8": {}
}
}
""",
set(map(pkg_resources.parse_version, ['1.2.3', '3.4.5', '6.7.8'])),
),
(
'numpy',
"""
{
"releases": {}
}
""",
set(),
),
(
'numpy',
'This is not a json.',
set(),
),
(
'numpy',
"""
{
"incorrect_key": {
"1.2.3": {},
"3.4.5": {},
"6.7.8": {}
}
}
""",
set(),
),
]
@pytest.mark.parametrize(('package_name', 'response_json', 'expected_versions'), GET_AVAILABLE_VERSIONS_TEST_DATA)
def test_get_available_versions(
_httpretty_fixture,
package_name: str,
response_json: str,
expected_versions: Set[Version],
):
httpretty.register_uri(
httpretty.GET,
PYPI_PACKAGE_METADATA_URL.format(package_name=package_name),
body=response_json,
)
assert expected_versions == get_available_versions(package_name)
GET_PACKAGE_CLASSIFIERS_TEST_DATA = [
(
"""
{
"info": {
"classifiers": [
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8"
]
}
}
""",
'1.0.0',
{
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
},
),
(
"""
{
"info": {
"classifiers": []
}
}
""",
'1.0.0',
set(),
),
(
'This is not a json.',
'1.0.0',
set(),
),
(
"""
{
"incorrect_key": {
"classifiers": [
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8"
]
}
}
""",
'1.0.0',
set(),
),
(
"""
{
"info": {
"incorrect_key": [
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8"
]
}
}
""",
'1.0.0',
set(),
),
(
"""
{
"info": {
"classifiers": [
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8"
]
}
}
""",
None,
{
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
},
),
(
"""
{
"info": {
"classifiers": []
}
}
""",
None,
set(),
),
(
'This is not a json.',
None,
set(),
),
(
"""
{
"incorrect_key": {
"classifiers": [
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8"
]
}
}
""",
None,
set(),
),
(
"""
{
"info": {
"incorrect_key": [
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8"
]
}
}
""",
None,
set(),
),
]
@pytest.mark.parametrize(
('response_json', 'package_version', 'expected_classifiers'),
GET_PACKAGE_CLASSIFIERS_TEST_DATA,
)
def test_get_package_classifiers(
_httpretty_fixture,
response_json: str,
package_version: Optional[str],
expected_classifiers: Set[str],
):
uri = (
PYPI_PACKAGE_METADATA_URL.format(package_name='some_package')
if package_version is None
else PYPI_VERSION_METADATA_URL.format(package_name='some_package', package_version=package_version)
)
httpretty.register_uri(httpretty.GET, uri=uri, body=response_json)
assert expected_classifiers == get_package_classifiers('some_package', package_version)
CHECK_PACKAGE_EXISTS_TEST_DATA = [
(
200,
True,
),
(
404,
False,
),
(
300,
None,
),
]
@pytest.mark.parametrize(('html_status', 'expected_existence'), CHECK_PACKAGE_EXISTS_TEST_DATA)
def test_check_package_exists(
_httpretty_fixture,
html_status: int,
expected_existence: Optional[bool],
):
httpretty.register_uri(
httpretty.GET,
PYPI_PACKAGE_METADATA_URL.format(package_name='some_package'),
status=html_status,
)
assert expected_existence == check_package_exists('some_package')
```
#### File: utils/python/pypi_utils.py
```python
import logging
from distutils.version import Version
from typing import Optional, Set
from pkg_resources import parse_version
import requests
from requests.adapters import HTTPAdapter
from urllib3 import Retry
# If the "simplejson" package is installed, then "requests" uses it to handle json,
# otherwise it uses the standard "json" package.
try:
from simplejson import JSONDecodeError
except ImportError:
from json import JSONDecodeError
PYPI_PACKAGE_METADATA_URL = 'https://pypi.org/pypi/{package_name}/json'
PYPI_VERSION_METADATA_URL = 'https://pypi.org/pypi/{package_name}/{package_version}/json'
logger = logging.getLogger(__name__)
def _create_session() -> requests.Session:
session = requests.Session()
retries = Retry(total=10, backoff_factor=0.1)
session.mount('https://', HTTPAdapter(max_retries=retries))
return session
def get_available_versions(package_name: str) -> Set[Version]:
"""
By a given package, collect a list of all the versions available on PyPI.
:param package_name: PyPI package name.
:return: Set of available versions. If the version could not be obtained, None will be returned.
"""
session = _create_session()
url = PYPI_PACKAGE_METADATA_URL.format(package_name=package_name)
try:
metadata = session.get(url).json()
except requests.exceptions.RequestException:
logger.error('An error occurred when accessing the PyPI.')
return set()
except JSONDecodeError:
logger.error(f'Failed to get a version for the {package_name} package.')
return set()
if 'releases' in metadata.keys():
versions = metadata['releases'].keys()
else:
logger.error('The PyPI response does not contain the "releases" field.')
return set()
return set(map(parse_version, versions))
def get_package_classifiers(package_name: str, package_version: Optional[str] = None) -> Set[str]:
"""
Return the list of classifiers of the given package by version.
If no version is specified, the classifiers of the latest version will be returned.
:param package_name: The name of the PyPI package.
:param package_version: The version of the PyPI package.
:return: Set of classifiers. In case of failure an empty set will be returned.
"""
session = _create_session()
if package_version is None:
url = PYPI_PACKAGE_METADATA_URL.format(package_name=package_name)
else:
url = PYPI_VERSION_METADATA_URL.format(package_name=package_name, package_version=package_version)
try:
metadata = session.get(url).json()
except requests.exceptions.RequestException:
logger.error('An error occurred when accessing the PyPI.')
return set()
except JSONDecodeError:
logger.error(f'Failed to get classifiers for the {package_name} package (version = {package_name}).')
return set()
if 'info' not in metadata.keys():
logger.error('The PyPI response does not contain the "info" field.')
return set()
info = metadata['info']
if 'classifiers' not in info:
logger.error('The PyPI response does not contain the "classifiers" field.')
return set()
return set(info['classifiers'])
def check_package_exists(package_name: str) -> Optional[bool]:
"""
Check if a package exists.
:param package_name: PyPI package name.
:return: If it was not possible to find out whether the package exists or not, None will be returned.
"""
session = _create_session()
url = PYPI_PACKAGE_METADATA_URL.format(package_name=package_name)
try:
response = session.get(url)
except requests.exceptions.RequestException:
logger.error('An error occurred when accessing the PyPI.')
return None
if response.status_code == 200:
return True
if response.status_code == 404:
return False
logger.warning(f'PyPI returned an unexpected code ({response.status_code}).')
return None
```
|
{
"source": "JetBrains-Research/Matroskin",
"score": 3
}
|
#### File: Matroskin/examples/examples_utils.py
```python
import time
import os
import yaml
from loguru import logger
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
class LogFilter:
def __init__(self, level):
self.level = level
def __call__(self, record):
levelno = logger.level(self.level).no
return record["level"].no >= levelno
def log_exceptions(func):
def function_wrapper(*args, **kwargs):
try:
if args[1] % 10_000 == 0:
log_work = LogFilter("INFO")
fmt = "{time:X}\t{name}\t{level}\t{message}"
logger.add("../logs/log.log", filter=log_work, level=0, format=fmt)
logger.info(f'Processed:\t{args[1]}')
return func(*args, **kwargs)
except Exception as e:
if type(e).__name__ != 'AttributeError':
log_filter = LogFilter("WARNING")
fmt = "{time:}\t{name}\t{level}\t{message}"
logger.add("../logs/log.log", filter=log_filter, level=0, format=fmt)
logger.error(f'{args[0]}\t{type(e).__name__}\t{e}')
return 0
return function_wrapper
def timing(func):
def function_wrapper(*args, **kwargs):
start_time = time.monotonic()
func(*args, **kwargs)
print("--- {:.1f} seconds ---".format(time.monotonic() - start_time))
return function_wrapper
def get_config(filename):
with open(filename, "r") as yml_config:
cfg = yaml.safe_load(yml_config)
return cfg
def get_db_name(sql_config):
if sql_config['engine'] == 'postgresql':
db_name = f'{sql_config["engine"]}:{sql_config["pg_name"]}:{sql_config["password"]}//@{sql_config["host"]}/{sql_config["name"]}'
else: # Engine = sqlite
abs_path_to_db = os.path.join(BASE_DIR, sql_config["name"])
db_name = f'{sql_config["engine"]}:////{abs_path_to_db}'
print(f'Database name is {db_name}')
return db_name
```
#### File: matroskin/notebook/notebook.py
```python
import pandas as pd
from sqlalchemy.orm.session import sessionmaker
from itertools import combinations
from typing import Tuple, Set
import builtins
import types
from ..processors import MdProcessor
from ..processors import CodeProcessor
from ..connector import Connector
from .write_to_db import write_notebook_to_db, write_features_to_db
def flatten(dictionary):
output = dict()
for key, value in dictionary.items():
if isinstance(value, dict):
output.update(flatten(value))
else:
output[key] = value
return output
class Aggregator:
def __init__(self):
self.task_mapping = {
'general_metrics': self.get_general_notebook_metrics,
'complexity_metrics': self.get_mean_complexity_metrics,
'coupling_between_cells': self.get_coupling_between_cells,
'coupling_between_functions': self.get_coupling_between_functions,
'coupling_between_methods': self.get_mean_coupling_between_methods,
'functions_statistics': self.get_functions_statistics
}
self.cells_df = None
@staticmethod
def get_sets_coupling(pair: Tuple[Set, Set]) -> int:
a, b = pair
return len(a.intersection(b))
def get_general_notebook_metrics(self):
df = self.cells_df
notebook_metrics = {
'notebook_cells_number': df.shape[0],
'code_cells_count': sum(df.type == 'code'),
'md_cells_count': sum(df.type == 'markdown'),
'notebook_imports': " ".join(df.code_imports.replace('', float('NaN')).dropna()),
'unused_imports_total': int(df.unused_imports_count.dropna().sum()),
'sloc': int(df.sloc.sum()),
'comments_count': max(int(df.comments_count.sum()), 0),
'extended_comments_count': max(int(df.comments_count.sum()), 0),
'blank_lines_count': max(int(df.blank_lines_count.sum()), 0),
'classes': int(
df[df.classes_size > 0]. \
classes_size. \
dropna().astype(bool).sum()
),
'classes_comments': int(
df[df.classes_size > 0]. \
comments_count. \
dropna().sum()
),
'mean_attributes_count': (df.classes_size
- df.new_methods_count
- df.override_methods_count).mean(),
'mean_new_methods': df.new_methods_count.mean(),
'mean_override_methods': df.override_methods_count.mean(),
'comments_density': 0,
'comments_per_class': 0,
}
count_markdown = True
if count_markdown:
default_length = 1
notebook_metrics['extended_comments_count'] += int(
df[df.type == 'markdown']. \
source. \
apply(lambda lines: lines.count('\n') + default_length).sum()
)
notebook_metrics['comments_density'] = notebook_metrics['comments_count'] \
/ max((notebook_metrics['sloc'] + notebook_metrics['comments_count']), 1)
notebook_metrics['extended_comments_density'] = notebook_metrics['extended_comments_count'] \
/ max((notebook_metrics['sloc'] + notebook_metrics['comments_count']), 1)
notebook_metrics['comments_per_class'] = notebook_metrics['classes_comments'] \
/ max(notebook_metrics['classes'], 1)
return notebook_metrics
def get_coupling_between_cells(self):
pair_combination = 2
cells_variables = self.cells_df.variables. \
replace("", float("NaN")).dropna().apply(
lambda variables_string: set(variables_string.split(' '))
)
coupling = 0
for pair in combinations(cells_variables, pair_combination):
coupling += self.get_sets_coupling(pair)
return coupling
def get_coupling_between_functions(self):
"""
cells_df.inner_functions: Series[ List[ Set, ... , Set ] ]
"""
pair_combination = 2
inner_functions_sets = self.cells_df.inner_functions.explode().dropna()
coupling = 0
for pair in combinations(inner_functions_sets, pair_combination):
coupling += self.get_sets_coupling(pair)
return coupling
def get_mean_coupling_between_methods(self):
"""
Mean Coupling in cells which have methods in it
"""
coupling_series = self.cells_df[self.cells_df.mean_classes_coupling > 0]. \
mean_classes_coupling.dropna()
mean_coupling = coupling_series.mean() if len(coupling_series) else 0
return mean_coupling
def get_functions_statistics(self):
"""
cells_df.defined_functions: Series[ String['fun_1 fun_2 ... fun_n'] ]
cells_df.used_functions: Series[ List[ String, ... , String ] ]
cells_df.inner_functions: Series[ List[ Set, ... , Set ] ]
"""
builtin_functions = [name for name, obj in vars(builtins).items()
if isinstance(obj, types.BuiltinFunctionType)]
collection_functions_names = dir(list) + dir(dict) + dir(tuple)
build_in_functions_set = set(builtin_functions + collection_functions_names)
used_functions_series = self.cells_df.used_functions. \
explode().replace('', float('Nan')).dropna()
defined_functions_series = self.cells_df.defined_functions. \
replace("", float('Nan')).dropna().apply(lambda line: line.split(' ')).explode()
defined_functions_set = set(defined_functions_series)
imported_entities = self.cells_df.imported_entities.explode().to_numpy()
defined_functions_used = [function for function in used_functions_series
if function in defined_functions_set]
build_in_functions_used = [function for function in used_functions_series
if function in build_in_functions_set]
api_functions_used = [
function['function']
for function in self.cells_df.functions.explode().dropna()
if (function['module'] in imported_entities or
function['function'] in imported_entities)
]
api_functions_set = set(api_functions_used)
other_functions_used = [function for function in used_functions_series
if (function not in defined_functions_set
and function not in api_functions_set
and function not in build_in_functions_set)]
stats = {
'API_functions_count': len(api_functions_set),
'defined_functions_count': len(defined_functions_set),
'API_functions_uses': len(api_functions_used),
'defined_functions_uses': len(defined_functions_used),
'build_in_functions_count': len(set(build_in_functions_used)),
'build_in_functions_uses': len(build_in_functions_used),
'other_functions_uses': len(other_functions_used)
}
return stats
def get_mean_complexity_metrics(self):
cells_metrics = ['ccn', 'npavg', 'halstead']
notebook_metrics = {}
for metric in cells_metrics:
if metric == 'ccn':
notebook_metrics[metric] = int(self.cells_df[metric].max())
else:
notebook_metrics[metric] = self.cells_df[metric].mean()
return notebook_metrics
def run_tasks(self, cells, config):
self.cells_df = pd.DataFrame(cells).set_index('num').sort_index()
functions = [
function for function, executing in config.items()
if (function in self.task_mapping.keys() and executing is True)
]
features = {}
for function in functions:
features[function] = self.task_mapping[function]()
return features
class Notebook(object):
processors = [CodeProcessor, MdProcessor]
aggregator = Aggregator()
cells = []
metadata = {}
features = {}
nlp = None
def __init__(self, name, db_name=""):
connector = Connector(name, db_name)
self.engine = connector.engine
self.metadata = connector.data.metadata
self.cells = connector.data.cells
self.features = connector.data.features
def add_nlp_model(self, nlp):
self.nlp = nlp
return 1
def write_to_db(self):
session = sessionmaker(bind=self.engine)()
with session as conn:
self.metadata['id'] = write_notebook_to_db(conn, self.metadata, self.cells)
return 1
def run_tasks(self, config):
for i, cell in enumerate(self.cells):
self.cells[i] = self.processors[0](cell).process_cell(config['code']) \
if cell['type'] == 'code' \
else self.processors[1](cell, self.nlp).process_cell(config['markdown'])
return self.cells
def aggregate_tasks(self, config):
flatten_cells = [flatten(cell) for cell in self.cells]
self.features = self.aggregator.run_tasks(flatten_cells, config['notebook'])
if self.engine:
session = sessionmaker(bind=self.engine)()
with session as conn:
flatten_features = write_features_to_db(conn, self.metadata, self.features)
return self.features
```
|
{
"source": "JetBrains-Research/metrics-evaluation",
"score": 3
}
|
#### File: JetBrains-Research/metrics-evaluation/hs-rate.py
```python
import sys
import PySimpleGUI as sg
# import os.path
import json
import os
import random
import tkinter as tk
def check_experience(s):
if (s.isdigit() == False):
return False
exp = int(s)
if (exp > 30):
return False
return True
filename = './to-grade/hs.json'
try:
with open(filename[:-5] + '.tmp.json') as f:
dat = json.load(f)
except:
with open(filename) as f:
dat = json.load(f)
mylist = [(x, y) for x in range(len(dat) - 1) for y in range(3)]
random.shuffle(mylist)
names = ('gcnn', 'nl2code', 'snippet')
file_list_column = [
[
sg.Text('''Is the code snippet below relevant or not relevant description of the card on the right?
Please rate it on a scale from 0 to 4. You can either press on the radio button or press the corresponding key (\'4\' for 4 etc.)
You can also press \'Exit\' to finish grading or \'Skip\' to skip the snippet
4: Snippet is very relevant, it describes the card exactly
3: Snippet is relevant, but needs to be slightly changed to describe the card exactly
2: Snippet is somewhat relevant, it requires significant changes (compared to the size of the snippet), but is still useful to describe the card
1: Snippet is slightly relevant, it contains information relevant to the card, but it is easier to write the description from scratch
0: Snippet is not at all relevant to the card''', font=("Helvetica", 12)),
],
[sg.Radio('4', "RADIO1", enable_events=True, font=("Helvetica", 12), key='4', size=(10, 10)),
sg.Radio('3', "RADIO1", enable_events=True, font=("Helvetica", 12), key='3', size=(10, 10)),
sg.Radio('2', "RADIO1", enable_events=True, font=("Helvetica", 12), key='2', size=(10, 10)),
sg.Radio('1', "RADIO1", enable_events=True, font=("Helvetica", 12), key='1', size=(10, 10)),
sg.Radio('0', "RADIO1", enable_events=True, font=("Helvetica", 12), key='0', size=(10, 10))],
[sg.Cancel(button_text="Skip"), sg.Exit()],
[sg.Text(''), sg.Text(size=(150, 40), key='-OUTPUT-', font=("Helvetica", 12))]
]
# For now will only show the name of the file that was chosen
image_viewer_column = [
[sg.Image(key="-IMAGE-")],
]
# ----- Full layout -----
layout_form = [[sg.Text('''Dear participant,\n
this program is a survey on quality of the code snippets conducted by Independent non-profit organization of additional professional education
“Research and Education Center “JetBrains”, OGRN 1187800000134, located at St. Petersburg, Kantemirovskaya street 2, liter A, office 201.
You will be presented with code snippets (one at a time) and a problem they are supposed to solve. You are asked to evaluate whether
the suggested snippet is helpful or not helpful in solving the problem on a scale from 0 to 4, where 0 corresponds to a totally irrelevant snippet
and 4 corresponds to a snippet which solves the problem (more detailed instruction will be present at the snippet grading screen).\n
In the event of any publication or presentation resulting from the research, no personally identifiable information will be shared.
We plan to include the results of this survey in a scientific publication. If you have any concerns or questions about your rights as a participant
or about the way the study is being conducted, please contact <NAME> (<EMAIL>).''',
font=("Helvetica", 12))],
[sg.Text('''In the text box below please write, for how long have you been programming in Python (in years),
rounded to the nearest integer number. This information will be reported in the publication in an aggregated form.''',
font=("Helvetica", 12))],
[sg.Text('Python experience: ', key='_text1_',
font=("Helvetica", 12)), sg.InputText(key='_python_', size=(10, 1))],
[sg.Text('''In the text box below please write your Slack handle or e-mail address. This information will be kept private and we only ask for it
to be able to reach back to you to clarify any technical uncertainties with the graded snippets, if such uncertainties shall arise.''')],
[sg.Text('Contact information: ', key='_text2_',
font=("Helvetica", 12)), sg.InputText(key='_contact_', size=(30, 1))],
[sg.Text('''ELECTRONIC CONSENT\n
Please select your choice below. Selecting the “yes” option below indicates that:
i) you have read and understood the above information,
ii) you voluntarily agree to participate, and
iii) you are at least 18 years old.
If you do not wish to participate in the research study, please decline participation by selecting “No”.''',
font=("Helvetica", 12))],
[sg.Ok(button_text="Yes"), sg.Exit(button_text="No")],
]
layout_grade = [[
sg.Column(file_list_column),
sg.VSeperator(),
sg.Column(image_viewer_column),
]
]
#layout1 = [[sg.Text('')]]
#root = tk.Tk()
#screen_width = root.winfo_screenwidth()
#scaling_window = sg.Window('Window Title', layout1, no_titlebar=True, auto_close=False, alpha_channel=0).Finalize()
#scaling_window.TKroot.tk.call('tk', 'scaling', max(screen_width / 1920, 1))
#scaling_window.close()
pers_data = dat[-1]
no_consent = False
if ((pers_data["contact"] == "") or (pers_data["experience"] == "") or (pers_data["consent"] == "")):
window = sg.Window("Hearthstone dataset grader form", layout_form, finalize=True, location=(0, 0),
return_keyboard_events=True)
no_consent = True
while (no_consent):
event, values = window.read()
if event == "No" or event == sg.WIN_CLOSED:
window.close()
sys.exit()
elif event == "Yes":
error_text = ""
if (check_experience(values['_python_']) == False):
error_text += "Incorrect input. Please enter, for how long have you been programming in Python (in " \
"years, rounded to a nearest integer)\n"
if (len(values['_contact_']) < 1):
error_text += 'Incorrect input. Please enter your Slack handle or e-mail address.\n'
if len(error_text) > 0:
sg.popup(error_text)
else:
pers_data["contact"] = values['_contact_']
pers_data["experience"] = int(values['_python_'])
pers_data["consent"] = 'yes'
no_consent = False
for key in dat[-1]:
dat[-1][key] = pers_data[key]
window.close()
else:
pass
window = sg.Window("Hearthstone dataset grader", layout_grade, finalize=True, location=(0, 0),
return_keyboard_events=True)
if no_consent: window.close()
# Run the Event Loop
for (i, j) in mylist:
successful = False
finished = False
sname = 'grade-' + names[j]
if sname not in dat[i]:
window['-OUTPUT-'].update(dat[i][names[j]])
window["-IMAGE-"].update(filename='./hs_cards/' + str(i) + '.png')
while not successful:
event, values = window.read()
if event == "Exit" or event == sg.WIN_CLOSED:
with open(filename, 'w') as o:
json.dump(dat, o)
try:
os.remove(filename[:-5] + '.tmp.json')
except:
pass
finished = True
successful = True
elif event[0] in ['0', '1', '2', '3', '4']:
successful = True
dat[i][sname] = int(event)
with open(filename[:-5] + '.tmp.json', 'w') as o:
json.dump(dat, o)
elif event == "Skip":
successful = True
pass
else:
sg.popup(event)
if finished:
break
with open(filename, 'w') as o:
json.dump(dat, o)
try:
os.remove(filename[:-5] + '.tmp.json')
except:
pass
window.close()
```
#### File: JetBrains-Research/metrics-evaluation/rate.py
```python
import click
import json
import os
import random
import sys
from pygments import highlight
from pygments.lexers.python import PythonLexer
from pygments.formatters.terminal import TerminalFormatter
def hl(snippet):
return highlight(snippet, PythonLexer(), TerminalFormatter())
# gauge is the list of 40 intents with 40*5 = 200 snippets to be graded by all our graders. These will allow to compare the graders and yield better estimate for the other grades
names = ('baseline', 'tranx-annot', 'best-tranx', 'best-tranx-rerank', 'snippet', 'codex')
def get_exp():
while True:
exp_str = input()
try:
experience = int(exp_str)
if (0 > experience) or (experience > 30):
raise ValueError
else:
return experience
except ValueError:
print('Incorrect input. Please enter, for how long have you been programming in Python (in years, rounded to a nearest integer)')
def get_name():
while True:
name = input()
if (len(name) < 1):
print('Incorrect input. Please enter your Slack handle or e-mail address.')
else:
return name
def get_consent():
while (True):
consent = input().lower()
if (consent == 'yes'):
return
elif (consent == 'no'):
sys.exit()
else:
print('Incorrect input. Please enter "yes", if you wish to participate in the study, and "no", if you want to decline participation')
def consent():
print('''Dear participant,\n
this program is a survey on quality of the code snippets conducted by Independent non-profit organization of additional professional education
“Research and Education Center “JetBrains”, OGRN 1187800000134, located at St. Petersburg, Kantemirovskaya street 2, liter A, office 201.
You will be presented with code snippets (one at a time) and a problem they are supposed to solve. You are asked to evaluate
whether the suggested snippet is helpful or not helpful in solving the problem on a scale from 0 to 4,
where 0 corresponds to a totally irrelevant snippet and 4 corresponds to a snippet which solves the problem
(more detailed instruction will be present at the snippet grading screen).
In the event of any publication or presentation resulting from the research, no personally identifiable information will be shared.
We plan to include the results of this survey in a scientific publication. If you have any concerns or questions about your rights
as a participant or about the way the study is being conducted, please contact <NAME> (<EMAIL>).''')
print(' ')
print('''Please write, for how long have you been programming in Python (in years),
rounded to the nearest integer number. This information will be reported in the publication in an aggregated form.''')
pers_data = dict()
pers_data["experience"] = get_exp()
print('''Please write your Slack handle or e-mail address. This information will be kept private and we only ask for it to be able to reach back to you
to clarify any technical uncertainties with the graded snippets, if such uncertainties shall arise.''')
pers_data["contact"] = input()
print('ELECTRONIC CONSENT\n')
print('''Please enter your choice below. Entering the “yes” option below indicates that:\n
i) you have read and understood the above information,\n
ii) you voluntarily agree to participate, and \n
iii) you are at least 18 years old.\n
If you do not wish to participate in the research study, please decline participation by entering "no"''')
get_consent()
pers_data["consent"] = 'yes'
return pers_data
@click.command()
@click.option('--filename', default='./to-grade/all-singles.json', help='JSON dataset of code snippets to be rated')
def loadprint(filename):
try:
with open(filename[:-5]+'.tmp.json') as f:
dat = json.load(f)
except:
with open(filename) as f:
dat = json.load(f)
mylist = [(x, y) for x in range(500) for y in range(6)]
random.shuffle(mylist)
cnt = 0
pers_data = dat[-1]
if ((pers_data["contact"] == "") or (pers_data["experience"] == "") or (pers_data["consent"] == "")):
pers_data = consent()
for key in dat[-1]:
dat[-1][key] = pers_data[key]
for (i, j) in mylist:
sname = 'grade-' + names[j]
if sname in dat[i]:
cnt += 1
for (i, j) in mylist:
sname = 'grade-' + names[j]
if sname not in dat[i]:
click.clear()
click.echo('''Is the suggested code snippet helpful or not helpful in solving the problem?
Please rate it on a scale from 0 to 4. You can also enter \'f\' to finish rating or \'s\' to skip the snippet
4: Snippet is very helpful, it solves the problem
3: Snippet is helpful, but needs to be slightly changed to solve the problem
2: Snippet is somewhat helpful, it requires significant changes (compared to the size of the snippet), but is still useful
1: Snippet is slightly helpful, it contains information relevant to the problem, but it is easier to write the solution from scratch
0: Snippet is not at all helpful, it is irrelevant to the problem''')
click.echo(' ')
click.echo('The problem is:')
click.echo(dat[i]['intent'])
click.echo(' ')
click.echo('The snippet is:')
click.echo(hl(dat[i][names[j]].replace("`", "'")))
click.echo(' ')
click.echo(' ')
click.echo(' ')
click.echo('You have graded ' + str(cnt) + ' snippets so far')
while True:
c = click.getchar()
click.echo(c)
if c == 'f':
break
elif c == 's':
break
elif c in ['0', '1', '2', '3', '4']:
dat[i][sname] = int(c)
cnt += 1
with open(filename[:-5]+'.tmp.json', 'w') as o:
json.dump(dat, o)
break
else:
print("Sorry, the input was invalid")
continue
if c == 'f':
break
click.echo('Thank you for grading!')
with open(filename, 'w') as o:
json.dump(dat, o)
try:
os.remove(filename[:-5]+'.tmp.json')
except:
pass
if __name__ == '__main__':
loadprint()
```
#### File: metrics-evaluation/ruby/nx_graphs.py
```python
import ast
from typing import Union, Optional, Dict, Tuple
import networkx as nx
from func_timeout import FunctionTimedOut, func_timeout
from networkx.algorithms.similarity import optimize_graph_edit_distance
from ruby.util import get_ast_node_label, get_ast_children
def convert_ast_to_graph(root: Union[str, ast.AST,]) -> nx.DiGraph:
g = nx.DiGraph()
nodes = []
edges = []
num_nodes = 0
def add_node() -> int:
nonlocal num_nodes
new_node = num_nodes
num_nodes += 1
return new_node
def traverse(cur_node: Union[str, ast.AST], parent: Optional[int] = None):
label = get_ast_node_label(cur_node)
node_index = add_node()
nodes.append((node_index, {'label': label}))
if parent is not None:
edges.append((parent, node_index, {'label': 'AST'}))
for child in get_ast_children(cur_node):
traverse(child, node_index)
traverse(root)
g.add_nodes_from(nodes)
g.add_edges_from(edges)
return g
def convert_dict_to_graph(dict_g: Dict) -> nx.DiGraph:
g = nx.DiGraph()
nodes = [
(i, {'label': node})
for i, node in enumerate(dict_g['nodes'])
]
edges = [
(int(v), int(u), {'label': edge_type})
for edge_type in dict_g['edges']
for v, us in dict_g['edges'][edge_type].items()
for u in us
]
g.add_nodes_from(nodes)
g.add_edges_from(edges)
return g
def compute_ged(sample_graph: nx.DiGraph, reference_graph: nx.DiGraph, use_edge_cost: bool = False) \
-> Tuple[float, float]:
ged_generator = optimize_graph_edit_distance(
sample_graph, reference_graph,
node_match=lambda v, u: v['label'] == u['label'], edge_match=lambda e1, e2: e1['label'] == e2['label'],
edge_ins_cost=lambda e: 1 if use_edge_cost else 0, edge_del_cost=lambda e: 1 if use_edge_cost else 0
)
total_size = sample_graph.number_of_nodes() + reference_graph.number_of_nodes()
if use_edge_cost:
total_size += sample_graph.number_of_edges() + reference_graph.number_of_edges()
ged = total_size
while True:
try:
new_ged = func_timeout(0.1, next, args=(ged_generator,))
ged = new_ged
except (FunctionTimedOut, StopIteration):
break
return ged, total_size
```
#### File: metrics-evaluation/ruby/util.py
```python
import tokenize
import ast
import re
from io import BytesIO
from typing import List, Optional, Union, Any, Dict
from codebleu.graph_generator.graphgenerator import AstGraphGenerator
from codebleu.graph_generator.type_lattice_generator import TypeLatticeGenerator
def tokenize_builtin(code: str) -> List[str]:
try:
tokens = list(tokenize.tokenize(BytesIO(code.encode('utf-8')).readline))[1:-1]
tokens = [token.string for token in tokens]
return tokens
except tokenize.TokenError:
return tokenize_tranx(code)
def tokenize_tranx(code: str) -> List[str]:
""" The tokenizer taken from https://github.com/pcyin/tranX
Originally from <NAME> et al.,
Latent Predictor Networks for Code Generation (2016)
@param code: string containing a code snippet
@return: list of code tokens
"""
code = re.sub(r'([^A-Za-z0-9_])', r' \1 ', code)
code = re.sub(r'([a-z])([A-Z])', r'\1 \2', code)
code = re.sub(r'\s+', ' ', code)
code = code.replace('"', '`')
code = code.replace('\'', '`')
tokens = [t for t in code.split(' ') if t]
return tokens
def create_ast(code: str) -> Optional[ast.AST]:
try:
return ast.parse(code)
except SyntaxError:
return None
def create_graph(code: str) -> Optional[Dict]:
try:
lattice = TypeLatticeGenerator('codebleu/typingRules.json')
generator = AstGraphGenerator(code, lattice)
graph = generator.build()
return graph
except SyntaxError:
return None
def get_ast_children(node: Union[Any, ast.AST]) -> List[Union[Any, ast.AST]]:
if not isinstance(node, ast.AST):
return []
def wrap(node_field: Union[list, Union[Any, ast.AST]]) -> List[Union[Any, ast.AST]]:
if isinstance(node_field, list):
return node_field
return [node_field]
children = [
child
for field in node._fields
for child in wrap(getattr(node, field))
]
return children
def get_ast_node_label(node: Union[Any, ast.AST]) -> str:
if not isinstance(node, ast.AST):
return str(node)
return str(type(node))
def ast_labels_distance(label1: str, label2: str) -> float:
if label1 == label2:
return 0.
return 1.
def get_ast_size(node: Union[str, ast.AST]) -> int:
if isinstance(node, int):
return 1
return sum(1 for _ in ast.walk(node))
```
#### File: JetBrains-Research/metrics-evaluation/simple-rate.py
```python
import click
import json
import os
import random
from pygments import highlight
from pygments.lexers.python import PythonLexer
from pygments.formatters.terminal import TerminalFormatter
def hl(snippet):
return highlight(snippet, PythonLexer(), TerminalFormatter())
@click.command()
@click.option('--filename', default='./to-grade/simple-test.json', help='JSON dataset of code snippets to be rated')
def loadprint(filename):
try:
with open(filename[:-5] + '.tmp.json') as f:
dat = json.load(f)
except:
with open(filename) as f:
dat = json.load(f)
mylist = [i for i in range(20)]
random.shuffle(mylist)
cnt = 0
sname = 'grade-code'
for i in mylist:
if sname in dat[i]:
cnt += 1
for i in mylist:
if sname not in dat[i]:
click.clear()
click.echo('''Is the suggested code snippet helpful or not helpful in solving the problem?
Please rate it on a scale from 0 to 4. You can also enter \'f\' to finish rating or \'s\' to skip the snippet
4: Snippet is very helpful, it solves the problem
3: Snippet is helpful, but needs to be slightly changed to solve the problem
2: Snippet is somewhat helpful, it requires significant changes (compared to the size of the snippet), but is still useful
1: Snippet is slightly helpful, it contains information relevant to the problem, but it is easier to write the solution from scratch
0: Snippet is not at all helpful, it is irrelevant to the problem''')
click.echo(' ')
click.echo('The problem is:')
click.echo(dat[i]['intent'])
click.echo(' ')
click.echo('The snippet is:')
click.echo(hl(dat[i]['code'].replace("`", "'")))
click.echo(' ')
click.echo(' ')
click.echo(' ')
click.echo('You have graded ' + str(cnt) + ' snippets so far')
while True:
c = click.getchar()
click.echo(c)
if c == 'f':
break
elif c == 's':
break
elif c in ['0', '1', '2', '3', '4']:
dat[i][sname] = int(c)
cnt += 1
with open(filename[:-5] + '.tmp.json', 'w') as o:
json.dump(dat, o)
break
else:
print("Sorry, the input was invalid")
continue
if c == 'f':
break
click.echo('Thank you for grading!')
with open(filename, 'w') as o:
json.dump(dat, o)
try:
os.remove(filename[:-5] + '.tmp.json')
except:
pass
if __name__ == '__main__':
loadprint()
```
|
{
"source": "JetBrains-Research/pubtrends-nature-reviews",
"score": 2
}
|
#### File: pubtrends-nature-reviews/src/bulk_export.py
```python
import gzip
import json
import logging
import os
from pysrc.papers.analysis.expand import expand_ids
from pysrc.papers.analyzer import PapersAnalyzer
from pysrc.papers.config import PubtrendsConfig
from pysrc.papers.db.loaders import Loaders
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s')
FILE_DIR = os.path.abspath(os.path.dirname(__file__))
TARGET_FOLDER = os.path.normpath(os.path.join(FILE_DIR, '../pubtrends-export/'))
TARGET_PMIDS = [26667849, 26678314, 26688349, 26688350, 26580716, 26580717, 26656254, 26675821, 27834397, 27834398,
27890914, 27916977, 27677859, 27677860, 27904142, 28003656, 29147025, 29170536, 28853444, 28920587,
28792006, 28852220, 29213134, 29321682, 30578414, 30842595, 30644449, 30679807, 30108335, 30390028,
30459365, 30467385, 31686003, 31806885, 31836872, 32005979, 31937935, 32020081, 32042144, 32699292]
SOURCE = 'Pubmed'
LIMIT = 1000
def export_analysis(pmid):
logging.info(f'Started analysis for PMID {pmid}')
ids = [pmid]
query = f'Paper ID: {pmid}'
# extracted from 'analyze_id_list' Celery task
config = PubtrendsConfig(test=False)
loader = Loaders.get_loader(SOURCE, config)
analyzer = PapersAnalyzer(loader, config)
try:
ids = expand_ids(loader=loader, ids=ids, single_paper=True, limit=LIMIT, max_expand=PapersAnalyzer.EXPAND_LIMIT,
citations_q_low=PapersAnalyzer.EXPAND_CITATIONS_Q_LOW,
citations_q_high=PapersAnalyzer.EXPAND_CITATIONS_Q_HIGH,
citations_sigma=PapersAnalyzer.EXPAND_CITATIONS_SIGMA,
similarity_threshold=PapersAnalyzer.EXPAND_SIMILARITY_THRESHOLD,
single_paper_impact=PapersAnalyzer.SINGLE_PAPER_IMPACT)
analyzer.analyze_papers(ids, query, task=None)
finally:
loader.close_connection()
dump = analyzer.dump()
# export as JSON
path = os.path.join(TARGET_FOLDER, f'{pmid}.json.gz')
with gzip.open(path, 'w') as f:
f.write(json.dumps(dump).encode('utf-8'))
logging.info(f'Finished analysis for PMID {pmid}\n')
def main():
for pmid in TARGET_PMIDS:
export_analysis(pmid)
if __name__ == "__main__":
main()
```
#### File: src/utils/preprocessing.py
```python
SPECIAL_SECTIONS = ['INTRODUCTION', 'CONCLUSION', 'PERSPECTIVES']
UNIQUENESS_METHODS = ['first_occurrence', 'unique_only']
def is_box_section(title):
"""
Box sections have specific titles: "Box N | Title goes here".
This function determines whether title belongs to a box section.
"""
if '|' not in title:
return False
return 'Box' in title.split('|')[0]
def flatten_clustering_impl(clustering, max_level, current_level):
"""
Recursive traversal of multi-level dict-like clustering.
Clusters on level larger than `max_level` are merged.
"""
current_level_elements = []
clusters = []
num_clusters = 0
for el in clustering:
if isinstance(el, dict):
inner_clusters, num_inner_clusters = flatten_clustering_impl(el['references'],
max_level, current_level + 1)
if max_level <= current_level:
current_level_elements.extend(inner_clusters)
else:
if num_inner_clusters == 1:
clusters.append(inner_clusters)
else:
clusters.extend(inner_clusters)
num_clusters += num_inner_clusters
else:
current_level_elements.append(el)
if max_level <= current_level or not clusters:
return current_level_elements, 1
else:
if current_level_elements:
clusters.insert(0, current_level_elements)
num_clusters += 1
if num_clusters == 1:
return clusters[0], num_clusters
else:
return clusters, num_clusters
def flatten_clustering(clustering, max_level,
include_special_sections,
include_box_sections):
"""
Builds a flat version of multi-level clustering sliced at `max_level`.
max_level is 1-based.
"""
flat_clustering = []
for section in clustering:
is_special_section = section['title'] in SPECIAL_SECTIONS
if not include_special_sections and is_special_section:
continue
if not include_box_sections and is_box_section(section['title']):
continue
clusters, num_clusters = flatten_clustering_impl(section['references'], max_level, 1)
if num_clusters == 1:
flat_clustering.append(clusters)
else:
flat_clustering.extend(clusters)
return flat_clustering
def unique_ids_clustering(clustering, method):
"""
Ensures that each paper is assigned only to one cluster by one of the methods:
* 'first_occurence' - paper is assigned to the first cluster
* 'unique_only' - only papers belonging to one cluster are taken into account
"""
id_cluster = {}
for i, cluster in enumerate(clustering):
for pmid in cluster:
if pmid not in id_cluster:
id_cluster[pmid] = []
id_cluster[pmid].append(i)
if method == 'first_occurrence':
return {str(k): v[0] for k, v in id_cluster.items()}
elif method == 'unique_only':
return {str(k): v[0] for k, v in id_cluster.items() if len(set(v)) == 1}
def preprocess_clustering(clustering, max_level,
include_special_sections=False,
include_box_sections=True,
uniqueness_method=None):
"""
Convert raw multi-level clustering to a flat clustering with unique ids.
max_level is 1-based.
"""
flat_clustering = flatten_clustering(clustering, max_level,
include_special_sections,
include_box_sections)
if uniqueness_method:
if uniqueness_method not in UNIQUENESS_METHODS:
raise ValueError('Unrecognized uniqueness method')
return unique_ids_clustering(flat_clustering, uniqueness_method)
return flat_clustering
def get_clustering_level(clustering):
"""
Returns the numbers of levels in the clustering.
Intended to be used as an upper bound for 1-based `max_level` in clustering preprocessing.
"""
levels = []
for el in clustering:
if isinstance(el, dict):
levels.append(get_clustering_level(el['references']))
if not levels:
return 1
else:
return max(levels) + 1
```
|
{
"source": "JetBrains-Research/pubtrends",
"score": 2
}
|
#### File: app/admin/admin.py
```python
from multiprocessing import Lock
from flask import abort, url_for, request, redirect
from flask_admin import helpers as admin_helpers, expose, BaseView, Admin
from flask_security import Security, SQLAlchemyUserDatastore, \
UserMixin, RoleMixin, current_user
from flask_security.utils import hash_password
from flask_sqlalchemy import SQLAlchemy
import os
from pysrc.app.admin.celery import prepare_celery_data
from pysrc.app.admin.feedback import prepare_feedback_data
from pysrc.app.admin.stats import prepare_stats_data
from pysrc.papers.config import PubtrendsConfig
from pysrc.version import VERSION
PUBTRENDS_CONFIG = PubtrendsConfig(test=False)
DB_LOCK = Lock()
# Admin service database path
SERVICE_DATABASE_PATHS = ['/database', os.path.expanduser('~/.pubtrends/database')]
for p in SERVICE_DATABASE_PATHS:
if os.path.isdir(p):
SERVICE_DATABASE_PATH = p
break
else:
raise RuntimeError('Failed to configure service db path')
def configure_admin_functions(app, celery_app, logfile):
"""Configures flask-admin and flask-sqlalchemy"""
app.config.from_pyfile('config.py')
service_database_path = os.path.join(SERVICE_DATABASE_PATH, app.config['DATABASE_FILE'])
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + service_database_path
db = SQLAlchemy(app)
# Define models
roles_users = db.Table(
'roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id'))
)
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __str__(self):
return self.name
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __str__(self):
return self.email
# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)
# Build a sample db on the fly, if one does not exist yet.
try:
DB_LOCK.acquire()
if not os.path.exists(service_database_path):
db.drop_all()
db.create_all()
with app.app_context():
user_role = Role(name='user')
admin_role = Role(name='admin')
db.session.add(user_role)
db.session.add(admin_role)
db.session.commit()
user_datastore.create_user(
first_name='Admin',
email='admin',
password=hash_password(PUBTRENDS_CONFIG.admin_password),
roles=[user_role, admin_role]
)
db.session.commit()
finally:
DB_LOCK.release()
# UI
class AdminStatsView(BaseView):
@expose('/')
def index(self):
stats_data = prepare_stats_data(logfile)
return self.render('admin/stats.html', version=VERSION, **stats_data)
def is_accessible(self):
return current_user.is_active and current_user.is_authenticated and current_user.has_role('admin')
def _handle_view(self, name, **kwargs):
"""
Override builtin _handle_view in order to redirect users when a view is not accessible.
"""
if not self.is_accessible():
if current_user.is_authenticated:
# permission denied
abort(403)
else:
# login
return redirect(url_for('security.login', next=request.url))
class AdminFeedbackView(BaseView):
@expose('/')
def index(self):
feedback_data = prepare_feedback_data(logfile)
return self.render('admin/feedback.html', version=VERSION, **feedback_data)
def is_accessible(self):
return current_user.is_active and current_user.is_authenticated and current_user.has_role('admin')
def _handle_view(self, name, **kwargs):
"""
Override builtin _handle_view in order to redirect users when a view is not accessible.
"""
if not self.is_accessible():
if current_user.is_authenticated:
# permission denied
abort(403)
else:
# login
return redirect(url_for('security.login', next=request.url))
class AdminCeleryView(BaseView):
@expose('/')
def index(self):
celery_data = prepare_celery_data(celery_app)
return self.render('admin/celery.html', version=VERSION, **celery_data)
def is_accessible(self):
return current_user.is_active and current_user.is_authenticated and current_user.has_role('admin')
def _handle_view(self, name, **kwargs):
"""
Override builtin _handle_view in order to redirect users when a view is not accessible.
"""
if not self.is_accessible():
if current_user.is_authenticated:
# permission denied
abort(403)
else:
# login
return redirect(url_for('security.login', next=request.url))
# Create admin
admin = Admin(
app,
'Pubtrends',
base_template='master.html',
template_mode='bootstrap3',
)
# Available views
admin.add_view(AdminStatsView(name='Statistics', endpoint='stats'))
admin.add_view(AdminFeedbackView(name='Feedback', endpoint='feedback'))
admin.add_view(AdminCeleryView(name='Celery', endpoint='celery'))
# define a context processor for merging flask-admin's template context into the flask-security views.
@security.context_processor
def security_context_processor():
return dict(
admin_base_template=admin.base_template,
admin_view=admin.index_view,
h=admin_helpers,
get_url=url_for
)
```
#### File: papers/analysis/node2vec.py
```python
import logging
import numpy as np
from gensim.models import Word2Vec
logger = logging.getLogger(__name__)
def node2vec(ids, graph, p=0.5, q=2.0, walk_length=32, walks_per_node=5, vector_size=64, key='weight', seed=42):
"""
:param ids: Ids or nodes for embedding
:param graph: Undirected weighted networkx graph
:param p: Defines probability, 1/p, of returning to source node
:param q: Defines probability, 1/q, for moving away from source node
:param walk_length: Walk length for each node. Walk stops preliminary if no neighbors found
:param walks_per_node: Number of walk actions performed starting from each node
:param vector_size: Resulting embedding size
:param key: key for weight
:param seed: seed
:returns matrix of embeddings
"""
logger.debug('Precomputing random walk probabilities')
probabilities_first_step, probabilities_next_step = _precompute(graph, key, p, q)
logger.debug('Performing random walks')
walks = _random_walks(
graph, probabilities_first_step, probabilities_next_step,
walks_per_node, walk_length,
seed=seed
)
logger.debug('Performing word2vec embeddings')
logging.getLogger('node2vec.py').setLevel('ERROR') # Disable logging
w2v = Word2Vec(
walks, vector_size=vector_size, window=5, min_count=0, sg=1, workers=1, epochs=1, seed=seed
)
logger.debug('Retrieve word embeddings, corresponding subjects and reorder according to ids')
node_ids, node_embeddings = w2v.wv.index_to_key, w2v.wv.vectors
indx = {pid: i for i, pid in enumerate(node_ids)}
return np.array([
node_embeddings[indx[pid]] if pid in indx else np.zeros(node_embeddings.shape[1]) # Process missing
for pid in ids
])
def _precompute(graph, key='weight', p=0.5, q=2.0):
"""
:param graph: Undirected weighted networkx graph
:param key: weight key for edge
:param p: Defines probability, 1/p, of returning to source node
:param q: Defines probability, 1/q, for moving away from source node
:return: probabilities on first step, and probabilities on steps 2+
"""
probabilities_first_step = dict() # No returning back option
probabilities_next_step = {node: dict() for node in graph.nodes()}
for i, node in enumerate(graph.nodes()):
if i % 1000 == 1:
logger.debug(f'Analyzed probabilities for {i} nodes')
first_step_weights = [graph[node][neighbor].get(key, 1) for neighbor in (graph.neighbors(node))]
probabilities_first_step[node] = _normalize(first_step_weights)
for neighbor in graph.neighbors(node):
walk_weights = [_next_step_weight(graph, key, node, neighbor, neighbor2, p, q)
for neighbor2 in graph.neighbors(neighbor)]
probabilities_next_step[neighbor][node] = _normalize(walk_weights)
return probabilities_first_step, probabilities_next_step
def _next_step_weight(graph, key, node, neighbor, neighbor2, p, q):
if neighbor2 == node: # Backwards probability
return graph[neighbor][neighbor2].get(key, 1) * 1 / p
elif neighbor2 in graph[node]: # If the neighbor is connected to the node
return graph[neighbor][neighbor2].get(key, 1)
else:
return graph[neighbor][neighbor2].get(key, 1) * 1 / q
def _normalize(values):
""" Normalize values, so that sum = 1 """
values = np.asarray(values).astype('float64')
return values / values.sum()
def _random_walks(
graph,
probabilities_first_step,
probabilities_next_step,
walks_per_node,
walk_length,
seed=None
):
""" Perform random walks with given probabilities """
np.random.seed(seed)
walks = []
for i in range(walks_per_node):
logger.debug(f'Generating walk {i+1}')
# Start a random walk from every node
for node in graph.nodes():
# Perform walk
walk = [node]
while len(walk) < walk_length:
neighbors = list(graph.neighbors(walk[-1]))
# Dead end nodes
if len(neighbors) == 0:
break
if len(walk) == 1:
step_probabilities = probabilities_first_step[walk[-1]]
else:
step_probabilities = probabilities_next_step[walk[-1]][walk[-2]]
if len(neighbors) != len(step_probabilities):
raise Exception(f'Illegal probabilities for node {node}, '
f'neighbors size {len(neighbors)}, '
f'probabilities {len(step_probabilities)}')
walk.append(np.random.choice(neighbors, size=1, p=step_probabilities)[0])
walks.append(walk)
return walks
```
#### File: papers/analysis/numbers.py
```python
import logging
import re
import math
import pandas as pd
import spacy
from nltk.stem import WordNetLemmatizer
from spacy import displacy
from text_to_num import alpha2digit
NUMBER = re.compile(r'-?[\d]+([\.,][\d]+)?([eE][+-]?\d+)?')
ENTITY = re.compile(r'[a-zA-Z_]+[a-zA-Z0-9_\-]*')
URL = re.compile(r"((http|https)\:\/\/)?[a-zA-Z0-9\.\/\?\:@\-_=#]+\.([a-zA-Z]){2,6}([a-zA-Z0-9\.\&\/\?\:@\-_=#])*")
spacy_en = spacy.load('en_core_web_sm')
lemmatizer = WordNetLemmatizer()
def extract_numbers(df):
"""
Extracts number from the titles of papers
:param df: Papers dataframe
:return: Dataframe [id, title, numbers]
"""
metrics_data = []
for _, data in df.iterrows():
paper_metrics_data = [data['id'], *extract_metrics(data['abstract'])]
metrics_data.append(paper_metrics_data)
metrics_df = pd.DataFrame(metrics_data, columns=['ID', 'Metrics', 'Sentences'])
result = pd.merge(left=metrics_df, left_on='ID', right=df[['id', 'title']], right_on='id')
result = result[['id', 'title', 'Metrics']]
result['numbers'] = [
'; '.join(
f'{number}:{",".join(str(v) for v in sorted(set(v[0] for v in values)))}'
for number, values in row['Metrics'].items()
) for _, row in result.iterrows()
]
result = result.loc[result['numbers'] != '']
return result[['id', 'title', 'numbers']]
def process_candidate(metrics, token, value, idx):
tt = token.text
if ENTITY.fullmatch(tt) and token.pos_ in {'NOUN', 'PROPN'}:
if re.match(r'[A-Z\-0-9_]+s', tt): # plural of abbreviation
tt = tt[:-1]
tt = lemmatizer.lemmatize(tt.lower())
if tt not in metrics:
metrics[tt] = []
metrics[tt].append((value, idx))
return True
return False
def process_number(token, value, idx, metrics):
# logging.debug(f'Number: {value}')
if token.head.pos_ == 'NUM':
tht = token.head.text
if re.match(r'hundred(s?)', tht, flags=re.IGNORECASE):
value *= 100
elif re.match(r'thousand(s?)', tht, flags=re.IGNORECASE):
value *= 1000
elif re.match(r'million(s?)', tht, flags=re.IGNORECASE):
value *= 1000000
elif re.match(r'billion(s?)', tht, flags=re.IGNORECASE):
value *= 1000000000
# logging.debug(f'Value adjusted: {value}')
token = next(token.ancestors, token)
# Analyze children and siblings, then ancestors if first was not enough
# TODO: is there a better way?
# TODO: use close nouns as a fallback when it is hard to find a dependency?
# TODO: expand nouns with adjectives or other nouns? (rate -> information transfer rate)
# logging.debug(f'Token children: {",".join(t.text for t in token.children)}')
for t in token.children:
if t != token and process_candidate(metrics, t, value, idx):
# logging.debug(f'Child term: {t.text}')
return
# logging.debug('Head with children: '
# f'{token.head.text} | {",".join(t.text for t in token.head.children)}')
if token != token.head:
if process_candidate(metrics, token.head, value, idx):
# logging.debug(f'Head term: {token.head.text}')
return
for t in token.head.children:
if t != token and process_candidate(metrics, t, value, idx):
# logging.debug(f'Child of head term: {t.text}')
return
# logging.debug(f'Token anscestors: {",".join(t.text for t in token.ancestors)}')
for i, t in enumerate(token.ancestors):
if i == 3: # Don't go too high
return
if t != token and process_candidate(metrics, t, value, idx):
# logging.debug(f'Ancestor: {t.text}')
return
def extract_metrics(text, visualize_dependencies=False):
"""
Parses abstract and returns a dict of numbers with nouns that could be suitable as a metric.
:return list of tuples (sentence, [metrics]), where metrics is a list of tuples (number, [nouns], sentence_number)
"""
metrics = {}
sentences = {}
# Replace all emails / urls to avoid irrelevant numbers
text = re.sub(URL, "", text)
# Insert whitespaces between non-ascii and punctuation symbols, help spacy to split tokens correctly.
text = re.sub(r"([^0-9a-z\-\n])", r" \g<1> ", text, flags=re.IGNORECASE)
# Whitespaces normalization
text = re.sub(r'[ ]{2,}', ' ', text.strip())
# Convert textual numbers to digits (three -> 3)
text = alpha2digit(text, 'en', relaxed=True)
# Convect 10th -> 10
text = re.sub(r"([\d]+)th", r"\g<1>", text, flags=re.IGNORECASE)
# Split text into sentences and find numbers in sentences
doc = spacy_en(text)
for idx, sent in enumerate(doc.sents):
# # logging.debug('###')
# # logging.debug(sent.text)
sentences[idx] = sent.text
for token in sent:
# print(token.text, token.pos_, list(token.ancestors))
if NUMBER.fullmatch(token.text):
tt = token.text.replace(',', '') # TODO: can fail in case of different locale
try:
value = float(tt)
if math.ceil(value) == value:
value = int(value)
process_number(token, value, idx, metrics)
except Exception as e:
logging.error(f'/Failed to process number {tt}', e)
if visualize_dependencies:
displacy.render(sent, style="dep", jupyter=True)
return metrics, sentences
```
#### File: pysrc/papers/analyzer.py
```python
import logging
import numpy as np
import pandas as pd
from networkx.readwrite import json_graph
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScaler
from pysrc.papers.analysis.citations import find_top_cited_papers, find_max_gain_papers, \
find_max_relative_gain_papers, build_cit_stats_df, merge_citation_stats, build_cocit_grouped_df
from pysrc.papers.analysis.evolution import topic_evolution_analysis, topic_evolution_descriptions
from pysrc.papers.analysis.graph import build_papers_graph, \
to_weighted_graph, sparse_graph
from pysrc.papers.analysis.metadata import popular_authors, popular_journals
from pysrc.papers.analysis.node2vec import node2vec
from pysrc.papers.analysis.numbers import extract_numbers
from pysrc.papers.analysis.text import texts_embeddings, vectorize_corpus, tokens_embeddings
from pysrc.papers.analysis.topics import get_topics_description, cluster_and_sort
from pysrc.papers.db.loaders import Loaders
from pysrc.papers.db.search_error import SearchError
from pysrc.papers.progress import Progress
from pysrc.papers.utils import SORT_MOST_CITED
logger = logging.getLogger(__name__)
class PapersAnalyzer:
TOP_CITED_PAPERS = 50
# Features are originally taken from paper:
# 1) Which type of citation analysis generates the most accurate taxonomy of
# scientific and technical knowledge? (https://arxiv.org/pdf/1511.05078.pdf)
# ...bibliographic coupling (BC) was the most accurate, followed by co-citation (CC).
# Direct citation (DC) was a distant third among the three...
#
# Coefficients were estimated in the paper: https://dl.acm.org/doi/10.1145/3459930.3469501
# Poster: https://drive.google.com/file/d/1SeqJtJtaHSO6YihG2905boOEYL1NiSP1/view
# See for details: https://github.com/JetBrains-Research/pubtrends-nature-reviews
SIMILARITY_BIBLIOGRAPHIC_COUPLING = 3 # Limited by number of references, applied to log
SIMILARITY_COCITATION = 3 # Limiter by number of co-citations, applied to log
SIMILARITY_CITATION = 1 # Limited by 1 citation
# Minimal number of common references, used to reduces papers graph edges count
# Value > 1 is especially useful while analysing single paper, removes meaningless connections by construction
SIMILARITY_BIBLIOGRAPHIC_COUPLING_MIN = 1
# Minimal number of common references, used to reduces papers graph edges count
SIMILARITY_COCITATION_MIN = 1
# Papers embeddings is a concatenation of graph and text embeddings times corresponding factors
# Graph embeddings produce more clear topics separation, so it goes with bigger coefficient
GRAPH_EMBEDDINGS_FACTOR = 5
TEXT_EMBEDDINGS_FACTOR = 1
# Reduce number of edges in papers graph
PAPERS_GRAPH_EDGES_TO_NODES = 5
# Global vectorization max vocabulary size
VECTOR_WORDS = 10000
# Terms with lower frequency will be ignored, remove rare words
VECTOR_MIN_DF = 0.001
# Terms with higher frequency will be ignored, remove abundant words
VECTOR_MAX_DF = 0.8
PCA_COMPONENTS = 30
# Configure number and size of topics
TOPICS_NUMBER_SMALL = dict(max_number=10, min_size=50)
TOPICS_NUMBER_MEDIUM = dict(max_number=20, min_size=20)
TOPICS_NUMBER_LARGE = dict(max_number=50, min_size=10)
@staticmethod
def get_topics_info(topics):
if topics.lower() == 'small':
info = PapersAnalyzer.TOPICS_NUMBER_SMALL
elif topics.lower() == 'medium':
info = PapersAnalyzer.TOPICS_NUMBER_MEDIUM
elif topics.lower() == 'large':
info = PapersAnalyzer.TOPICS_NUMBER_LARGE
else:
raise Exception(f'Unknown topics size: {topics}')
return info['max_number'], info['min_size']
# Number of top cited papers in topic picked for description computation
TOPIC_MOST_CITED_PAPERS = 50
# Number of words for topic description
TOPIC_DESCRIPTION_WORDS = 10
POPULAR_JOURNALS = 50
POPULAR_AUTHORS = 50
# Expand limit by references before filtration by citations and keywords
EXPAND_LIMIT = 5000
# Control citations count
EXPAND_CITATIONS_Q_LOW = 5
EXPAND_CITATIONS_Q_HIGH = 95
EXPAND_CITATIONS_SIGMA = 3
# Take up to fraction of top similarity
EXPAND_SIMILARITY_THRESHOLD = 0.5
# Impact of single paper when analyzing citations and mesh terms when analysing paper
SINGLE_PAPER_IMPACT = 20
EVOLUTION_MIN_PAPERS = 100
EVOLUTION_STEP = 10
def __init__(self, loader, config, test=False):
self.config = config
self.progress = Progress(self.total_steps())
self.loader = loader
self.source = Loaders.source(self.loader, test)
def total_steps(self):
return 14 + 1 # One extra step for visualization
def teardown(self):
self.progress.remove_handler()
def search_terms(self, query, limit=None, sort=None, noreviews=True, task=None):
# Search articles relevant to the terms
if len(query) == 0:
raise SearchError('Empty search string, please use search terms or '
'all the query wrapped in "" for phrasal search')
limit = limit or self.config.max_number_of_articles
sort = sort or SORT_MOST_CITED
noreviews_msg = ", not reviews" if noreviews else ""
self.progress.info(f'Searching {limit} {sort.lower()} publications matching {query}{noreviews_msg}',
current=1, task=task)
ids = self.loader.search(query, limit=limit, sort=sort, noreviews=noreviews)
if len(ids) == 0:
raise SearchError(f"Nothing found for search query: {query}")
else:
self.progress.info(f'Found {len(ids)} publications in the database', current=1, task=task)
return ids
def analyze_papers(self, ids, query, topics='medium', test=False, task=None):
self.progress.info('Loading publication data', current=2, task=task)
self.query = query
self.df = self.loader.load_publications(ids)
if len(self.df) == 0:
raise SearchError(f'Nothing found for ids: {ids}')
else:
self.progress.info(f'Found {len(self.df)} papers in database', current=2, task=task)
ids = list(self.df['id']) # Limit ids to existing papers only!
self.pub_types = list(set(self.df['type']))
self.progress.info('Analyzing title and abstract texts', current=3, task=task)
self.corpus, self.corpus_tokens, self.corpus_counts = vectorize_corpus(
self.df,
max_features=PapersAnalyzer.VECTOR_WORDS,
min_df=PapersAnalyzer.VECTOR_MIN_DF,
max_df=PapersAnalyzer.VECTOR_MAX_DF,
test=test
)
if PapersAnalyzer.TEXT_EMBEDDINGS_FACTOR != 0:
logger.debug('Analyzing tokens embeddings')
self.corpus_tokens_embedding = tokens_embeddings(
self.corpus, self.corpus_tokens, test=test
)
logger.debug('Analyzing texts embeddings')
self.texts_embeddings = texts_embeddings(
self.corpus_counts, self.corpus_tokens_embedding
)
else:
self.texts_embeddings = np.zeros(shape=(len(self.df), 0))
self.progress.info('Loading citations for papers', current=4, task=task)
logger.debug('Loading citations by year statistics')
cits_by_year_df = self.loader.load_citations_by_year(ids)
logger.debug(f'Found {len(cits_by_year_df)} records of citations by year')
self.cit_stats_df = build_cit_stats_df(cits_by_year_df, len(ids))
if len(self.cit_stats_df) == 0:
logger.warning('No citations of papers were found')
self.df, self.citation_years = merge_citation_stats(self.df, self.cit_stats_df)
logger.debug('Loading citations information')
self.cit_df = self.loader.load_citations(ids)
logger.debug(f'Found {len(self.cit_df)} citations between papers')
self.progress.info('Calculating co-citations for selected papers', current=5, task=task)
self.cocit_df = self.loader.load_cocitations(ids)
cocit_grouped_df = build_cocit_grouped_df(self.cocit_df)
logger.debug(f'Found {len(cocit_grouped_df)} co-cited pairs of papers')
self.cocit_grouped_df = cocit_grouped_df[cocit_grouped_df['total'] >= self.SIMILARITY_COCITATION_MIN].copy()
logger.debug(f'Filtered {len(self.cocit_grouped_df)} co-cited pairs of papers, '
f'threshold {self.SIMILARITY_COCITATION_MIN}')
self.progress.info('Processing bibliographic coupling for selected papers', current=6, task=task)
bibliographic_coupling_df = self.loader.load_bibliographic_coupling(ids)
logger.debug(f'Found {len(bibliographic_coupling_df)} bibliographic coupling pairs of papers')
self.bibliographic_coupling_df = bibliographic_coupling_df[
bibliographic_coupling_df['total'] >= self.SIMILARITY_BIBLIOGRAPHIC_COUPLING_MIN].copy()
logger.debug(f'Filtered {len(self.bibliographic_coupling_df)} bibliographic coupling pairs of papers '
f'threshold {self.SIMILARITY_BIBLIOGRAPHIC_COUPLING_MIN}')
self.progress.info('Analyzing papers graph', current=7, task=task)
self.papers_graph = build_papers_graph(
self.df, self.cit_df, self.cocit_grouped_df, self.bibliographic_coupling_df,
)
self.progress.info(f'Built papers graph - {self.papers_graph.number_of_nodes()} nodes and '
f'{self.papers_graph.number_of_edges()} edges', current=7, task=task)
logger.debug('Analyzing papers graph embeddings')
self.weighted_similarity_graph = to_weighted_graph(self.papers_graph, PapersAnalyzer.similarity)
logger.debug('Prepare sparse graph for visualization')
self.sparse_papers_graph = self.prepare_sparse_papers_graph(self.papers_graph, self.weighted_similarity_graph)
if PapersAnalyzer.GRAPH_EMBEDDINGS_FACTOR != 0:
gs = sparse_graph(self.weighted_similarity_graph)
self.graph_embeddings = node2vec(self.df['id'], gs)
else:
self.graph_embeddings = np.zeros(shape=(len(self.df), 0))
logger.debug('Computing aggregated graph and text embeddings for papers')
papers_embeddings = np.concatenate(
(self.graph_embeddings * PapersAnalyzer.GRAPH_EMBEDDINGS_FACTOR,
self.texts_embeddings * PapersAnalyzer.TEXT_EMBEDDINGS_FACTOR), axis=1)
if len(self.df) > 1:
logger.debug('Computing PCA projection')
pca = PCA(n_components=min(len(papers_embeddings), PapersAnalyzer.PCA_COMPONENTS))
t = StandardScaler().fit_transform(papers_embeddings)
self.pca_coords = pca.fit_transform(t)
logger.debug(f'Explained variation {int(np.sum(pca.explained_variance_ratio_) * 100)}%')
logger.debug('Apply TSNE transformation on papers PCA coords')
tsne_embeddings_2d = TSNE(n_components=2, random_state=42).fit_transform(self.pca_coords)
self.df['x'] = tsne_embeddings_2d[:, 0]
self.df['y'] = tsne_embeddings_2d[:, 1]
else:
self.pca_coords = np.zeros(shape=(len(self.df), 128))
self.df['x'] = 0
self.df['y'] = 0
self.progress.info(f'Extracting {topics.lower()} number of topics from papers text and graph similarity',
current=8, task=task)
topics_max_number, topic_min_size = PapersAnalyzer.get_topics_info(topics)
if self.papers_graph.number_of_nodes() <= topic_min_size:
logger.debug('Small graph - single topic')
self.clusters, self.dendrogram = [0] * len(self.df), None
self.df['comp'] = self.clusters
else:
logger.debug('Extracting topics from papers embeddings')
self.clusters, self.dendrogram = cluster_and_sort(self.pca_coords, topics_max_number, topic_min_size)
self.df['comp'] = self.clusters
self.progress.info(f'Analyzing {len(set(self.df["comp"]))} topics descriptions',
current=9, task=task)
comp_pids = self.df[['id', 'comp']].groupby('comp')['id'].apply(list).to_dict()
self.topics_description = get_topics_description(
self.df, comp_pids,
self.corpus, self.corpus_tokens, self.corpus_counts,
n_words=self.TOPIC_DESCRIPTION_WORDS
)
kwds = [(comp, ','.join([f'{t}:{v:.3f}' for t, v in vs[:self.TOPIC_DESCRIPTION_WORDS]]))
for comp, vs in self.topics_description.items()]
self.kwd_df = pd.DataFrame(kwds, columns=['comp', 'kwd'])
self.progress.info('Identifying top cited papers', current=10, task=task)
logger.debug('Top cited papers')
self.top_cited_papers, self.top_cited_df = find_top_cited_papers(self.df, self.TOP_CITED_PAPERS)
logger.debug('Top cited papers per year')
self.max_gain_papers, self.max_gain_df = find_max_gain_papers(self.df, self.citation_years)
logger.debug('Hot paper per year')
self.max_rel_gain_papers, self.max_rel_gain_df = find_max_relative_gain_papers(
self.df, self.citation_years
)
# Additional analysis steps
if self.config.feature_authors_enabled:
self.progress.info("Analyzing authors and groups", current=11, task=task)
self.author_stats = popular_authors(self.df, n=self.POPULAR_AUTHORS)
if self.config.feature_journals_enabled:
self.progress.info("Analyzing popular journals", current=12, task=task)
self.journal_stats = popular_journals(self.df, n=self.POPULAR_JOURNALS)
if self.config.feature_numbers_enabled:
if len(self.df) >= 0:
self.progress.info('Extracting quantitative features from abstracts texts', current=13, task=task)
self.numbers_df = extract_numbers(self.df)
else:
logger.debug('Not enough papers for numbers extraction')
if self.config.feature_evolution_enabled:
if len(self.df) >= PapersAnalyzer.EVOLUTION_MIN_PAPERS:
self.progress.info(f'Analyzing evolution of topics {self.df["year"].min()} - {self.df["year"].max()}',
current=14, task=task)
logger.debug('Perform topic evolution analysis and get topic descriptions')
self.evolution_df, self.evolution_year_range = topic_evolution_analysis(
self.df,
self.cit_df,
self.cocit_grouped_df,
self.bibliographic_coupling_df,
self.SIMILARITY_COCITATION_MIN,
self.similarity,
self.corpus_counts,
self.corpus_tokens_embedding,
PapersAnalyzer.GRAPH_EMBEDDINGS_FACTOR,
PapersAnalyzer.TEXT_EMBEDDINGS_FACTOR,
topics_max_number,
topic_min_size,
self.EVOLUTION_STEP
)
self.evolution_kwds = topic_evolution_descriptions(
self.df, self.evolution_df, self.evolution_year_range,
self.corpus, self.corpus_tokens, self.corpus_counts, self.TOPIC_DESCRIPTION_WORDS,
self.progress, current=14, task=task
)
else:
logger.debug('Not enough papers for topics evolution')
self.evolution_df = None
self.evolution_kwds = None
@staticmethod
def prepare_sparse_papers_graph(papers_graph, weighted_similarity_graph):
sparse_papers_graph = sparse_graph(weighted_similarity_graph, PapersAnalyzer.PAPERS_GRAPH_EDGES_TO_NODES)
for i, j in sparse_papers_graph.edges():
d = papers_graph.get_edge_data(i, j)
for k, v in d.items():
sparse_papers_graph[i][j][k] = v
sparse_papers_graph[i][j]['similarity'] = PapersAnalyzer.similarity(d)
return sparse_papers_graph
@staticmethod
def similarity(d):
return \
PapersAnalyzer.SIMILARITY_BIBLIOGRAPHIC_COUPLING * np.log1p(d.get('bibcoupling', 0)) + \
PapersAnalyzer.SIMILARITY_COCITATION * np.log1p(d.get('cocitation', 0)) + \
PapersAnalyzer.SIMILARITY_CITATION * d.get('citation', 0)
def dump(self):
"""
Dump valuable fields to JSON-serializable dict. Use 'load' to restore analyzer.
"""
return dict(
df=self.df.to_json(),
cit_df=self.cit_df.to_json(),
cocit_grouped_df=self.cocit_grouped_df.to_json(),
bibliographic_coupling_df=self.bibliographic_coupling_df.to_json(),
topics_description=self.topics_description,
kwd_df=self.kwd_df.to_json(),
pca_coords=self.pca_coords.tolist(),
sparse_papers_graph=json_graph.node_link_data(self.sparse_papers_graph),
top_cited_papers=self.top_cited_papers,
max_gain_papers=self.max_gain_papers,
max_rel_gain_papers=self.max_rel_gain_papers
)
@staticmethod
def load(fields):
"""
Load valuable fields from JSON-serializable dict. Use 'dump' to dump analyzer.
"""
# Restore main dataframe
df = pd.read_json(fields['df'])
df['id'] = df['id'].apply(str)
mapping = {}
for col in df.columns:
try:
mapping[col] = int(col)
except ValueError:
mapping[col] = col
df = df.rename(columns=mapping)
cit_df = pd.read_json(fields['cit_df'])
cit_df['id_in'] = cit_df['id_in'].astype(str)
cit_df['id_out'] = cit_df['id_out'].astype(str)
cocit_grouped_df = pd.read_json(fields['cocit_grouped_df'])
cocit_grouped_df['cited_1'] = cocit_grouped_df['cited_1'].astype(str)
cocit_grouped_df['cited_2'] = cocit_grouped_df['cited_2'].astype(str)
bibliographic_coupling_df = pd.read_json(fields['bibliographic_coupling_df'])
bibliographic_coupling_df['citing_1'] = bibliographic_coupling_df['citing_1'].astype(str)
bibliographic_coupling_df['citing_2'] = bibliographic_coupling_df['citing_2'].astype(str)
# Restore topic descriptions
topics_description = {int(c): ks for c, ks in fields["topics_description"].items()} # Restore int components
kwd_df = pd.read_json(fields['kwd_df'])
# Extra filter is applied to overcome split behaviour problem: split('') = [''] problem
kwd_df['kwd'] = [kwd.split(',') if kwd != '' else [] for kwd in kwd_df['kwd']]
kwd_df['kwd'] = kwd_df['kwd'].apply(lambda x: [el.split(':') for el in x])
kwd_df['kwd'] = kwd_df['kwd'].apply(lambda x: [(el[0], float(el[1])) for el in x])
# Restore original coordinates
pca_coords = np.array(fields['pca_coords'])
# Restore citation and structure graphs
sparse_papers_graph = json_graph.node_link_graph(fields['sparse_papers_graph'])
top_cited_papers = fields['top_cited_papers']
max_gain_papers = fields['max_gain_papers']
max_rel_gain_papers = fields['max_rel_gain_papers']
return dict(
df=df,
cit_df=cit_df,
cocit_grouped_df=cocit_grouped_df,
bibliographic_coupling_df=bibliographic_coupling_df,
topics_description=topics_description,
kwd_df=kwd_df,
pca_coords=pca_coords,
sparse_papers_graph=sparse_papers_graph,
top_cited_papers=top_cited_papers,
max_gain_papers=max_gain_papers,
max_rel_gain_papers=max_rel_gain_papers
)
def init(self, fields):
"""
Init analyzer with required fields.
NOTE: results page doesn't use dump/load for visualization.
Look for init calls in the codebase to find out useful fields for serialization.
:param fields: deserialized JSON
"""
logger.debug('Loading analyzer')
loaded = PapersAnalyzer.load(fields)
self.df = loaded['df']
self.cit_df = loaded['cit_df']
self.cocit_grouped_df = loaded['cocit_grouped_df']
self.bibliographic_coupling_df = loaded['bibliographic_coupling_df']
# Used for components naming
self.topics_description = loaded['topics_description']
self.kwd_df = loaded['kwd_df']
# Used for similar papers
self.pca_coords = loaded['pca_coords']
# Used for network visualization
self.sparse_papers_graph = loaded['sparse_papers_graph']
# Used for navigation
self.top_cited_papers = loaded['top_cited_papers']
self.max_gain_papers = loaded['max_gain_papers']
self.max_rel_gain_papers = loaded['max_rel_gain_papers']
```
#### File: papers/db/article.py
```python
from dataclasses import dataclass, field
from typing import List
@dataclass
class Author:
name: str = ''
affiliation: List[str] = field(default_factory=lambda: [])
def to_dict(self):
return {'name': self.name, 'affiliation': self.affiliation}
@dataclass
class Journal:
name: str = ''
def to_dict(self):
return {'name': self.name}
@dataclass
class AuxInfo:
authors: List[Author] = field(default_factory=lambda: [])
journal: Journal = field(default=Journal())
def to_dict(self):
return {'authors': [author.to_dict() for author in self.authors],
'journal': self.journal.to_dict()}
@dataclass
class Article:
pmid: int or None
title: str
abstract: str or None = None
doi: str = None
keywords: List[str] = field(default_factory=lambda: [])
aux: AuxInfo = AuxInfo()
def authors(self) -> str:
return ', '.join([author.name for author in self.aux.authors])
def journal(self) -> str:
return self.aux.journal.name
```
#### File: papers/db/loader.py
```python
import html
import json
import numpy as np
from abc import abstractmethod, ABCMeta
from pysrc.papers.utils import extract_authors
class Loader(metaclass=ABCMeta):
@abstractmethod
def find(self, key, value):
"""
Searches single or multiple paper(s) for give search key, value.
:return: list of ids, i.e. list(String).
"""
@abstractmethod
def search(self, query, limit=None, sort=None, noreviews=True):
"""
Searches publications by given query, ignoring reviews
:return: list of ids, i.e. list(String).
"""
@abstractmethod
def load_publications(self, ids):
"""
Loads publications for given ids.
:return: dataframe[id(String), title, abstract, year, type, keywords, mesh, doi, aux]
"""
@abstractmethod
def load_citations_by_year(self, ids):
"""
Loads all the citations stats for each of given ids.
:return: dataframe[id(String), year, count]
"""
@abstractmethod
def load_references(self, pid, limit):
"""
Returns paper references, limited by number.
:return: list[String]
"""
@abstractmethod
def load_citations_counts(self, ids):
"""
Returns total citations counts for each paper id.
:return: list[Int]
"""
@abstractmethod
def load_citations(self, ids):
"""
Loading citations graph, between ids.
:return: dataframe[id_out(String), id_in(String)]
"""
@abstractmethod
def load_cocitations(self, ids):
"""
Loading co-citations graph.
:return: dataframe[citing(String), cited_1(String), cited_2(String), year]
"""
@abstractmethod
def load_bibliographic_coupling(self, ids):
"""
Loading bibliographic coupling graph.
:return: dataframe[citing_1(String), citing_2(String), total]
"""
@abstractmethod
def expand(self, ids, limit):
"""
Expands list of ids after one or BFS step along citations graph.
:return: dataframe[id(String), total]
"""
@staticmethod
def process_publications_dataframe(ids, pub_df):
# Switch to string ids
pub_df['id'] = pub_df['id'].apply(str)
# Semantic Scholar stores aux in jsonb format, no json parsing required
pub_df['aux'] = pub_df['aux'].apply(
lambda aux: json.loads(aux) if type(aux) is str else aux
)
pub_df = pub_df.fillna(value={'abstract': ''})
pub_df['year'] = pub_df['year'].apply(int)
pub_df['authors'] = pub_df['aux'].apply(lambda aux: extract_authors(aux['authors']))
pub_df['journal'] = pub_df['aux'].apply(lambda aux: aux['journal']['name'])
pub_df['title'] = pub_df['title'].apply(lambda title: title)
# Semantic Scholar specific hack
if 'crc32id' in pub_df:
pub_df['crc32id'] = pub_df['crc32id'].apply(int)
# Reorder dataframe
ids_order = {str(pid): index for index, pid in enumerate(ids)}
sort_ord = np.argsort([ids_order[pid] for pid in pub_df['id']])
return pub_df.iloc[sort_ord, :].reset_index(drop=True)
```
#### File: papers/db/loaders.py
```python
from pysrc.papers.db.pm_postgres_loader import PubmedPostgresLoader
from pysrc.papers.db.postgres_connector import PostgresConnector
from pysrc.papers.db.ss_postgres_loader import SemanticScholarPostgresLoader
from pysrc.papers.utils import PUBMED_ARTICLE_BASE_URL, SEMANTIC_SCHOLAR_BASE_URL
from pysrc.prediction.ss_arxiv_loader import SSArxivLoader
from pysrc.prediction.ss_pubmed_loader import SSPubmedLoader
class Loaders:
@staticmethod
def source(loader, test=False):
# Determine source to provide correct URLs to articles,
# see #get_loader_and_url_prefix
# TODO: Bad design, refactor
if isinstance(loader, PubmedPostgresLoader):
return 'Pubmed'
elif isinstance(loader, SemanticScholarPostgresLoader):
return 'Semantic Scholar'
elif isinstance(loader, SSArxivLoader):
return 'SSArxiv'
elif isinstance(loader, SSPubmedLoader):
return 'SSPubmed'
elif not test:
raise TypeError(f'Unknown loader {loader}')
@staticmethod
def get_loader_and_url_prefix(source, config):
if PostgresConnector.postgres_configured(config):
if source == 'Pubmed':
return PubmedPostgresLoader(config), PUBMED_ARTICLE_BASE_URL
elif source == 'Semantic Scholar':
return SemanticScholarPostgresLoader(config), SEMANTIC_SCHOLAR_BASE_URL
else:
raise ValueError(f"Unknown source {source}")
else:
raise ValueError("No database configured")
@staticmethod
def get_loader(source, config):
return Loaders.get_loader_and_url_prefix(source, config)[0]
```
#### File: papers/plot/plot_evolution.py
```python
import logging
import holoviews as hv
from holoviews import dim
from pysrc.papers.plot.plot_preprocessor import PlotPreprocessor
logger = logging.getLogger(__name__)
def plot_topics_evolution(df, evolution_df, evolution_kwds, plot_width, plot_height):
"""
Sankey diagram of topic evolution
:return:
if evolution_df is None: None, as no evolution can be observed in 1 step
Sankey diagram + table with keywords
"""
logger.debug('Processing topic_evolution')
# Topic evolution analysis failed, one step is not enough to analyze evolution
if evolution_df is None or not evolution_kwds:
logger.debug(f'Topic evolution failure, '
f'evolution_df is None: {evolution_df is None}, '
f'evolution_kwds is None: {evolution_kwds is None}')
return None
n_steps = len(evolution_df.columns) - 2
edges, nodes_data = PlotPreprocessor.topic_evolution_data(
evolution_df, evolution_kwds, n_steps
)
value_dim = hv.Dimension('Papers', unit=None)
nodes_ds = hv.Dataset(nodes_data, 'index', 'label')
topic_evolution = hv.Sankey((edges, nodes_ds), ['From', 'To'], vdims=value_dim)
topic_evolution.opts(labels='label',
width=plot_width, height=max(plot_height, len(set(df['comp'])) * 30),
show_values=False, cmap='tab20',
edge_color=dim('To').str(), node_color=dim('index').str())
p = hv.render(topic_evolution, backend='bokeh')
p.sizing_mode = 'stretch_width'
kwds_data = PlotPreprocessor.topic_evolution_keywords_data(
evolution_kwds
)
return p, kwds_data
```
#### File: pysrc/papers/progress.py
```python
import logging
from io import StringIO
class Progress:
"""
IMPORTANT! Progress initialization is required to change job state into PROGRESS,
so that it's execution will be shown in '/process' app handler.
"""
def __init__(self, total):
self.stream = StringIO()
self.handler = logging.StreamHandler(self.stream)
self.handler.setFormatter(logging.Formatter('[%(asctime)s] %(message)s', "%Y-%m-%d %H:%M:%S"))
self.logger = logging.getLogger(__name__)
self.logger.addHandler(self.handler)
self.total = total
def info(self, message, current, task=None):
if message:
self.logger.info(message)
if task:
self.handler.flush()
task.update_state(state='PROGRESS',
meta={'current': current, 'total': self.total, 'log': self.stream.getvalue()})
def done(self, message='Done', task=None):
self.info(message, self.total, task)
def remove_handler(self):
self.logger.removeHandler(self.handler)
def log(self):
return self.stream.getvalue()
```
#### File: review/app/app.py
```python
import json
import logging
import re
from celery.result import AsyncResult
from flask import request, redirect, url_for, render_template_string, render_template
from pysrc.app.predefined import load_predefined_or_result_data
from pysrc.app.messages import SOMETHING_WENT_WRONG_SEARCH, ERROR_OCCURRED
from pysrc.celery.pubtrends_celery import pubtrends_celery
from pysrc.papers.config import PubtrendsConfig
from pysrc.papers.utils import trim
from pysrc.version import VERSION
from pysrc.review.app.task import prepare_review_data_async
logger = logging.getLogger(__name__)
PUBTRENDS_CONFIG = PubtrendsConfig(test=False)
REVIEW_ANALYSIS_TYPE = 'review'
MAX_QUERY_LENGTH = 60
def log_request(r):
return f'addr:{r.remote_addr} args:{json.dumps(r.args)}'
def register_app_review(app, predefined_jobs):
@app.route('/generate_review')
def generate_review():
logger.info(f'/generate_review {log_request(request)}')
try:
jobid = request.args.get('jobid')
query = request.args.get('query')
source = request.args.get('source')
limit = request.args.get('limit')
sort = request.args.get('sort')
num_papers = request.args.get('papers_number')
num_sents = request.args.get('sents_number')
if jobid:
data = load_predefined_or_result_data(source, jobid, predefined_jobs, pubtrends_celery)
if data is not None:
job = prepare_review_data_async.delay(data, source, num_papers, num_sents)
return redirect(url_for('.process', analysis_type=REVIEW_ANALYSIS_TYPE, jobid=job.id,
query=query, source=source, limit=limit, sort=sort))
logger.error(f'/generate_review error {log_request(request)}')
return render_template_string(SOMETHING_WENT_WRONG_SEARCH), 400
except Exception as e:
logger.error(f'/generate_review error', e)
return render_template_string(ERROR_OCCURRED), 500
@app.route('/review')
def review():
logger.info(f'/review {log_request(request)}')
try:
jobid = request.args.get('jobid')
query = request.args.get('query')
source = request.args.get('source')
limit = request.args.get('limit')
sort = request.args.get('sort')
if jobid:
job = AsyncResult(jobid, app=pubtrends_celery)
if job and job.state == 'SUCCESS':
review_res = job.result
export_name = re.sub('_{2,}', '_', re.sub('["\':,. ]', '_', f'{query}_review'.lower().strip('_')))
return render_template('review.html',
query=trim(query, MAX_QUERY_LENGTH),
source=source,
limit=limit,
sort=sort,
version=VERSION,
review_array=review_res,
export_name=export_name)
else:
logger.error(f'/review error {log_request(request)}')
return render_template_string(SOMETHING_WENT_WRONG_SEARCH), 400
except Exception as e:
logger.error(f'/review error', e)
return render_template_string(ERROR_OCCURRED), 500
```
#### File: test/analysis/test_citations.py
```python
import unittest
from parameterized import parameterized
from pysrc.papers.analysis.citations import find_top_cited_papers
from pysrc.papers.analyzer import PapersAnalyzer
from pysrc.papers.config import PubtrendsConfig
from pysrc.test.mock_loaders import MockLoader, \
EXPECTED_MAX_GAIN, EXPECTED_MAX_RELATIVE_GAIN, MockLoaderSingle
class TestPopularPapers(unittest.TestCase):
PUBTRENDS_CONFIG = PubtrendsConfig(test=True)
@classmethod
def setUpClass(cls):
loader = MockLoader()
cls.analyzer = PapersAnalyzer(loader, TestPopularPapers.PUBTRENDS_CONFIG, test=True)
ids = cls.analyzer.search_terms(query='query')
cls.analyzer.analyze_papers(ids, 'query', test=True)
cls.analyzer.cit_df = cls.analyzer.loader.load_citations(cls.analyzer.df['id'])
cls.analyzer.bibliographic_coupling_df = loader.load_bibliographic_coupling(cls.analyzer.df['id'])
def test_find_max_gain_papers_count(self):
max_gain_count = len(list(self.analyzer.max_gain_df['year'].values))
self.assertEqual(max_gain_count, len(EXPECTED_MAX_GAIN.keys()))
def test_find_max_gain_papers_years(self):
max_gain_years = list(self.analyzer.max_gain_df['year'].values)
self.assertCountEqual(max_gain_years, EXPECTED_MAX_GAIN.keys())
def test_find_max_gain_papers_ids(self):
max_gain = dict(self.analyzer.max_gain_df[['year', 'id']].values)
self.assertDictEqual(max_gain, EXPECTED_MAX_GAIN)
def test_find_max_relative_gain_papers_count(self):
max_rel_gain_count = len(list(self.analyzer.max_rel_gain_df['year'].values))
self.assertEqual(max_rel_gain_count, len(EXPECTED_MAX_RELATIVE_GAIN.keys()))
def test_find_max_relative_gain_papers_years(self):
max_rel_gain_years = list(self.analyzer.max_rel_gain_df['year'].values)
self.assertCountEqual(max_rel_gain_years, EXPECTED_MAX_RELATIVE_GAIN.keys())
def test_find_max_relative_gain_papers_ids(self):
max_rel_gain = dict(self.analyzer.max_rel_gain_df[['year', 'id']].values)
self.assertDictEqual(max_rel_gain, EXPECTED_MAX_RELATIVE_GAIN)
@parameterized.expand([
('threshold 5', 5, ['3', '1', '4', '2', '5']),
('threshold 10', 10, ['3', '1', '4', '2', '5']),
('limit-2', 2, ['3', '1']),
('limit-4', 4, ['3', '1', '4', '2'])
])
def test_find_top_cited_papers(self, name, max_papers, expected):
_, top_cited_df = find_top_cited_papers(self.analyzer.df, n_papers=max_papers)
top_cited_papers = list(top_cited_df['id'].values)
self.assertListEqual(top_cited_papers, expected, name)
class TestPopularPapersSingle(unittest.TestCase):
PUBTRENDS_CONFIG = PubtrendsConfig(test=True)
@classmethod
def setUpClass(cls):
cls.analyzer = PapersAnalyzer(MockLoaderSingle(), TestPopularPapersSingle.PUBTRENDS_CONFIG, test=True)
ids = cls.analyzer.search_terms(query='query')
cls.analyzer.analyze_papers(ids, 'query', test=True)
cls.analyzer.cit_df = cls.analyzer.loader.load_citations(cls.analyzer.df['id'])
def test_find_max_gain_papers_count(self):
max_gain_count = len(list(self.analyzer.max_gain_df['year'].values))
self.assertEqual(max_gain_count, len(EXPECTED_MAX_GAIN.keys()))
def test_find_max_gain_papers_years(self):
max_gain_years = list(self.analyzer.max_gain_df['year'].values)
self.assertCountEqual(max_gain_years, EXPECTED_MAX_GAIN.keys())
def test_find_max_gain_papers_ids(self):
max_gain = dict(self.analyzer.max_gain_df[['year', 'id']].values)
self.assertDictEqual(max_gain, {1972: '1', 1974: '1'})
def test_find_max_relative_gain_papers_count(self):
max_rel_gain_count = len(list(self.analyzer.max_rel_gain_df['year'].values))
self.assertEqual(max_rel_gain_count, len(EXPECTED_MAX_RELATIVE_GAIN.keys()))
def test_find_max_relative_gain_papers_years(self):
max_rel_gain_years = list(self.analyzer.max_rel_gain_df['year'].values)
self.assertCountEqual(max_rel_gain_years, EXPECTED_MAX_RELATIVE_GAIN.keys())
def test_find_max_relative_gain_papers_ids(self):
max_rel_gain = dict(self.analyzer.max_rel_gain_df[['year', 'id']].values)
self.assertDictEqual(max_rel_gain, {1972: '1', 1974: '1'})
if __name__ == '__main__':
unittest.main()
```
#### File: test/analysis/test_graph.py
```python
import unittest
import networkx as nx
from pysrc.papers.analysis.graph import _local_sparse
from pysrc.papers.analyzer import PapersAnalyzer
from pysrc.papers.config import PubtrendsConfig
from pysrc.test.mock_loaders import MockLoader, PAPERS_GRAPH_EDGES, MockLoaderSingle
class TestBuildGraph(unittest.TestCase):
PUBTRENDS_CONFIG = PubtrendsConfig(test=True)
@classmethod
def setUpClass(cls):
loader = MockLoader()
cls.analyzer = PapersAnalyzer(loader, TestBuildGraph.PUBTRENDS_CONFIG, test=True)
ids = cls.analyzer.search_terms(query='query')
cls.analyzer.analyze_papers(ids, 'query', test=True)
def test_build_papers_graph(self):
edges = list(self.analyzer.papers_graph.edges(data=True))
# print(edges)
self.assertEquals(len(PAPERS_GRAPH_EDGES), len(edges), msg='size')
for expected, actual in zip(PAPERS_GRAPH_EDGES, edges):
self.assertEquals(expected[0], actual[0], msg='source')
self.assertEquals(expected[1], actual[1], msg='target')
for m in 'cocitation', 'citations', 'bibcoupling':
self.assertEquals(m in expected[2], m in actual[2], msg=f'{m} presence')
if m in expected[2]:
self.assertAlmostEqual(expected[2][m], actual[2][m], msg=f'{m} value', delta=1e-3)
def test_local_sparse(self):
# Full graph on 4 nodes
graph = nx.DiGraph()
for i in range(5):
for j in range(i + 1, 5):
graph.add_edge(i, j, similarity=1)
self.assertEqual([(0, 1), (0, 2), (1, 2), (1, 3), (2, 3), (2, 4), (3, 4)],
list(_local_sparse(graph, 0.1, key='similarity').edges))
self.assertEqual([(0, 1), (0, 2), (1, 2), (1, 3), (2, 3), (2, 4), (3, 4)],
list(_local_sparse(graph, 0.5, key='similarity').edges))
self.assertEqual([(0, 1), (0, 2), (0, 3), (0, 4),
(1, 2), (1, 3), (1, 4),
(2, 3), (2, 4),
(3, 4)],
list(_local_sparse(graph, 1, key='similarity').edges))
# Add not connected edge
graph.add_edge(10, 11, similarity=10)
self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (10, 11)],
list(_local_sparse(graph, 0, key='similarity').edges))
def test_isolated_edges_sparse(self):
# Full graph on 4 nodes
graph = nx.DiGraph()
graph.add_node(1)
graph.add_node(2)
graph.add_node(3)
self.assertEqual([1, 2, 3], list(_local_sparse(graph, 0, key='similarity').nodes))
class TestBuildGraphSingle(unittest.TestCase):
PUBTRENDS_CONFIG = PubtrendsConfig(test=True)
@classmethod
def setUpClass(cls):
cls.analyzer = PapersAnalyzer(MockLoaderSingle(), TestBuildGraphSingle.PUBTRENDS_CONFIG, test=True)
ids = cls.analyzer.search_terms(query='query')
cls.analyzer.analyze_papers(ids, 'query', test=True)
cls.analyzer.cit_df = cls.analyzer.loader.load_citations(cls.analyzer.df['id'])
if __name__ == "__main__":
unittest.main()
```
#### File: test/db/test_pm_postgres_delete.py
```python
import unittest
from pysrc.papers.config import PubtrendsConfig
from pysrc.papers.db.pm_postgres_loader import PubmedPostgresLoader
from pysrc.papers.db.pm_postgres_writer import PubmedPostgresWriter
from pysrc.papers.utils import SORT_MOST_CITED
from pysrc.test.db.pm_test_articles import REQUIRED_ARTICLES, ARTICLES, CITATIONS
class TestPubmedPostgresDelete(unittest.TestCase):
test_config = PubtrendsConfig(test=True)
loader = PubmedPostgresLoader(config=test_config)
writer = PubmedPostgresWriter(config=test_config)
@classmethod
def setUpClass(cls):
cls.loader = TestPubmedPostgresDelete.loader
# Text search is not tested, imitating search results
cls.ids = list(map(lambda article: article.pmid, REQUIRED_ARTICLES))
# Reset and load data to the test database
writer = TestPubmedPostgresDelete.writer
writer.init_pubmed_database()
writer.insert_pubmed_publications(ARTICLES)
writer.insert_pubmed_citations(CITATIONS)
# Get data via loader methods
cls.pub_df = cls.loader.load_publications(cls.ids)
@classmethod
def tearDownClass(cls):
cls.loader.close_connection()
def test_delete(self):
self.writer.delete(['2'])
self.assertListEqual(['3'],
sorted(self.loader.search('Abstract', limit=5, sort=SORT_MOST_CITED)),
'Wrong IDs of papers')
self.writer.delete(['3'])
self.assertListEqual([],
sorted(self.loader.search('Abstract', limit=5, sort=SORT_MOST_CITED)),
'Wrong IDs of papers')
if __name__ == "__main__":
unittest.main()
```
#### File: pysrc/test/mock_loaders.py
```python
import pandas as pd
from pysrc.papers.db.loader import Loader
PUBLICATION_DATA = [
['1', 1963, 'Article 1', 'just a paper', 'Article', '<NAME>, <NAME>, <NAME>', 'Nature',
'term1,term2,term3', 'kw1,kw2'],
['2', 1965, 'Article 2', 'abstract', 'Article', '<NAME>, <NAME>, <NAME>', 'Science',
'term2,term3,term4', 'kw2,kw3'],
['3', 1967, 'Article 3', 'other abstract', 'Article', '<NAME>, <NAME>', 'Nature',
'term3,term4,term5', 'kw3,kw4'],
['4', 1968, 'Article 4', 'interesting paper', 'Article', '<NAME>, <NAME>', 'Science',
'term4,term5,term1', 'kw4,kw5'],
['5', 1975, 'Article 5', 'just a breakthrough', 'Review', '<NAME>, <NAME>, <NAME>', 'Nature',
'term5,term1,term2', 'kw5,kw1']
]
CITATION_STATS_DATA = [['1', 1972, 2], ['1', 1974, 15],
['2', 1974, 1],
['3', 1972, 5], ['3', 1974, 13],
['4', 1972, 1], ['4', 1974, 8]]
CITATION_DATA = [['4', '1'], ['3', '1'], ['4', '2'], ['3', '2'],
['5', '1'], ['5', '2'], ['5', '3'], ['5', '4']]
COCITATION_DATA = [['3', '1', '2', 1967],
['4', '1', '2', 1968],
['5', '1', '2', 1975],
['5', '3', '4', 1975]]
COCITATION_GROUPED_DATA = [['1', '2', 1, 1, 1, 3],
['3', '4', 0, 0, 1, 1]]
COCITATION_YEARS = [1967, 1968, 1969]
COCITATION_DF = pd.DataFrame([['1', '2', 3], ['3', '4', 1]], columns=['cited_1', 'cited_2', 'total'])
COCITATION_GRAPH_EDGES = [('1', '2', 3), ('3', '4', 1)]
BIBLIOGRAPHIC_COUPLING_DATA = [['3', '4', 2],
['3', '5', 2],
['4', '5', 2]]
BIBCOUPLING_DF = pd.DataFrame(BIBLIOGRAPHIC_COUPLING_DATA, columns=['citing_1', 'citing_2', 'total'])
PAPERS_GRAPH_EDGES = [('1', '2', {'cocitation': 3}), ('1', '4', {'citation': 1}), ('1', '3', {'citation': 1}),
('1', '5', {'citation': 1}), ('2', '4', {'citation': 1}), ('2', '3', {'citation': 1}),
('2', '5', {'citation': 1}), ('3', '4', {'cocitation': 1, 'bibcoupling': 2}),
('3', '5', {'bibcoupling': 2, 'citation': 1}), ('4', '5', {'bibcoupling': 2, 'citation': 1})]
EXPECTED_MAX_GAIN = {1972: '3', 1974: '1'}
EXPECTED_MAX_RELATIVE_GAIN = {1972: '3', 1974: '4'}
class MockLoader(Loader):
def find(self, key, value):
raise Exception('Not implemented')
def expand(self, ids, limit):
raise Exception('Not implemented')
def search(self, terms, limit=None, sort=None, noreviews=True):
return ['1', '2', '3', '4', '5']
def load_publications(self, ids=None):
return pd.DataFrame(
PUBLICATION_DATA,
columns=['id', 'year', 'title', 'abstract', 'type', 'authors', 'journal', 'mesh', 'keywords']
)
def load_citations_by_year(self, ids=None):
return pd.DataFrame(CITATION_STATS_DATA, columns=['id', 'year', 'count'])
def load_references(self, pid, limit):
raise Exception('Not implemented')
def load_citations_counts(self, ids):
raise Exception('Not implemented')
def load_citations(self, ids=None):
return pd.DataFrame(CITATION_DATA, columns=['id_out', 'id_in'])
def load_cocitations(self, ids=None):
return pd.DataFrame(COCITATION_DATA, columns=['citing', 'cited_1', 'cited_2', 'year'])
def load_bibliographic_coupling(self, ids=None):
return pd.DataFrame(BIBLIOGRAPHIC_COUPLING_DATA, columns=['citing_1', 'citing_2', 'total'])
class MockLoaderSingle(Loader):
def find(self, key, value):
raise Exception('Not implemented')
def expand(self, ids, limit):
raise Exception('Not implemented')
def search(self, terms, limit=None, sort=None, noreviews=True):
return ['1']
def load_publications(self, ids=None):
return pd.DataFrame(
PUBLICATION_DATA[0:1],
columns=['id', 'year', 'title', 'abstract', 'type', 'authors', 'journal', 'mesh', 'keywords']
)
def load_citations_by_year(self, ids=None):
return pd.DataFrame([['1', 1972, 2], ['1', 1974, 15]],
columns=['id', 'year', 'count'])
def load_references(self, pid, limit):
raise Exception('Not implemented')
def load_citations_counts(self, ids):
raise Exception('Not implemented')
def load_citations(self, ids=None):
return pd.DataFrame(columns=['id_out', 'id_in'], dtype=object)
def load_cocitations(self, ids=None):
df = pd.DataFrame(columns=['citing', 'cited_1', 'cited_2', 'year'], dtype=object)
df['year'] = df['year'].astype(int)
return df
def load_bibliographic_coupling(self, ids=None):
df = pd.DataFrame(columns=['citing_1', 'citing_2', 'total'], dtype=object)
df['total'] = df['total'].astype(int)
return df
class MockLoaderEmpty(Loader):
def search(self, terms, limit=None, sort=None, noreviews=True):
return []
def find(self, key, value):
raise Exception('Not implemented')
def load_publications(self, ids):
raise Exception('Not implemented')
def load_citations_by_year(self, ids):
raise Exception('Not implemented')
def load_references(self, pid, limit):
raise Exception('Not implemented')
def load_citations_counts(self, ids):
raise Exception('Not implemented')
def load_citations(self, ids):
raise Exception('Not implemented')
def load_cocitations(self, ids):
raise Exception('Not implemented')
def load_bibliographic_coupling(self, ids=None):
raise Exception('Not implemented')
def expand(self, ids, limit):
raise Exception('Not implemented')
```
#### File: pysrc/test/test_utils.py
```python
import unittest
from parameterized import parameterized
from pysrc.papers.utils import cut_authors_list, crc32, \
preprocess_doi, preprocess_search_title, rgb2hex
class TestUtils(unittest.TestCase):
def test_cut_authors_list_limit_size(self):
limit_size_list = "first, second, third"
actual = cut_authors_list(limit_size_list, limit=len(limit_size_list))
self.assertEqual(actual, limit_size_list)
def test_cut_authors_list_less(self):
long_list = "first, second, third"
actual = cut_authors_list(long_list, 2)
expected = "first,...,third"
self.assertEqual(actual, expected)
def test_cut_authors_list_greater(self):
short_list = "first, second, third"
actual = cut_authors_list(short_list, 4)
self.assertEqual(actual, short_list)
@parameterized.expand([
('cc77a65ff80a9d060e48461603bcf06bb0ef9294', -189727251, 'negative'),
('6d8484217c9fa02419536c9118435715d3a8e705', 1979136599, 'positive')
])
def test_crc32(self, ssid, crc32id, case):
self.assertEqual(crc32(ssid), crc32id, f"Hashed id is wrong ({case} case)")
@parameterized.expand([
('dx.doi.org prefix', 'http://dx.doi.org/10.1037/a0028240', '10.1037/a0028240'),
('doi.org prefix', 'http://doi.org/10.3352/jeehp.2013.10.3', '10.3352/jeehp.2013.10.3'),
('no changes', '10.1037/a0028240', '10.1037/a0028240')
])
def test_preprocess_doi(self, case, doi, expected):
self.assertEqual(preprocess_doi(doi), expected, case)
def test_preprocess_pubmed_search_title(self):
title = '[DNA methylation age.]'
expected = 'DNA methylation age'
self.assertEqual(preprocess_search_title(title), expected)
@parameterized.expand([
([145, 200, 47], '#91c82f'),
([143, 254, 9], '#8ffe09'),
('red', '#ff0000'),
('blue', '#0000ff')
])
def test_color2hex(self, color, expected):
self.assertEqual(rgb2hex(color), expected)
```
|
{
"source": "JetBrains-Research/relevant-tasks-search",
"score": 3
}
|
#### File: src/tools/rut5_finetuning.py
```python
import os
from argparse import ArgumentParser
import numpy as np
import pandas as pd
from transformers import (
AutoTokenizer,
AutoModelForSeq2SeqLM,
DataCollatorForSeq2Seq,
Seq2SeqTrainingArguments,
Seq2SeqTrainer,
)
from datasets import DatasetDict, load_metric
import nltk
def read_data(input_path: str, load_courses=False):
"""
Used for reading data from input path and returning pd.DataFrames
:param input_path: path to dir with train/test/val .csv files
:param load_courses: if True, loading data about courses and sections too
:return:
"""
if not isinstance(input_path, str):
raise Exception(f"You passed {type(input_path)} instead of str type")
if not os.path.exists(input_path):
raise FileNotFoundError(f"{input_path} doesn't exist")
data_train = pd.read_csv(os.path.join(input_path, "train.csv"))
data_val = pd.read_csv(os.path.join(input_path, "val.csv"))
data_test = pd.read_csv(os.path.join(input_path, "test.csv"))
data_train = data_train.dropna().reset_index(drop=True)
data_val = data_val.dropna().reset_index(drop=True)
data_test = data_test.dropna().reset_index(drop=True)
if load_courses:
data_courses = pd.read_csv(os.path.join(input_path, "popular_courses.csv"))
data_sections = pd.read_csv(os.path.join(input_path, "popular_courses_sections.csv"))
return data_train, data_val, data_test, data_courses, data_sections
else:
return data_train, data_val, data_test
def create_dataset(input_path: str, output_path: str):
"""
Used for dataset's creation. You should provide input path with train/test/val .csv files and
sections & courses data
:param input_path: path to load train/test/val .csv files and sections & courses data
:param output_path: path to save datasets
:return:
"""
if not os.path.isdir(output_path):
os.mkdir(output_path)
data_train, data_val, data_test, data_courses, data_sections = read_data(input_path, load_courses=True)
dataset_train = pd.DataFrame({"text": data_train.preprocessed_text, "id": data_train.id})
dataset_test = pd.DataFrame({"text": data_test.preprocessed_text, "id": data_test.id})
dataset_val = pd.DataFrame({"text": data_val.preprocessed_text, "id": data_val.id})
course2title = {}
for index in data_courses.index:
course2title[data_courses.at[index, "id"]] = data_courses.at[index, "title"]
section2title = {}
for index in data_sections.index:
section2title[data_sections.at[index, "id"]] = data_sections.at[index, "title"]
# Adding key word "summarize" which T5 is needed
dataset_train.text = "summarize: " + dataset_train.text + " </s>"
dataset_test.text = "summarize: " + dataset_test.text + " </s>"
dataset_val.text = "summarize: " + dataset_val.text + " </s>"
# Adding some king of summary - section_name + delimiter + course_name
dataset_train["summary"] = ""
dataset_test["summary"] = ""
dataset_val["summary"] = ""
for index in data_train.index:
course_id = data_train.at[index, "course_id"]
section_id = data_train.at[index, "section_id"]
dataset_train.at[index, "summary"] = section2title[section_id] + " в курсе " + course2title[course_id]
for index in data_test.index:
course_id = data_test.at[index, "course_id"]
section_id = data_test.at[index, "section_id"]
dataset_test.at[index, "summary"] = section2title[section_id] + " в курсе " + course2title[course_id]
for index in data_val.index:
course_id = data_val.at[index, "course_id"]
section_id = data_val.at[index, "section_id"]
dataset_val.at[index, "summary"] = section2title[section_id] + " в курсе " + course2title[course_id]
# Saving datasets to the output dir
dataset_train.to_csv(os.path.join(output_path, "dataset_train.csv"), index=False, header=True)
dataset_test.to_csv(os.path.join(output_path, "dataset_test.csv"), index=False, header=True)
dataset_val.to_csv(os.path.join(output_path, "dataset_val.csv"), index=False, header=True)
def preprocess_function(examples, tokenizer, max_length=512):
"""
This function is used to tokenized text in datasets
Adopt by me almost without changes from https://github.com/huggingface/notebooks/blob/master/examples/summarization.ipynb
:param examples: dataset
:param tokenizer: tokenizer to use
:param max_length: max length of sequence in tokens
:return:
"""
inputs = [doc for doc in examples["text"]]
model_inputs = tokenizer(inputs, max_length=max_length, truncation=True, padding="max_length")
# Setup the tokenizer for targets
with tokenizer.as_target_tokenizer():
labels = tokenizer(examples["summary"], max_length=max_length, truncation=True, padding="max_length")
model_inputs["labels"] = labels["input_ids"]
return model_inputs
def compute_metrics(eval_pred, tokenizer, metric):
"""
This function is used to compute ROUGE metric.
Adopt by me almost without changes from https://github.com/huggingface/notebooks/blob/master/examples/summarization.ipynb
:param eval_pred:
:param tokenizer:
:param metric:
:return:
"""
predictions, labels = eval_pred
decoded_preds = tokenizer.batch_decode(predictions, skip_special_tokens=True)
# Replace -100 in the labels as we can't decode them.
labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
# Rouge expects a newline after each sentence
decoded_preds = ["\n".join(nltk.sent_tokenize(pred.strip())) for pred in decoded_preds]
decoded_labels = ["\n".join(nltk.sent_tokenize(label.strip())) for label in decoded_labels]
result = metric.compute(predictions=decoded_preds, references=decoded_labels, use_stemmer=True)
# Extract a few results
result = {key: value.mid.fmeasure * 100 for key, value in result.items()}
# Add mean generated length
prediction_lens = [np.count_nonzero(pred != tokenizer.pad_token_id) for pred in predictions]
result["gen_len"] = np.mean(prediction_lens)
return {k: round(v, 4) for k, v in result.items()}
def train(
input_path: str, output_path: str, metric_name: str = "rouge", model_checkpoint: str = "cointegrated/rut5-small"
):
"""
Used for training. You should provide input path with already computed datasets
:param input_path: path to directory with datasets
:param output_path: where to save trained model
:param metric_name: metric to compute while training
:param model_checkpoint: checkpoint to start finetuning
:return:
"""
if not os.path.exists(input_path):
raise FileNotFoundError(f"{input_path} doesn't exist")
if not os.path.isdir(output_path):
os.mkdir(output_path)
raw_datasets = DatasetDict.from_csv(
{
"train": os.path.join(input_path, "dataset_train.csv"),
"test": os.path.join(input_path, "dataset_test.csv"),
"validation": os.path.join(input_path, "dataset_val.csv"),
}
)
metric = load_metric(metric_name)
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)
tokenized_datasets = raw_datasets.map(lambda x: preprocess_function(x, tokenizer), batched=True)
batch_size = 4
args = Seq2SeqTrainingArguments(
os.path.join(output_path, "rut5_finetuned"),
evaluation_strategy="steps",
eval_steps=200,
learning_rate=2e-5,
per_device_train_batch_size=batch_size,
per_device_eval_batch_size=batch_size,
weight_decay=1e-5,
save_total_limit=1,
save_strategy="steps",
save_steps=1000,
num_train_epochs=2,
predict_with_generate=True,
logging_steps=200,
logging_first_step=True,
logging_dir=os.path.join(output_path, "logs"),
push_to_hub=False,
)
try:
nltk.data.find("tokenizers/punkt")
except LookupError:
nltk.download("punkt")
data_collator = DataCollatorForSeq2Seq(tokenizer, model=model)
trainer = Seq2SeqTrainer(
model,
args,
train_dataset=tokenized_datasets["train"],
eval_dataset=tokenized_datasets["test"],
data_collator=data_collator,
tokenizer=tokenizer,
compute_metrics=lambda x: compute_metrics(x, tokenizer, metric),
)
trainer.train()
model.save_pretrained(os.path.join(output_path, "rut5_finetuned"))
def configure_arg_parser() -> ArgumentParser:
arg_parser = ArgumentParser()
arg_parser.add_argument("-t", "--task", choices=["create_dataset", "train"], required=True)
arg_parser.add_argument("-o", "--output", required=True, help="Path to output directory")
arg_parser.add_argument("-i", "--input", required=True, help="Path to input directory")
return arg_parser
if __name__ == "__main__":
__arg_parser = configure_arg_parser()
__args = __arg_parser.parse_args()
if __args.task == "create_dataset":
create_dataset(__args.input, __args.output)
elif __args.task == "train":
train(__args.input, __args.output)
```
|
{
"source": "JetBrains-Research/ReSplit",
"score": 3
}
|
#### File: ReSplit/analysis/generator_functions.py
```python
import pandas as pd
import os
import re
def merge_chunked_data(dataset, path='../dump2', save_path='../data', duplicates='../data/duplicates_id.csv'):
chunks = os.listdir(f'{path}/{dataset}')
df_list = [pd.read_csv(f'{path}/{dataset}/{chunk}') for chunk in chunks]
df = pd.concat(df_list)
cols_to_remove = [c for c in df.columns if re.search('Unnamed: ', c)]
df = df.drop(columns=cols_to_remove)
duplicates = pd.read_csv(duplicates)
df = df[~df.notebook_id.isin(duplicates.dupl_id)]
df.to_csv(f'{save_path}/{dataset}.csv')
# return df
```
|
{
"source": "JetBrains-Research/similar-python-dependencies",
"score": 3
}
|
#### File: JetBrains-Research/similar-python-dependencies/cli.py
```python
import argparse
import tempfile
from collections import defaultdict
from operator import itemgetter
from typing import List, Optional, Tuple, Dict, Union
import faiss
import numpy as np
import requirements
from analysis import read_library_names, read_library_embeddings, build_index, get_year, read_repo_list, read_idfs, \
read_dependencies
def _read_file_input(fname: str) -> List[str]:
reqs = [req for req in requirements.parse(open(fname))]
reqs = [req.name.lower().replace('-', '_') for req in reqs]
return reqs
def _parse_requirements_with_tmp_file(requirements: List[str]) -> List[str]:
f = tempfile.NamedTemporaryFile(mode='w')
for req in requirements:
f.write(f'{req}\n')
f.flush()
parsed_requirements = _read_file_input(f.name)
f.close()
return parsed_requirements
def _read_user_input() -> List[str]:
requirements = []
print('Please input dependencies from your requirements.txt file one by one.\n'
'To end the input, pass an empty line.')
while True:
req = input()
req = req.strip()
if req == '':
break
requirements.append(req)
return _parse_requirements_with_tmp_file(requirements)
def project_to_library_embedding(dependencies: List[str]) -> Optional[np.ndarray]:
known_libraries = read_library_names()
library_embeddings = read_library_embeddings()
inds = [known_libraries.index(dep) for dep in dependencies if dep in known_libraries]
if len(inds) == 0:
return None
embedding = library_embeddings[inds].mean(axis=0)
return embedding / np.linalg.norm(embedding)
def predict_closest_by_raw_embedding(
file: str, embeddings: np.ndarray, amount: int
) -> List[List[Tuple[int, np.float]]]:
# Load the embeddings and transform them to the necessary format
data = np.load(file)
data = data.astype(np.float32)
# Load the names of repos
repos_list = []
with open("models/repos_list.txt") as fin:
for line in fin:
repos_list.append(line.rstrip())
repos_list = np.array(repos_list)
target_year = '2020'
picked_repos = [
i
for i, repo_name in enumerate(repos_list)
if get_year(repo_name) == target_year
]
data = data[picked_repos] # Filter the embeddings
index = build_index(data)
# Build query embeddings of query projects
query_embedding = embeddings.copy().astype(np.float32)
faiss.normalize_L2(query_embedding)
all_distances, all_indices = index.search(query_embedding, len(data))
# Iterating over query projects.
closest = [[] for _ in range(query_embedding.size)]
for query_ind, (distances, indices) in enumerate(zip(all_distances, all_indices)):
# Post-process all the repos.
for dist, ind in zip(distances, indices):
closest[query_ind].append((ind, dist))
if len(closest[query_ind]) >= amount:
break # If enough candidates are gathered, stop the process
return closest
def suggest_libraries_from_predictions(
config: Dict[str, Union[float, int]],
predictions: List[Tuple[int, float]],
query_libraries: List[str],
reqs: Optional[Dict[str, List[str]]] = None,
idfs: Optional[Dict[str, float]] = None,
repos_list: Optional[np.ndarray] = None
):
if reqs is None:
reqs = read_dependencies()
if idfs is None:
idfs = read_idfs()
if repos_list is None:
repos_list = [repo for repo in read_repo_list() if get_year(repo) == '2020']
libraries = defaultdict(float)
for closest_ind, dist in predictions: # Iterate over the closest repos.
repo_name = repos_list[closest_ind]
for req in reqs[repo_name]: # Iterate over dependencies.
if req not in query_libraries: # Skip if the given requirement already in the query.
# Cosine distance to repo * IDF of lib
libraries[req] += (idfs[req] ** config['idf_power']) * \
(((dist + 1) / 2) ** config['sim_power'])
# Sort the suggestions by their score.
return list(sorted(libraries.items(), key=itemgetter(1, 0), reverse=True))
def configs():
return [
{
'description': 'Regular',
'num_closest': 500,
'idf_power': -1,
'sim_power': 2
},
{
'description': 'Exploration',
'num_closest': 50,
'idf_power': 3,
'sim_power': 2
}
]
def run_predictions(args: argparse.Namespace):
if args.file is None:
requirements = _read_user_input()
else:
requirements = _read_file_input(args.file)
print('Your requirements:\n', requirements)
embedding = project_to_library_embedding(requirements)
for config in configs():
closest = predict_closest_by_raw_embedding(
'models/repos_by_libraries_embeddings.npy', embedding.reshape(1, -1), amount=config['num_closest']
)
suggestions = suggest_libraries_from_predictions(config, closest[0], requirements)
print()
print(f'{config["description"]} suggestions:')
for lib, score in suggestions[:20]:
print(f'{lib} | {score:.3f}')
if __name__ == '__main__':
argparser = argparse.ArgumentParser()
argparser.add_argument(
'-f', '--file',
help='Path to requirements.txt file. If not passed, you will be prompted to input the dependencies.',
required=False, type=str
)
run_predictions(argparser.parse_args())
```
|
{
"source": "JetBrains-Research/snakecharm",
"score": 2
}
|
#### File: bismark/bismark/wrapper.py
```python
__author__ = "<NAME>"
__copyright__ = "Copyright (c) 2019 JetBrains"
__email__ = "<EMAIL>"
__license__ = "MIT"
import os
from snakemake.shell import shell
from tempfile import TemporaryDirectory
def basename_without_ext(file_path):
"""Returns basename of file path, without the file extension."""
base = os.path.basename(file_path)
split_ind = 2 if base.endswith(".gz") else 1
base = ".".join(base.split(".")[:-split_ind])
return base
extra = snakemake.params.get("extra", "")
cmdline_args = ["bismark {extra} --bowtie2"]
outdir = os.path.dirname(snakemake.output.bam)
if outdir:
cmdline_args.append("--output_dir {outdir}")
genome_indexes_dir = os.path.dirname(snakemake.input.bismark_indexes_dir)
cmdline_args.append("{genome_indexes_dir}")
if not snakemake.output.get("bam", None):
raise ValueError("bismark/bismark: Error 'bam' output file isn't specified.")
if not snakemake.output.get("report", None):
raise ValueError("bismark/bismark: Error 'report' output file isn't specified.")
# basename
if snakemake.params.get("basename", None):
cmdline_args.append("--basename {snakemake.params.basename:q}")
basename = snakemake.params.basename
else:
basename = None
# reads input
single_end_mode = snakemake.input.get("fq", None)
if single_end_mode:
# for SE data, you only have to specify read1 input by -i or --in1, and
# specify read1 output by -o or --out1.
cmdline_args.append("--se {snakemake.input.fq:q}")
mode_prefix = "se"
if basename is None:
basename = basename_without_ext(snakemake.input.fq)
else:
# for PE data, you should also specify read2 input by -I or --in2, and
# specify read2 output by -O or --out2.
cmdline_args.append("-1 {snakemake.input.fq_1:q} -2 {snakemake.input.fq_2:q}")
mode_prefix = "pe"
if basename is None:
# default basename
basename = basename_without_ext(snakemake.input.fq_1) + "_bismark_bt2"
# log
log = snakemake.log_fmt_shell(stdout=True, stderr=True)
cmdline_args.append("{log}")
# run
shell(" ".join(cmdline_args))
# Move outputs into proper position.
expected_2_actual_paths = [
(
snakemake.output.bam,
os.path.join(
outdir, "{}{}.bam".format(basename, "" if single_end_mode else "_pe")
),
),
(
snakemake.output.report,
os.path.join(
outdir,
"{}_{}_report.txt".format(basename, "SE" if single_end_mode else "PE"),
),
),
(
snakemake.output.get("nucleotide_stats", None),
os.path.join(
outdir,
"{}{}.nucleotide_stats.txt".format(
basename, "" if single_end_mode else "_pe"
),
),
),
]
log_append = snakemake.log_fmt_shell(stdout=True, stderr=True, append=True)
for (exp_path, actual_path) in expected_2_actual_paths:
if exp_path and (exp_path != actual_path):
shell("mv {actual_path:q} {exp_path:q} {log_append}")
```
#### File: bio/fastqc/wrapper.py
```python
__author__ = "<NAME>"
__copyright__ = "Copyright 2017, <NAME>"
__email__ = "<EMAIL>"
__license__ = "MIT"
from os import path
from tempfile import TemporaryDirectory
from snakemake.shell import shell
log = snakemake.log_fmt_shell(stdout=False, stderr=True)
def basename_without_ext(file_path):
"""Returns basename of file path, without the file extension."""
base = path.basename(file_path)
split_ind = 2 if base.endswith(".fastq.gz") else 1
base = ".".join(base.split(".")[:-split_ind])
return base
# Run fastqc, since there can be race conditions if multiple jobs
# use the same fastqc dir, we create a temp dir.
with TemporaryDirectory() as tempdir:
shell(
"fastqc {snakemake.params} --quiet -t {snakemake.threads} "
"--outdir {tempdir:q} {snakemake.input[0]:q}"
" {log:q}"
)
# Move outputs into proper position.
output_base = basename_without_ext(snakemake.input[0])
html_path = path.join(tempdir, output_base + "_fastqc.html")
zip_path = path.join(tempdir, output_base + "_fastqc.zip")
if snakemake.output.html != html_path:
shell("mv {html_path:q} {snakemake.output.html:q}")
if snakemake.output.zip != zip_path:
shell("mv {zip_path:q} {snakemake.output.zip:q}")
```
|
{
"source": "JetBrains-Research/spla-bench",
"score": 2
}
|
#### File: scripts/build/build.py
```python
from config import TOOL_CONFIG
from typing import Callable, List, Tuple
from pathlib import Path
import build.suitesparse as suitesparse
from build.graphblast import build as build_graphblast
from build.gunrock import build as build_gunrock
from build.lagraph import build as build_lagraph
from build.spla import build as build_spla
from lib.tool import ToolName
from lib.util import check_paths_exist
TOOL_BUILDERS = {
ToolName.graphblast: build_graphblast,
ToolName.gunrock: build_gunrock,
ToolName.lagraph: build_lagraph,
ToolName.spla: build_spla
}
def rebuild(builder: Callable[[], None], targets: List[Path]):
builder()
if not check_paths_exist(targets):
not_built = '\n\t' + \
'\n\t'.join(filter(lambda t: not t.exists(), targets))
raise Exception(f'Not all targets were built:{not_built}')
def build(builder: Callable[[], None], targets: List[Path]):
if check_paths_exist(targets):
return
rebuild(builder, targets)
def build_tool(tool: ToolName):
build(TOOL_BUILDERS[tool], TOOL_CONFIG[tool].algo_exec_paths())
def rebuild_tool(tool: ToolName):
rebuild(TOOL_BUILDERS[tool], TOOL_CONFIG[tool].algo_exec_paths())
def build_suitesparse() -> Tuple[Path, Path]:
if check_paths_exist(suitesparse.chosen_method_targets()):
return
return suitesparse.do_chosen_method()
def rebuild_suitesparse() -> Tuple[Path, Path]:
return suitesparse.do_chosen_method()
```
#### File: scripts/build/graphblast.py
```python
import subprocess
import config
import lib.util as util
from lib.tool import ToolName
GRAPHBLAST_PATHS = config.TOOL_CONFIG[ToolName.graphblast]
def build():
util.check_call(
[
"make", "-B", f"--directory={GRAPHBLAST_PATHS.sources}", f"-j{config.BUILD.jobs}"
]
)
```
#### File: scripts/lib/algorithm.py
```python
from enum import Enum
class AlgorithmName(Enum):
bfs = 'bfs'
tc = 'tc'
sssp = 'sssp'
def __str__(self):
return self.value
```
#### File: scripts/lib/matrix.py
```python
import random
from typing import List, Tuple, Union, Callable, Type, Optional, FrozenSet, Set
from pathlib import Path
MatrixValueType = Union[int, float]
ValuedMatrixEntry = Tuple[int, int, MatrixValueType]
VoidMatrixEntry = Tuple[int, int]
MatrixData = Tuple[int, int, List[Union[ValuedMatrixEntry, VoidMatrixEntry]]]
Void = type(None)
def remove_comment(line: str) -> str:
return line[:line.find("%")] if line else None
def reader_header(line_iter) -> str:
line = remove_comment(next(line_iter))
while not line is None and len(line) == 0:
line = remove_comment(next(line_iter))
return line
def load_header(path: Path) -> Tuple[int, int, int]:
with path.open('r') as file:
line = file.readline()
while line.startswith('%'):
line = file.readline()
n, m, nvals = map(int, line.split(' '))
return n, m, nvals
def value_type_of_repr(repr: str) -> MatrixValueType:
if '.' in repr:
return float(repr)
return int(repr)
def load(path: str) -> MatrixData:
m = 0
n = 0
entries = list()
with open(path, "r") as file:
lines = file.readlines()
line_iter = iter(lines)
line = reader_header(line_iter)
params = line.split(" ")
assert len(params) == 3
m, n, nvals = int(params[0]), int(params[1]), int(params[2])
if nvals > 0:
nvals -= 1
line = next(line_iter)
values = line.split(" ")
assert len(values) == 2 or len(values) == 3
has_values = len(values) == 3
while line and nvals > 0:
values = line.split(" ")
i, j = int(values[0]), int(values[1])
if has_values:
assert len(values) == 3
entries.append((i, j, value_type_of_repr(values[2])))
else:
assert len(values) == 2
entries.append((i, j))
line = next(line_iter)
nvals -= 1
return m, n, entries
def save(path: str, matrix: MatrixData) -> None:
with open(path, "w") as file:
m, n, entries = matrix
file.write(f"{m} {n} {len(entries)}\n")
if len(entries) > 0:
has_values = len(entries[0]) == 3
if has_values:
for i, j, v in entries:
file.write(f"{i} {j} {v}\n")
else:
for i, j in entries:
file.write(f"{i} {j}\n")
def value_type(matrix: MatrixData) -> Optional[MatrixValueType]:
_, _, entries = matrix
if entries == []:
return None
if len(entries[0]) < 3:
return None
return type(entries[0][2])
def has_values(matrix: MatrixData) -> bool:
return value_type(matrix) is not None
def remove_values(matrix: MatrixData) -> str:
assert has_values(matrix)
m, n, entries = matrix
result = []
for entry in entries:
i, j, _ = entry
result.append((i, j))
return (m, n, result)
def make_type_generator(t: Type) -> Callable[[], MatrixValueType]:
if t == float:
return random.random
elif t == int:
return lambda: random.randint(1, 100)
raise Exception(f'Unable to generate type {t.name}')
def generate_values(matrix: MatrixData, generator: Callable[[], MatrixValueType]):
assert not has_values(matrix)
m, n, entries = matrix
result = []
for entry in entries:
i, j = entry
result.append((i, j, generator()))
return (m, n, result)
def is_directed(matrix: MatrixData) -> bool:
_, _, entries = matrix
all_edges: Set[Tuple[int, int]] = set()
has_vals = has_values(matrix)
for entry in entries:
if has_vals:
i, j, _ = entry
else:
i, j = entry
edge = (i, j)
edge_rev = (j, i)
if edge_rev in all_edges:
all_edges.remove(edge_rev)
else:
all_edges.add(edge)
return len(all_edges) == len(entries)
def generate_directions(mtx: MatrixData) -> MatrixData:
raise NotImplementedError()
def remove_directions(mtx: MatrixData) -> MatrixData:
raise NotImplementedError()
```
|
{
"source": "JetBrains-Research/stepik-comment-analysis",
"score": 2
}
|
#### File: src/encoder_decoder/encoder_decoder.py
```python
from transformers import AutoModel, BertGenerationConfig, BertGenerationDecoder
from torch.nn import Module
class EncoderDecoderModel(Module):
def __init__(self, num_hidden_layers):
super(EncoderDecoderModel, self).__init__()
self.encoder = AutoModel.from_pretrained("sentence-transformers/paraphrase-multilingual-mpnet-base-v2")
decoder_config = BertGenerationConfig(
vocab_size=250002, num_hidden_layers=num_hidden_layers, is_decoder=True, hidden_size=768
)
self.decoder = BertGenerationDecoder(decoder_config)
def forward(self, x):
embed = self.encoder(x).last_hidden_state
out = self.decoder(inputs_embeds=embed)
return out
```
#### File: src/encoder_decoder/finetuning.py
```python
import os
import torch
import torch.nn.functional as F
from datasets import DatasetDict
from torch.utils.data import DataLoader
from tqdm.auto import tqdm, trange
from transformers import AutoTokenizer, set_seed
from src.encoder_decoder.config import Config
from src.encoder_decoder.encoder_decoder import EncoderDecoderModel
def encode_data(data, tokenizer, max_length):
inputs = tokenizer(data["question"], padding="max_length", truncation=True, max_length=max_length)
outputs = tokenizer(data["answer"], padding="max_length", truncation=True, max_length=max_length)
data["input_ids"] = inputs.input_ids
data["attention_mask"] = inputs.attention_mask
data["decoder_input_ids"] = outputs.input_ids
data["decoder_attention_mask"] = outputs.attention_mask
return data
def calculate_loss(outputs, targets, batch):
outputs = outputs.permute(0, 2, 1)
if outputs.shape[0] != targets.shape[0] or outputs.shape[0] * targets.shape[0] == 0:
return None
loss = F.cross_entropy(outputs, targets, reduction="none")
mask = targets != 1
loss = loss * mask
return loss.sum() / batch
def train_model(config):
set_seed(config.seed)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/paraphrase-multilingual-mpnet-base-v2")
model = EncoderDecoderModel(num_hidden_layers=config.num_hidden_layers)
model.to(device)
model.train()
optimizer = torch.optim.AdamW(params=model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay)
raw_datasets = DatasetDict.from_csv(
{
"train": os.path.join(config.input_path, "df_train.csv"),
"val": os.path.join(config.input_path, "df_eval.csv"),
}
)
raw_datasets = raw_datasets.map(lambda x: encode_data(x, tokenizer, config.max_length))
raw_datasets.set_format(
type="torch", columns=["input_ids", "attention_mask", "decoder_input_ids", "decoder_attention_mask"]
)
dataloaders = {x: DataLoader(raw_datasets[x], batch_size=config.batch_size, shuffle=True) for x in ["train", "val"]}
train_iterator = trange(0, config.epochs, desc="Epoch")
iteration = 0
for _ in train_iterator:
progressbar = tqdm(dataloaders["train"])
model.train()
for batch in progressbar:
optimizer.zero_grad()
outputs = model(batch["input_ids"].to(device))
loss = calculate_loss(outputs["logits"], batch["decoder_input_ids"].to(device), config.batch_size)
loss.backward()
optimizer.step()
progressbar.desc = f"iterations (loss: {round(loss.item(), 2)})"
iteration += 1
model.eval()
eval_loss = 0.0
eval_steps = 0
progressbar_eval = tqdm(dataloaders["val"], desc="validation")
for batch in progressbar_eval:
with torch.no_grad():
outputs = model(batch["input_ids"].to(device))
loss = calculate_loss(outputs["logits"], batch["decoder_input_ids"].to(device), config.batch_size)
eval_loss += loss.item()
eval_steps += 1
eval_loss = eval_loss / eval_steps
print("=== validation: loss ===", round(eval_loss, 2))
torch.save(model.state_dict(), os.path.join(config.output_path, f"encoder_decoder_model_loss_{eval_loss}.pt"))
if __name__ == "__main__":
train_model(Config())
```
|
{
"source": "JetBrains-Research/test-prioritization",
"score": 3
}
|
#### File: src/util/util.py
```python
from pathlib import Path
def parse_projects_file(prefix=Path("")):
projects = []
with open(prefix / Path("projects.txt"), "r") as file:
for line in file:
projects += line.rstrip().split("#")[0].split()
return projects
count = [
(1456, "Exposed_TestOracle"), # 139 tests
(1293, "Kotlin_dev_CompilerAndPlugin_191"), # 23k tests
(1262, "Kotlin_dev_CompilerAndPlugin_192"), # 23k tests
(2312, "Kotlin_dev_CompilerAndPlugin_as34"), # 22k tests
(2319, "Kotlin_dev_CompilerAndPlugin_as35"), # 23k tests
(1279, "Kotlin_dev_GradleIntegrationTests"), # 420 tests
(2336, "Kotlin_dev_CompilerAndPlugin_183"), # 25k tests
(1140, "Kotlin_dev_Aggregate"), # 100k tests
]
count2 = [
(106, "Kotlin_master_Aggregate"),
(107, "IdeaVim_Nvim"),
(107, "KotlinTools_Ktor_BuildGradleWindows"),
(107, "MPS_20191_Distribution_BuildNumber"),
(111, "MPS_20192_Distribution_Statistics"),
(113, "bt554"),
(114, "bt603"),
(114, "Kotlin_KotlinX_Html"),
(115, "bt744"),
(117, "bt367"),
(118, "TeamCityPluginsByJetBrains_Unsorted_RingUISandbox"),
(120, "Kotlin_Performance_IdeaPluginPerformanceTests_Vplus1"),
(123, "Kotlin_TypeScriptDeclarationToKotlinConverter_DukatTranspileConverter"),
(123, "Kotlin_PluginsCompatibilityCheck_As35Trunk13"),
(124, "Kotlin_PluginsCompatibilityCheck_As33Trunk13"),
(128, "Kotlin_master_CompilerAndPlugin_173"),
(131, "MPS_20212_Distribution_BuildNumber"),
(131, "Kotlin_PluginsCompatibilityCheck_As34Trunk13"),
(131, "Kotlin_master_CompilerAndPlugin_as23"),
(132, "Kotlin_master_CompilerAndPlugin_172"),
(133, "Kotlin_master_CompilerAndPlugin_163"),
(134, "Kotlin_master_CompilerTests"),
(134, "Kotlin_master_CompilerAndPlugin_171"),
(134, "Kotlin_master_CompilerAndPlugin_as30"),
(136, "VMprofPython_TestsPython27onMac"),
(136, "bt1058"),
(136, "Kotlin_master_CompilerAndPlugin_NoTests"),
(138, "bt992"),
(138, "MPS_34_BuildNumber"),
(139, "bt1008"),
(142, "KotlinTools_Ktor_BuildLinuxCoroutinesSnapshot"),
(145, "Kotlin_master_CompilerBootstrapNoTests"),
(147, "KotlinTools_Ktor_BuildGradleMac"),
(155, "IdeaVim_Qodana"),
(163, "VMprofPython_TestsPython27onLinux"),
(164, "VMprofPython_TestsPython34onLinux"),
(164, "bt1059"),
(165, "VMprofPython_TestsPython35onLinux"),
(165, "bt1060"),
(169, "ProjectsWrittenInKotlin_SysKotlin"),
(187, "Kotlin_KotlinPublic_BootstrapTestFir_LINUX"),
(188, "bt366"),
(193, "IntellijIdeaPlugins_Rust_192_TestIdea"),
(194, "IntellijIdeaPlugins_Rust_192_TestCLion"),
(195, "OpenSourceProjects_Betaflight_BetaflightConfigurator_Windows"),
(200, "KotlinTools_KotlinxCoroutines_NightlyStressWindows"),
(201, "KotlinTools_KotlinxCoroutines_NightlyStress"),
(201, "Kotlin_Performance_IdeaPluginPerformanceTests"),
(212, "MPS_20192_Distribution_IdeaPlugIn"),
(227, "MPS_20192_Distribution_TestBinaries"),
(227, "MPS_20192_Distribution_TestsFromIdeaProject"),
(227, "MPS_20192_Distribution_IdeaPlugInLatestIdeaBuild"),
(227, "MPS_20192_Distribution_WindowsInstaller"),
(227, "MPS_20192_Distribution_MacInstaller"),
(227, "MPS_20192_Distribution_TestTypesystem"),
(227, "MPS_20192_Distribution_LinuxDistribution"),
(229, "Kotlin_KotlinPublic_Artifacts"),
(229, "MPS_20192_Distribution_Binaries"),
(229, "MPS_20192_Distribution_Extensions"),
(244, "OpenSourceProjects_Hsqldb_HsqldbTrunkIdea"),
(252, "bt413"),
(256, "Kotlin_KotlinPublic_Aggregate"),
(270, "NUnit_NUnit3_FrameworkMSBuild_FrameworkWindowsNet45"),
(278, "NUnit_NUnit3_FrameworkMSBuild_FrameworkWindowsMono40"),
(290, "IdeaVim_IdeaVimEasyMotion_BuildMaster"),
(337, "NUnit_NUnit3_FrameworkMSBuild_FrameworkWindowsNet20"),
(342, "cb_bt350"),
(359, "bt131"),
(362, "bt130"),
(409, "NUnit_NUnit3_FrameworkMSBuild_FrameworkWindowsNet40"),
(418, "IntellijIdeaPlugins_Rust_TestEapCLion"),
(427, "bt1155"),
(427, "IntellijIdeaPlugins_Rust_EapIdea_TestsRust"),
(436, "NUnit_NUnit3_BuildAndTest_WindowsNet45"),
(436, "bt778"),
(437, "NUnit_NUnit3_BuildAndTest_WindowsNet20"),
(437, "bt779"),
(438, "NUnit_NUnit3_BuildAndTest"),
(438, "bt776"),
(443, "Kotlin_KotlinPublic_CompilerDist"),
(449, "MPS_20192_Distribution_BuildNumber"),
(466, "Kotlin_KotlinX_Css"),
(473, "bt565"),
(473, "NUnit_NUnit3_FrameworkMSBuild_FrameworkLinuxMono40"),
(527, "bt780"),
(698, "bt133"),
(703, "bt132"),
(739, "bt136"),
(1031, "bt425"),
(1069, "bt157"),
(1291, "bt419"),
(1292, "bt420"),
(1295, "bt704"),
(1295, "bt422"),
(1299, "bt421"),
]
```
|
{
"source": "JetBrains-Research/topic-dynamics",
"score": 3
}
|
#### File: topic-dynamics/topic_dynamics/modeling.py
```python
import csv
from operator import itemgetter
import os
from typing import Any, Callable, List, Tuple
import artm
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from .parsing import parse_slice_line, parse_token_line
def check_output_directory(output_dir: str) -> Callable[[Any, str], Any]:
"""
Check that an argument of the function that represents a directory exists and is a directory.
:param output_dir: the name of the argument that represents a path to the directory.
:return: the decorator that checks that the argument with the given name exists and is a
directory.
"""
def inner_decorator(fn):
def wrapper(*args, **kwargs):
assert os.path.exists(kwargs[output_dir])
assert os.path.isdir(kwargs[output_dir])
return fn(*args, **kwargs)
return wrapper
return inner_decorator
def create_batches(directory: str, name: str) -> Tuple[artm.BatchVectorizer, artm.Dictionary]:
"""
Create the batches and the dictionary from the dataset.
:param directory: the directory with the dataset.
:param name: name of the processed dataset.
:return: BatchVectorizer and Dictionary.
"""
print("Creating the batches and the dictionary of the data.")
batch_vectorizer = artm.BatchVectorizer(
data_path=directory, data_format="bow_uci", collection_name=name,
target_folder=os.path.abspath(os.path.join(directory, name + "_batches")))
dictionary = batch_vectorizer.dictionary
return batch_vectorizer, dictionary
def define_model(n_topics: int, dictionary: artm.Dictionary, sparse_theta: float,
sparse_phi: float, decorrelator_phi: float) -> artm.artm_model.ARTM:
"""
Define the ARTM model.
:param n_topics: number of topics.
:param dictionary: batch vectorizer dictionary.
:param sparse_theta: sparse theta parameter.
:param sparse_phi: sparse phi Parameter.
:param decorrelator_phi: decorellator phi Parameter.
:return: ARTM model.
"""
print("Defining the model.")
topic_names = ["topic_{}".format(i) for i in range(1, n_topics + 1)]
model_artm = artm.ARTM(topic_names=topic_names, cache_theta=True,
scores=[artm.PerplexityScore(name="PerplexityScore",
dictionary=dictionary),
artm.SparsityPhiScore(name="SparsityPhiScore"),
artm.SparsityThetaScore(name="SparsityThetaScore"),
artm.TopicKernelScore(name="TopicKernelScore",
probability_mass_threshold=0.3),
artm.TopTokensScore(name="TopTokensScore", num_tokens=15)],
regularizers=[artm.SmoothSparseThetaRegularizer(name="SparseTheta",
tau=sparse_theta),
artm.SmoothSparsePhiRegularizer(name="SparsePhi",
tau=sparse_phi),
artm.DecorrelatorPhiRegularizer(name="DecorrelatorPhi",
tau=decorrelator_phi)])
return model_artm
def train_model(model: artm.artm_model.ARTM, n_doc_iter: int, n_col_iter: int,
dictionary: artm.Dictionary, batch_vectorizer: artm.BatchVectorizer) -> None:
"""
Train the ARTM model.
:param model: the trained model.
:param n_doc_iter: number of document passes.
:param n_col_iter: number of collection passes.
:param dictionary: Batch Vectorizer dictionary.
:param batch_vectorizer: Batch Vectorizer.
:return: None.
"""
print("Training the model.")
model.num_document_passes = n_doc_iter
model.initialize(dictionary=dictionary)
model.fit_offline(batch_vectorizer=batch_vectorizer, num_collection_passes=n_col_iter)
@check_output_directory(output_dir="output_dir")
def save_parameters(model: artm.artm_model.ARTM, output_dir: str, name: str) -> None:
"""
Save the parameters of the model: sparsity phi, sparsity theta, kernel contrast,
kernel purity, perplexity, and graphs of sparsity phi, sparsity theta, and perplexity.
When run several times, overwrites the data.
:param model: the model.
:param output_dir: the output directory.
:param name: name of the processed dataset.
:return: None.
"""
with open(os.path.abspath(os.path.join(output_dir, name + "_parameters.txt")), "w+") as fout:
fout.write("Sparsity Phi: {0:.3f}".format(
model.score_tracker["SparsityPhiScore"].last_value) + "\n")
fout.write("Sparsity Theta: {0:.3f}".format(
model.score_tracker["SparsityThetaScore"].last_value) + "\n")
fout.write("Kernel contrast: {0:.3f}".format(
model.score_tracker["TopicKernelScore"].last_average_contrast) + "\n")
fout.write("Kernel purity: {0:.3f}".format(
model.score_tracker["TopicKernelScore"].last_average_purity) + "\n")
fout.write("Perplexity: {0:.3f}".format(
model.score_tracker["PerplexityScore"].last_value) + "\n")
plt.plot(range(model.num_phi_updates),
model.score_tracker["PerplexityScore"].value, "r--", linewidth=2)
plt.xlabel("Iterations count")
plt.ylabel("Perplexity")
plt.grid(True)
plt.savefig(os.path.abspath(os.path.join(output_dir, name + "_perplexity.png")), dpi=1200)
plt.close()
plt.plot(range(model.num_phi_updates),
model.score_tracker["SparsityPhiScore"].value, "r--", linewidth=2)
plt.xlabel("Iterations count")
plt.ylabel("Phi Sparsity")
plt.grid(True)
plt.savefig(os.path.abspath(os.path.join(output_dir, name + "_phi_sparsity.png")), dpi=1200)
plt.close()
plt.plot(range(model.num_phi_updates),
model.score_tracker["SparsityThetaScore"].value, "r--", linewidth=2)
plt.xlabel("Iterations count")
plt.ylabel("Theta Sparsity")
plt.grid(True)
plt.savefig(os.path.abspath(os.path.join(output_dir, name + "_theta_sparsity.png")), dpi=1200)
plt.close()
@check_output_directory(output_dir="output_dir")
def save_most_popular_tokens(model: artm.artm_model.ARTM, output_dir: str, name: str) -> None:
"""
Save the most popular tokens of the model.
When run several times, overwrites the data.
:param model: the model.
:param output_dir: the output directory.
:param name: name of the processed dataset.
:return: None.
"""
with open(os.path.abspath(os.path.join(output_dir, name + "_most_popular_tokens.txt")),
"w+") as fout:
for topic_name in model.topic_names:
fout.write("{topic_name}: {tokens}\n"
.format(topic_name=topic_name,
tokens=str(model.score_tracker["TopTokensScore"]
.last_tokens[topic_name])))
@check_output_directory(output_dir="output_dir")
def save_matrices(model: artm.artm_model.ARTM, output_dir: str, name: str) -> None:
"""
Save the Phi and Theta matrices.
When run several times, overwrites the data.
:param model: the model.
:param output_dir: the output directory.
:param name: name of the processed dataset.
:return: Two matrices as DataFrames.
"""
phi_matrix = model.get_phi().sort_index(axis=0)
phi_matrix.to_csv(os.path.abspath(os.path.join(output_dir, name + "_phi.csv")))
theta_matrix = model.get_theta().sort_index(axis=1)
theta_matrix.to_csv(os.path.abspath(os.path.join(output_dir, name + "_theta.csv")))
@check_output_directory(output_dir="output_dir")
def save_most_topical_files(theta_matrix: pd.DataFrame, tokens_file: str,
n_files: int, output_dir: str, name: str) -> None:
"""
Save the most topical files of the model.
When run several times, overwrites the data.
:param theta_matrix: Theta matrix.
:param tokens_file: the temporary file with tokens.
:param n_files: number of the most topical files to be saved for each topic.
:param output_dir: the output directory.
:param name: name of the processed dataset.
:return: None.
"""
file2path = {}
with open(tokens_file) as fin:
for line in fin:
token_line = parse_token_line(line)
file2path[int(token_line.index)] = token_line.path
with open(os.path.abspath(os.path.join(output_dir, name + "_most_topical_files.txt")),
"w+") as fout:
for i in range(1, theta_matrix.shape[0] + 1):
fout.write("Topic " + str(i) + "\n\n")
# Create a dictionary for this topic where keys are files and values are
# theta values for this topic and this file (n_files largest)
topic_dict = theta_matrix.sort_values(by="topic_" + str(i), axis=1,
ascending=False).loc["topic_" +
str(i)][:n_files].to_dict()
for k in topic_dict.keys():
fout.write("{file_index};{topic_weight:.3f};{file_path}\n"
.format(file_index=str(k), topic_weight=topic_dict[k],
file_path=file2path[int(k)]))
fout.write("\n")
def get_topics_weight(slices_file: str, theta_file: str) -> np.array:
"""
Read the theta file and transform it into topic weights for different slices.
:param slices_file: the path to the file with the indices of the slices.
:param theta_file: the path tp the csv file with the theta matrix.
:return np.array of weights of each topic for each slice.
"""
date2indices = {}
with open(slices_file) as fin:
for line in fin:
slice_line = parse_slice_line(line)
date2indices[slice_line.date] = (slice_line.start_index, slice_line.end_index)
topics_weight = []
with open(theta_file) as fin:
reader = csv.reader(fin)
next(reader, None) # Skip the headers
for row in reader:
topics_weight.append([])
for date in date2indices.keys():
topics_weight[-1].append(
sum(float(i) for i in row[date2indices[date][0]:date2indices[date][1] + 1]))
topics_weight = np.asarray(topics_weight)
return topics_weight
def get_normalized_dynamics(topics_weight: np.array) -> Tuple[np.array, List]:
"""
Transform topics weights into normalized topics weights and a list of dynamics parameters
for every topic: its minimal weight, maximal weight, and their ratio.
:param topics_weight: numpy array with topic weights.
:return np.array of normalized weights and a list with dynamics data.
"""
topics_weight_percent = np.zeros((topics_weight.shape[0], topics_weight.shape[1]))
for j in range(topics_weight.shape[1]):
slice_sum = np.sum(topics_weight[:, j], keepdims=True)
for i in range(topics_weight.shape[0]):
topics_weight_percent[i, j] = (topics_weight[i, j] / slice_sum) * 100
dynamics = []
for i in range(topics_weight_percent.shape[0]):
dynamics.append(["topic_{}".format(i + 1), min(topics_weight_percent[i]),
max(topics_weight_percent[i]),
max(topics_weight_percent[i]) / min(topics_weight_percent[i])])
dynamics = sorted(dynamics, key=itemgetter(3), reverse=True)
return topics_weight_percent, dynamics
@check_output_directory(output_dir="output_dir")
def save_dynamics(slices_file: str, theta_file: str, output_dir: str, name: str) -> None:
"""
Save figures with the dynamics.
When run several times, overwrites the data.
:param slices_file: the path to the file with the indices of the slices.
:param theta_file: the path to the csv file with the theta matrix.
:param output_dir: the output directory.
:param name: name of the processed dataset.
:return: None.
"""
topics_weight = get_topics_weight(slices_file, theta_file)
topics_weight_percent, dynamics = get_normalized_dynamics(topics_weight)
np.savetxt(os.path.abspath(os.path.join(output_dir, name + "_dynamics.txt")), topics_weight,
"%10.3f")
np.savetxt(os.path.abspath(os.path.join(output_dir, name + "_dynamics_percent.txt")),
topics_weight_percent, "%10.3f")
with open(os.path.abspath(os.path.join(output_dir, name + "_dynamics_percent_change.txt")),
"w+") as fout:
for topic in dynamics:
fout.write(
"{topic_name};{minimum_weight:.3f};{maximum_weight:.3f};{max_min_ratio:.3f}\n"
.format(topic_name=topic[0], minimum_weight=topic[1],
maximum_weight=topic[2], max_min_ratio=topic[3]))
plt.stackplot(range(1, topics_weight.shape[1] + 1), topics_weight)
plt.xlabel("Slice")
plt.ylabel("Proportion (a. u.)")
plt.savefig(os.path.abspath(os.path.join(output_dir, name + "_dynamics.png")), dpi=1200)
plt.close()
for topic in topics_weight.tolist():
plt.plot(range(1, topics_weight.shape[1] + 1), topic)
plt.xlabel("Slice")
plt.ylabel("Proportion (a. u.)")
plt.savefig(os.path.abspath(os.path.join(output_dir, name + "_dynamics_topics.png")), dpi=1200)
plt.close()
plt.stackplot(range(1, topics_weight.shape[1] + 1), topics_weight_percent)
plt.xlabel("Slice")
plt.ylabel("Proportion (%)")
plt.savefig(os.path.abspath(os.path.join(output_dir, name + "_dynamics_percent.png")),
dpi=1200)
plt.close()
for topic in topics_weight_percent.tolist():
plt.plot(range(1, topics_weight.shape[1] + 1), topic)
plt.xlabel("Slice")
plt.ylabel("Proportion (%)")
plt.savefig(os.path.abspath(os.path.join(output_dir, name + "_dynamics_topics_percent.png")),
dpi=1200)
plt.close()
def save_metadata(model: artm.artm_model.ARTM, output_dir: str, name: str, n_files: int) -> None:
"""
Save the metadata: the parameters of the model, most popular tokens, the matrices,
most topical files and various dynamics-related statistics.
:param model: the model.
:param output_dir: the output directory.
:param name: name of the processed dataset.
:param n_files: number of the most topical files to be saved for each topic.
:return: None.
"""
print("Saving the results.")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
tokens_file = os.path.abspath(os.path.join(output_dir, os.pardir, name + "_tokens.txt"))
slices_file = os.path.abspath(os.path.join(output_dir, os.pardir, name + "_slices.txt"))
theta_file = os.path.abspath(os.path.join(output_dir, name + "_theta.csv"))
theta_matrix = model.get_theta().sort_index(axis=1)
save_parameters(model=model, output_dir=output_dir, name=name)
save_most_popular_tokens(model=model, output_dir=output_dir, name=name)
save_matrices(model=model, output_dir=output_dir, name=name)
save_most_topical_files(theta_matrix=theta_matrix, tokens_file=tokens_file,
n_files=n_files, output_dir=output_dir, name=name)
save_dynamics(slices_file=slices_file, theta_file=theta_file, output_dir=output_dir, name=name)
def model_topics(output_dir: str, name: str, n_topics: int, sparse_theta: float, sparse_phi: float,
decorrelator_phi: float, n_doc_iter: int, n_col_iter: int, n_files: int) -> None:
"""
Take the input, create the batches, train the model with the given parameters,
and saves all metadata.
:param output_dir: the output directory.
:param name: name of the processed dataset.
:param n_topics: number of topics.
:param sparse_theta: sparse theta parameter.
:param sparse_phi: sparse phi parameter.
:param decorrelator_phi: decorellator phi parameter.
:param n_doc_iter: number of document passes.
:param n_col_iter: number of collection passes.
:param n_files: number of the most topical files to be saved for each topic.
:return: None.
"""
batch_vectorizer, dictionary = create_batches(output_dir, name)
model = define_model(n_topics, dictionary, sparse_theta, sparse_phi, decorrelator_phi)
train_model(model, n_doc_iter, n_col_iter, dictionary, batch_vectorizer)
results_dir = os.path.abspath(os.path.join(output_dir, "results"))
save_metadata(model, results_dir, name, n_files)
print("Topic modeling finished.")
```
#### File: topic-dynamics/topic_dynamics/parsing.py
```python
from collections import Counter
import datetime
from operator import itemgetter
import os
from pathlib import Path
from tempfile import TemporaryDirectory
from typing import Any, List, NamedTuple, Tuple
from tqdm import tqdm
import tree_sitter
from .parsers.utils import get_parser
from .slicing import get_dates, checkout_by_date
NODE_TYPES = {"c": ["identifier", "type_identifier"],
"c-sharp": ["identifier", "type_identifier"],
"cpp": ["identifier", "type_identifier"],
"java": ["identifier", "type_identifier"],
"python": ["identifier", "type_identifier"]}
SliceLine = NamedTuple("SliceLine", [("date", str), ("start_index", int), ("end_index", int)])
TokenLine = NamedTuple("TokenLine", [("index", int), ("path", str), ("tokens", str)])
def parse_slice_line(slice_line: str) -> SliceLine:
"""
Transform a line in the Slices file into the SliceLine format.
:param slice_line: a line in the Slices file.
:return: SliceLine object.
"""
line_list = slice_line.rstrip().split(";")
return SliceLine(line_list[0], int(line_list[1]), int(line_list[2]))
def parse_token_line(token_line: str) -> TokenLine:
"""
Transform a line in Tokens file into the TokenLine format.
:param token_line: a line in the Tokens file.
:return: TokenLine object.
"""
line_list = token_line.rstrip().split(";")
return TokenLine(int(line_list[0]), line_list[1], line_list[2])
def get_extensions(lang: str) -> str:
"""
Returns the extension for a given language. TODO: get rid of this and add enry.
:param lang: language name.
:return: the extension.
"""
extensions = {"cpp": "cpp",
"java": "java",
"python": "py"}
return extensions[lang]
def get_files(directory: str, extension: str) -> List[str]:
"""
Get a list of files with a given extension.
:param directory: path to directory.
:param extension: extension for file filtering -
only files with this extension will be preserved.
:return: list of file paths.
"""
dir_path = Path(directory)
files = [str(path) for path in sorted(dir_path.rglob("*." + extension))]
return files
def read_file(file: str) -> bytes:
"""
Read the contents of the file.
:param file: the path to the file.
:return: bytes with the contents of the file.
"""
with open(file) as fin:
return bytes(fin.read(), "utf-8")
def get_positional_bytes(node: tree_sitter.Node) -> Tuple[int, int]:
"""
Extract start and end byte.
:param node: node on the AST.
:return: (start byte, end byte).
"""
start = node.start_byte
end = node.end_byte
return start, end
def get_identifiers(file: str, lang: str) -> List[Tuple[str, int]]:
"""
Gather a sorted list of identifiers in the file and their count.
:param file: the path to the file.
:param lang: the language of file.
:return: a list of tuples, identifier and count.
"""
content = read_file(file)
tree = get_parser(lang).parse(content)
root = tree.root_node
identifiers = []
def traverse_tree(node: tree_sitter.Node) -> None:
"""
Run down the AST (DFS) from a given node and gather identifiers from its children.
:param node: starting node.
:return: None.
"""
for child in node.children:
if child.type in NODE_TYPES[lang]:
start, end = get_positional_bytes(child)
identifier = content[start:end].decode("utf-8").lower()
if "\n" not in identifier: # Will break output files. TODO: try to recreate bug.
identifiers.append(identifier)
if len(child.children) != 0:
traverse_tree(child)
traverse_tree(root)
sorted_identifiers = sorted(Counter(identifiers).items(), key=itemgetter(1), reverse=True)
return sorted_identifiers
def transform_identifiers(identifiers: List[Tuple[str, int]]) -> List[str]:
"""
Transform the original list of identifiers into the writable form.
:param identifiers: list of tuples, identifier and count.
:return: a list of identifiers in the writable form, "identifier:count".
"""
formatted_identifiers = []
for identifier in identifiers:
if identifier[0].rstrip() != "": # Checking for occurring empty tokens.
formatted_identifiers.append("{identifier}:{count}"
.format(identifier=identifier[0].rstrip(),
count=str(identifier[1]).rstrip()))
return formatted_identifiers
def slice_and_parse(repository: str, output_dir: str, dates: List[datetime.datetime],
lang: str, name: str) -> None:
"""
Split the repository, parse the full files, write the data into a file.
Can be called for parsing full files and for parsing diffs only.
When run several times, overwrites the data.
:param repository: path to the repository to process.
:param output_dir: path to the output directory.
:param dates: a list of dates used for slicing.
:param lang: programming language to use.
:param name: name of the dataset.
:return: None.
"""
print("Creating the temporal slices of the data.")
assert os.path.exists(os.path.abspath(os.path.join(repository, ".git")))
# Create a folder for created files
if not os.path.exists(output_dir):
os.makedirs(output_dir)
dates_indices = {}
count = 0
# Create temporal slices of the project, get a list of files for each slice,
# parse all files, save the tokens
with open(os.path.abspath(os.path.join(output_dir, name + "_tokens.txt")), "w+") as fout:
for date in tqdm(dates):
with TemporaryDirectory() as td:
subdirectory = os.path.abspath(os.path.join(td, date.strftime("%Y-%m-%d")))
checkout_by_date(repository, subdirectory, date)
files = get_files(subdirectory, get_extensions(lang))
start_index = count + 1
for file in files:
if os.path.isfile(file): # TODO: implement a better file-checking mechanism
try:
identifiers = get_identifiers(file, lang)
if len(identifiers) != 0:
count += 1
formatted_identifiers = transform_identifiers(identifiers)
fout.write("{file_index};{file_path};{tokens}\n"
.format(file_index=str(count),
file_path=os.path.relpath(file, os.path.abspath(
os.path.join(output_dir, td))),
tokens=",".join(formatted_identifiers)))
except UnicodeDecodeError:
continue
end_index = count
dates_indices[date.strftime("%Y-%m-%d")] = (start_index, end_index)
# Write the index boundaries of slices into a separate log file
print("Writing the index boundaries of slices into an auxiliary file.")
with open(os.path.abspath(os.path.join(output_dir, name + "_slices.txt")), "w+") as fout:
for date in dates_indices.keys():
if dates_indices[date][1] >= dates_indices[date][0]: # Skips empty slices
fout.write("{date};{start_index};{end_index}\n"
.format(date=date, start_index=str(dates_indices[date][0]),
end_index=str(dates_indices[date][1])))
def split_token_file(slices_file: str, tokens_file: str, output_dir: str) -> None:
"""
Split a single file with tokens into several by the date of the slice. For example, if the
slices in the file are 2015-01-01, 2015-02-01, and 2015-03-01,
it will divide the file into three.
:param slices_file: the path to the file with the indices of the slices.
:param tokens_file: the path to the temporary file with tokens.
:param output_dir: path to the output directory.
:return: None.
"""
print("Splitting the tokens of full files by versions.")
slice_number = 0
date2indices = {}
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Read the data about the indices boundaries of slices
with open(slices_file) as fin:
for line in fin:
slice_number = slice_number + 1
slice_line = parse_slice_line(line)
date2indices[slice_number] = (slice_line.start_index, slice_line.end_index)
# Write the tokens of each slice into a separate file, numbered incrementally
for date in tqdm(date2indices.keys()):
with open(tokens_file) as fin, \
open(os.path.abspath(os.path.join(output_dir, str(date) + ".txt")), "w+") as fout:
for line in fin:
token_line = parse_token_line(line)
if (token_line.index >= date2indices[date][0]) and (
token_line.index <= date2indices[date][1]):
fout.write(line)
def read_tokens_counter(tokens: str) -> Counter:
"""
Transform a string of tokens 'token1:count1,token2:count2' into a Counter object.
:param tokens: input string of tokens 'token1:count1,token2:count2'.
:return: Counter object of token tuples (token, count).
"""
counter_tokens = Counter()
for token_count in tokens.split(","):
token, count = token_count.split(":")
counter_tokens[token] = int(count)
return counter_tokens
def differentiate_tokens(tokens: List[Tuple[str, int]], sign: str,
new_tokens: List[Any]) -> List[Tuple[str, int]]:
"""
Transform the list of tuples (token, count) into the same list,
but adding the necessary sign before each token (+ or -).
:param tokens: input list of tuples (token, count).
:param sign: sign of token, one of two: + or -.
:param new_tokens: output list to append the results to.
:return: list of differentiated tuples (+/-token, count).
"""
assert sign in ["+", "-"]
for token in tokens:
new_token = sign + token[0]
new_tokens.append([new_token, token[1]])
return new_tokens
def calculate_diffs(slices_tokens_dir: str, output_dir: str, name: str,
dates: List[datetime.datetime]) -> None:
"""
Given temporary tokens files of individual slices (separate files with tokens of each file for
every slice), transform this data into a single tokens file with every slice except the first
one, where for every slice and every file in it only changed tokens are saved: new tokens as
'+token', deleted tokens as '-token'.
:param slices_tokens_dir: the directory with token files split by slices.
:param output_dir: path to the output directory.
:param name: name of the processed dataset.
:param dates: a list of dates used for slicing.
:return: None.
"""
print("Calculating the diffs between versions and transforming the token lists.")
diff_indices = {}
count_index_diff = 0
with open(os.path.abspath(os.path.join(output_dir, name + "_diffs_tokens.txt")), "w+") as fout:
for date in tqdm(range(2, len(dates) + 1)):
start_index_diff = count_index_diff + 1
# Save the tokens of the "previous" slice into memory
previous_version = {}
with open(os.path.abspath(
os.path.join(slices_tokens_dir, str(date - 1) + ".txt"))) as fin:
for line in fin:
token_line = parse_token_line(line)
previous_version[token_line.path] = read_tokens_counter(token_line.tokens)
current_version = []
with open(os.path.abspath(os.path.join(slices_tokens_dir, str(date) + ".txt"))) as fin:
for line in fin:
# Iterate over files in the "current" version
token_line = parse_token_line(line)
current_version.append(token_line.path)
tokens = read_tokens_counter(token_line.tokens)
old_path = token_line.path.replace(dates[date - 1].strftime("%Y-%m-%d"),
dates[date - 2].strftime("%Y-%m-%d"), 1)
# Check if the file with this name existed in the previous version
if old_path in previous_version.keys():
old_tokens = previous_version[old_path]
# Calculate which tokens have been added and removed between versions
created_tokens = sorted((tokens - old_tokens).items(), key=itemgetter(1),
reverse=True)
deleted_tokens = sorted((old_tokens - tokens).items(), key=itemgetter(1),
reverse=True)
new_tokens = []
if len(created_tokens) != 0:
new_tokens = differentiate_tokens(created_tokens, "+", new_tokens)
if len(deleted_tokens) != 0:
new_tokens = differentiate_tokens(deleted_tokens, "-", new_tokens)
# If the file is new, all of its tokens are considered created
else:
tokens = sorted(tokens.items(), key=itemgetter(1), reverse=True)
new_tokens = []
new_tokens = differentiate_tokens(tokens, "+", new_tokens)
if len(new_tokens) != 0:
formatted_new_tokens = transform_identifiers(new_tokens)
count_index_diff = count_index_diff + 1
fout.write("{file_index};{file_path};{tokens}\n"
.format(file_index=str(count_index_diff),
file_path=token_line.path,
tokens=",".join(formatted_new_tokens)))
# Iterate over files in the "previous" version to see which have been deleted
for old_path in previous_version.keys():
new_path = old_path.replace(dates[date - 2].strftime("%Y-%m-%d"),
dates[date - 1].strftime("%Y-%m-%d"), 1)
if new_path not in current_version:
tokens = sorted(previous_version[old_path].items(), key=itemgetter(1),
reverse=True)
new_tokens = []
new_tokens = differentiate_tokens(tokens, "-", new_tokens)
formatted_new_tokens = transform_identifiers(new_tokens)
count_index_diff = count_index_diff + 1
fout.write("{file_index};{file_path};{tokens}\n"
.format(file_index=str(count_index_diff),
file_path=old_path,
tokens=",".join(formatted_new_tokens)))
end_index_diff = count_index_diff
diff_indices[dates[date - 1].strftime("%Y-%m-%d")] = (start_index_diff, end_index_diff)
# Write the index boundaries of slices into a separate log file
print("Writing the index boundaries of slices into an auxiliary file (updated).")
with open(os.path.abspath(os.path.join(output_dir, name + "_diffs_slices.txt")), "w+") as fout:
for date in diff_indices.keys():
if diff_indices[date][1] >= diff_indices[date][0]: # Skips empty slices
fout.write("{date};{start_index};{end_index}\n"
.format(date=date, start_index=str(diff_indices[date][0]),
end_index=str(diff_indices[date][1])))
def uci_format(tokens_file: str, output_dir: str, name: str) -> None:
"""
Transform the file with tokens into the UCI bag-of-words format. The format consists of two
files: the first one lists all the tokens in the dataset alphabetically, and the second one
lists all the triplets document-token-count, ranged first by documents, then by tokens.
:param tokens_file: the path to the temporary file with tokens.
:param output_dir: path to the output directory.
:param name: name of the processed dataset.
:return: None.
"""
print("Transforming the data into the UCI format for topic-modeling.")
n_nnz = 0
set_of_tokens = set()
# Compile a list of all tokens in the dataset for a sorted list
with open(tokens_file) as fin:
for n_documents, line in enumerate(fin, start=1):
token_line = parse_token_line(line)
for token in token_line.tokens.split(","):
n_nnz = n_nnz + 1
set_of_tokens.add(token.split(":")[0])
n_tokens = len(set_of_tokens)
# Sort the list of tokens, transform them to indexes and write to file
sorted_list_of_tokens = sorted(list(set_of_tokens))
sorted_dictionary_of_tokens = {}
with open(os.path.abspath(os.path.join(output_dir, "vocab." + name + ".txt")), "w+") as fout:
for index in range(len(sorted_list_of_tokens)):
sorted_dictionary_of_tokens[sorted_list_of_tokens[index]] = index + 1
fout.write(sorted_list_of_tokens[index] + "\n")
# Compile the second necessary file: NNZ triplets sorted by document
with open(tokens_file) as fin, open(
os.path.abspath(os.path.join(output_dir, "docword." + name + ".txt")), "w+") as fout:
fout.write(str(n_documents) + "\n" + str(n_tokens) + "\n" + str(n_nnz) + "\n")
for line in tqdm(fin):
token_line = parse_token_line(line)
file_tokens = token_line.tokens.split(",")
file_tokens_separated = []
file_tokens_separated_numbered = []
for entry in file_tokens:
file_tokens_separated.append(entry.split(":"))
for entry in file_tokens_separated:
file_tokens_separated_numbered.append(
[sorted_dictionary_of_tokens[entry[0]], int(entry[1])])
file_tokens_separated_numbered = sorted(file_tokens_separated_numbered,
key=itemgetter(0), reverse=False)
for entry in file_tokens_separated_numbered:
fout.write("{doc_id} {token_id} {count}\n".format(doc_id=str(line.split(";")[0]),
token_id=str(entry[0]),
count=str(entry[1])))
def slice_and_parse_full_files(repository: str, output_dir: str, n_dates: int,
day_delta: int, lang: str, name: str,
start_date: str = None) -> None:
"""
Split the repository, parse the full files, write the data into a file,
transform into the UCI format.
:param repository: path to the repository to process.
:param output_dir: path to the output directory.
:param n_dates: number of dates.
:param day_delta: the number of days between dates.
:param start_date: the starting (latest) date of the slicing, in the format YYYY-MM-DD,
the default value is the moment of calling.
:param lang: programming language to use.
:param name: name of the dataset.
:return: None.
"""
dates = get_dates(n_dates, day_delta, start_date)
tokens_file = os.path.abspath(os.path.join(output_dir, name + "_tokens.txt"))
slice_and_parse(repository, output_dir, dates, lang, name)
uci_format(tokens_file, output_dir, name)
print("Finished data preprocessing.")
def slice_and_parse_diffs(repository: str, output_dir: str, n_dates: int,
day_delta: int, lang: str, name: str, start_date: str = None) -> None:
"""
Split the repository, parse the full files, extract the diffs,
write the data into a file, transform into the UCI format.
:param repository: path to the repository to process.
:param output_dir: path to the output directory.
:param n_dates: number of dates.
:param day_delta: the number of days between dates.
:param start_date: the starting (latest) date of the slicing, in the format YYYY-MM-DD,
the default value is the moment of calling.
:param lang: programming language to use.
:param name: name of the dataset.
:return: None.
"""
dates = get_dates(n_dates, day_delta, start_date)
slices_file = os.path.abspath(os.path.join(output_dir, name + "_slices.txt"))
tokens_file = os.path.abspath(os.path.join(output_dir, name + "_tokens.txt"))
slices_tokens_dir = os.path.abspath(os.path.join(output_dir, name + "_slices_tokens"))
tokens_file_diffs = os.path.abspath(os.path.join(output_dir, name + "_diffs_tokens.txt"))
slice_and_parse(repository, output_dir, dates, lang, name)
split_token_file(slices_file, tokens_file, slices_tokens_dir)
calculate_diffs(slices_tokens_dir, output_dir, name, dates)
uci_format(tokens_file_diffs, output_dir, name + "_diffs")
print("Finished data preprocessing.")
```
#### File: topic_dynamics/tests/test_parsing.py
```python
import os
import unittest
from ..parsing import get_identifiers
tests_dir = os.path.abspath(os.path.dirname(__file__))
class TestParser(unittest.TestCase):
test_parser_data = [["java", "test_files/test.java",
[("i", 9), ("anarray", 6), ("length", 2), ("system", 2), ("out", 2),
("arraydemo", 1), ("main", 1), ("string", 1), ("args", 1), ("print", 1),
("println", 1)]],
["python", "test_files/test.py",
[("left", 4), ("right", 4), ("n", 4), ("board_size", 3), ("col", 3),
("solve", 3), ("solution", 3), ("i", 3), ("under_attack", 2),
("queens", 2), ("c", 2), ("smaller_solutions", 2), ("answer", 2),
("r", 1), ("reversed", 1), ("range", 1), ("print", 1)]],
["cpp", "test_files/test.cpp",
[("n", 4), ("arr", 2), ("std", 1), ("main", 1), ("cout", 1),
("endl", 1)]]]
def test_parser(self):
for data in TestParser.test_parser_data:
with self.subTest():
file = os.path.abspath(os.path.join(tests_dir, data[1]))
identifiers = get_identifiers(file, data[0])
self.assertEqual(identifiers, data[2])
if __name__ == "__main__":
unittest.main()
```
|
{
"source": "JetBrains-Research/typilus",
"score": 2
}
|
#### File: typeparsing/rewriterules/removegenericwithany.py
```python
from typing import Optional
from graph_generator.typeparsing.nodes import parse_type_annotation_node, TypeAnnotationNode, SubscriptAnnotationNode, \
IndexAnnotationNode, ElipsisAnnotationNode, TupleAnnotationNode
from graph_generator.typeparsing.rewriterules import RewriteRule
__all__ = ['RemoveGenericWithAnys']
class RemoveGenericWithAnys(RewriteRule):
ANY_NODE = parse_type_annotation_node('typing.Any')
def matches(self, node: TypeAnnotationNode, parent: Optional[TypeAnnotationNode]) -> bool:
if not isinstance(node, SubscriptAnnotationNode):
return False
slice = node.slice
if isinstance(slice, IndexAnnotationNode):
slice = slice.value
if isinstance(slice, ElipsisAnnotationNode):
return True
if isinstance(slice, TupleAnnotationNode):
return all(s == self.ANY_NODE or isinstance(s, ElipsisAnnotationNode) for s in slice.elements)
return False
def apply(self, matching_node: TypeAnnotationNode) -> TypeAnnotationNode:
return matching_node.value
```
#### File: typeparsing/rewriterules/removeunionwithanys.py
```python
from typing import Optional
from graph_generator.typeparsing.nodes import parse_type_annotation_node, TypeAnnotationNode, SubscriptAnnotationNode, \
IndexAnnotationNode, ElipsisAnnotationNode, TupleAnnotationNode
from graph_generator.typeparsing.rewriterules import RewriteRule
__all__ = ['RemoveUnionWithAnys']
class RemoveUnionWithAnys(RewriteRule):
UNION_NODE = parse_type_annotation_node('typing.Union')
ANY_NODE = parse_type_annotation_node('typing.Any')
def matches(self, node: TypeAnnotationNode, parent: Optional[TypeAnnotationNode]) -> bool:
if not isinstance(node, SubscriptAnnotationNode):
return False
if node.value != self.UNION_NODE:
return False
slice = node.slice
if isinstance(slice, IndexAnnotationNode):
slice = slice.value
if isinstance(slice, ElipsisAnnotationNode):
return True
if isinstance(slice, TupleAnnotationNode):
return any(s == self.ANY_NODE for s in slice.elements)
return False
def apply(self, matching_node: TypeAnnotationNode) -> TypeAnnotationNode:
return self.ANY_NODE
```
|
{
"source": "JetBrains-Research/washu",
"score": 3
}
|
#### File: JetBrains-Research/washu/pipeline_utils.py
```python
import os
import os.path
from os.path import abspath, realpath, dirname
import argparse
import subprocess
import itertools
import shutil
from glob import glob
PROJECT_ROOT_PATH = abspath(os.path.join(dirname(realpath(__file__))))
class WritableDirectory(argparse.Action):
def __call__(self, parser, namespace, values, option_string=None):
if not os.path.isdir(values):
raise argparse.ArgumentTypeError(
"{0} is not a valid path".format(values)
)
if os.access(values, os.R_OK + os.W_OK):
setattr(namespace, self.dest, values)
else:
raise argparse.ArgumentTypeError(
"{0} is not a writable directory".format(values)
)
def run_bash(script, *params):
"""
Executes desired bash script and wait until it has finished
:param script: script relative (to project root) path
:param params: script args
"""
cmdline = " ".join(["bash", os.path.join(PROJECT_ROOT_PATH, script),
*[str(p) for p in params]])
print(cmdline)
subprocess.run(cmdline, shell=True, check=True)
def run(*params):
cmdline = " ".join([str(p) for p in params])
print(cmdline)
subprocess.run(cmdline, shell=True)
def move_forward(folder, new_folder, what_to_move, copy_files=False):
# Necessary for correct copy behavior
os.chdir(folder)
if not os.path.exists(new_folder):
os.mkdir(new_folder)
for pattern in itertools.chain.from_iterable(map(glob, what_to_move)):
if copy_files:
shutil.copy(pattern, new_folder)
else:
shutil.move(pattern, new_folder)
def file_path_type(dir=False, exists=True, ext=None):
"""
Argparse argument converter.
Usage:
parser.add_argument("tsv_file", type=file_path_type(ext="tsv"))
:param dir: Whether directory or file expected
:param exists: Ensure file or directory exists
:param ext: Desired file extension. If None - do not check
:return: Converter lambda: (arg: str) -> absolute path string
"""
def inner(arg: str) -> str:
msg = None
if exists and not os.path.exists(arg):
msg = "File not exists: " + arg
elif not dir and not os.path.isfile(arg):
msg = "File expected, by was: " + arg
elif dir and (os.path.exists(arg) and not os.path.isdir(arg)):
msg = "Dir expected, by was: " + arg
elif ext and not arg.lower().endswith(".{}".format(ext)):
msg = "File *.{} expected, by was: {}".format(ext, arg)
if msg:
raise argparse.ArgumentTypeError(msg)
return os.path.abspath(arg)
return inner
```
#### File: washu/test/test_annotate_reactome.py
```python
__author__ = '<NAME>'
__email__ = '<EMAIL>'
import pytest
from test.fixtures import test_data, tmp_path
from pipeline_utils import run, PROJECT_ROOT_PATH
from scripts.annotate_reactome import extract_reactome_id, fetch_title
@pytest.mark.parametrize("label,rid", [
("foo", None),
("2644605", None),
("R-HSA-2644605", "R-HSA-2644605"),
("r-hsa-2644605", "R-HSA-2644605"),
("foo_R-HSA-2644605_boo", "R-HSA-2644605"),
("foo_r-hsa-2644605_boo", "R-HSA-2644605"),
("foo.R-HSA-2644605-boo", "R-HSA-2644605"),
("foo-R-HSA-2644605.boo", "R-HSA-2644605"),
("foo-R-HSA-2644605boo", "R-HSA-2644605"),
("http://www.reactome.org/content/detail/R-HSA-2644605", "R-HSA-2644605"),
])
def test_extract_reactome_id(label, rid):
assert rid == extract_reactome_id(label)
@pytest.mark.parametrize("label,title,offline", [
("foo", "N/A", False),
("foo", "N/A", True),
("foo.R-HSA-2644605-boo", "FBXW7 Mutants and NOTCH1 in Cancer", False),
("foo.R-HSA-2644605-boo", "FBXW7 Mutants and NOTCH1 in Cancer", True),
])
def test_fetch_title(test_data, label, title, offline):
kw = {}
if offline:
kw['pathways_db_path'] = test_data("reactome/ReactomePathways.txt")
assert title == fetch_title(label, **kw)[0]
@pytest.mark.parametrize("offline", [True, False])
def test_fetch_titles(test_data, offline):
kw = {}
if offline:
kw['pathways_db_path'] = test_data("reactome/ReactomePathways.txt")
assert ['FBXW7 Mutants and NOTCH1 in Cancer', '2-LTR circle formation'] == fetch_title(
"R-HSA-2644605", "R-HSA-164843", **kw
)
def test_cli_help(capfd):
run("python", "{}/scripts/annotate_reactome.py".format(PROJECT_ROOT_PATH),
"-h")
output = capfd.readouterr()
assert """python {}/scripts/annotate_reactome.py -h
usage: annotate_reactome.py [-h] [--db PATH] [-F FS] [-o PATH] PATH INT_OR_STR
Annotates table containing http://www.reactome.org pathways ids (R-HSA-nnnnn)
with pathways titles
positional arguments:
PATH Table path
INT_OR_STR Index (>=1) or name of column containing Reactome pathway id. If
column is and index column w/o name, use ''
optional arguments:
-h, --help show this help message and exit
--db PATH ReactomePathways.txt file path (default: None)
-F FS Field separator, auto-detect if not specified (default: None)
-o PATH Output path (default: None)
""".format(PROJECT_ROOT_PATH) == output[0]
assert "" == output[1]
@pytest.mark.parametrize("file,args,result_stdout,result_stderr,fresult,offline", [
# offline
("empty.csv", ["1"], "", "File is empty: ", None, True),
("no_header_comma.csv", ["1"], "FBXW7 Mutants and NOTCH1 in Cancer", "", None, True),
("no_header_comma.csv", ["0"], "", "Column index should be >= 1, but was: 0", None, True),
("no_header_comma.csv", ["1"], "", "", "no_header_comma.result.txt", True),
("header_index_comma.csv", ["1"], "FBXW7 Mutants and NOTCH1 in Cancer", "", None, True),
("header_index_comma.csv", ["1"], "", "", "header_index_comma.result1.txt", True),
("header_index_comma.csv", ["''"], "", "", "header_index_comma.result2.txt", True),
("header_colname_comma.csv", ["1"], "FBXW7 Mutants and NOTCH1 in Cancer", "", None, True),
("header_colname_comma.csv", ["1"], "", "", "header_colname_comma.result1.txt", True),
("header_colname_comma.csv", ["data"], "FBXW7 Mutants and NOTCH1 in Cancer", "", None, True),
("header_colname_comma.csv", ["data"], "", "", "header_colname_comma.result2.txt", True),
("header_colname_comma.csv", ["data", "-F','"], "FBXW7 Mutants and NOTCH1 in Cancer", "",
None, True),
("header_colname_tab.tsv", ["data"], "", "", "header_colname_comma.result2.txt", True),
("header_colname_tab.tsv", ["data", "-F'\t'"], "", "", "header_colname_tab.result.txt", True),
("header_colname_comma.csv", ["data", "-F' '"], "",
"KeyError: 'the label [data] is not in the [columns]'", None, True),
# using web access:
("header_colname_comma.csv", ["1"], "FBXW7 Mutants and NOTCH1 in Cancer", "", None, False),
])
def test_cli(test_data, tmp_path, capfd, file, args, result_stdout, result_stderr, fresult,
offline):
pathways_db_path = test_data("reactome/ReactomePathways.txt") if offline else None
input_path = str(test_data("reactome/" + file))
if fresult:
args.append("-o " + str(tmp_path / "result.txt"))
if pathways_db_path:
args.append("--db " + pathways_db_path)
run(
"python", "{}/scripts/annotate_reactome.py".format(PROJECT_ROOT_PATH),
input_path,
*args
)
output = capfd.readouterr()
print("==== stdout =====")
print(output[0])
print("==== stderr =====")
print(output[1])
print("=================")
assert result_stdout in output[0]
assert result_stderr in output[1]
if fresult:
with open(test_data("reactome/" + fresult), 'r') as ef:
expected = ef.read()
with open(str(tmp_path / "result.txt"), 'r') as af:
actual = af.read()
assert expected == actual
```
|
{
"source": "JetBrains/ShortcutMapper",
"score": 3
}
|
#### File: ShortcutMapper/tests/run_all_tests.py
```python
import unittest
from keyboards import TestKeyboardLayout
def main():
"""
Runs the testsuite as command line application, or... that's what it will eventually do.
For the moment, just run everything
"""
try:
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestKeyboardLayout))
unittest.TextTestRunner(verbosity=2).run(suite)
except Exception as e:
print('Error: %s' % e)
if __name__ == '__main__':
main()
```
|
{
"source": "jetbridge/cognitojwt",
"score": 2
}
|
#### File: cognitojwt/cognitojwt/token_utils.py
```python
import time
from typing import Dict
from jose import jwt
from .exceptions import CognitoJWTException
def get_unverified_headers(token: str) -> dict:
return jwt.get_unverified_headers(token)
def get_unverified_claims(token: str) -> dict:
return jwt.get_unverified_claims(token)
def check_expired(exp: int, testmode: bool = False) -> None:
if time.time() > exp and not testmode:
raise CognitoJWTException('Token is expired')
def check_client_id(claims: Dict, app_client_id: str) -> None:
token_use = claims['token_use']
if token_use == 'access':
if claims['aud'] != app_client_id:
raise CognitoJWTException('Token was not issued for this client id audience')
elif token_use == 'id':
if claims['client_id'] != app_client_id:
raise CognitoJWTException('Token was not issued for this client id')
__all__ = [
'get_unverified_headers',
'get_unverified_claims',
'check_expired',
'check_aud'
]
```
|
{
"source": "jetbridge/puresnmp",
"score": 2
}
|
#### File: aio/api/pythonic.py
```python
from __future__ import unicode_literals
import logging
from collections import OrderedDict
from typing import TYPE_CHECKING
from warnings import warn
from . import raw
from ...const import DEFAULT_TIMEOUT
from ...pdu import VarBind
from ...util import BulkResult
from ...x690.types import Type, ObjectIdentifier
if TYPE_CHECKING: # pragma: no cover
# pylint: disable=unused-import, invalid-name
from typing import (
Any,
AsyncGenerator,
Callable,
Coroutine,
Dict,
List,
Tuple,
TypeVar,
Union,
)
from puresnmp.typevars import PyType, TWrappedPyType
TWalkResponse = AsyncGenerator[VarBind, None]
TFetcher = Callable[[str, str, List[str], int, int],
Coroutine[Any, Any, List[VarBind]]]
T = TypeVar('T', bound=PyType) # pylint: disable=invalid-name
try:
unicode = unicode # type: Callable[[Any], str]
except NameError:
# pylint: disable=invalid-name
unicode = str # type: Callable[[Any], str]
_set = set
LOG = logging.getLogger(__name__)
OID = ObjectIdentifier.from_string
async def get(ip, community, oid, port=161, timeout=DEFAULT_TIMEOUT):
# type: (str, str, str, int, int) -> PyType
"""
Delegates to :py:func:`~puresnmp.aio.api.raw.get` but returns simple Python
types.
See the "raw" equivalent for detailed documentation & examples.
"""
raw_value = await raw.get(ip, community, oid, port, timeout=timeout)
return raw_value.pythonize() # type: ignore
async def multiget(ip, community, oids, port=161, timeout=DEFAULT_TIMEOUT):
# type: (str, str, List[str], int, int) -> List[PyType]
"""
Delegates to :py:func:`~puresnmp.aio.api.raw.multiget` but returns simple
Python types.
See the "raw" equivalent for detailed documentation & examples.
"""
raw_output = await raw.multiget(ip, community, oids, port, timeout)
pythonized = [value.pythonize() for value in raw_output]
return pythonized
async def getnext(ip, community, oid, port=161, timeout=DEFAULT_TIMEOUT):
# type: (str, str, str, int, int) -> VarBind
"""
Delegates to :py:func:`~puresnmp.aio.api.raw.getnext` but returns simple
Python types.
See the "raw" equivalent for detailed documentation & examples.
"""
result = await multigetnext(ip, community, [oid], port, timeout=timeout)
return result[0]
async def multigetnext(ip, community, oids, port=161, timeout=DEFAULT_TIMEOUT):
# type: (str, str, List[str], int, int) -> List[VarBind]
"""
Delegates to :py:func:`~puresnmp.aio.api.raw.multigetnext` but returns
simple Python types.
See the "raw" equivalent for detailed documentation & examples.
"""
raw_output = await raw.multigetnext(ip, community, oids, port, timeout)
pythonized = [VarBind(oid, value.pythonize()) # type: ignore
for oid, value in raw_output]
return pythonized
async def walk(ip, community, oid, port=161, timeout=DEFAULT_TIMEOUT):
# type: (str, str, str, int, int) -> TWalkResponse
"""
Delegates to :py:func:`~puresnmp.aio.api.raw.walk` but returns simple
Python types.
See the "raw" equivalent for detailed documentation & examples.
"""
raw_result = raw.walk(ip, community, oid, port, timeout)
async for raw_oid, raw_value in raw_result:
yield VarBind(raw_oid, raw_value.pythonize()) # type: ignore
async def multiwalk(ip, community, oids, port=161, timeout=DEFAULT_TIMEOUT,
fetcher=multigetnext):
# type: (str, str, List[str], int, int, TFetcher) -> TWalkResponse
"""
Delegates to :py:func:`~puresnmp.aio.api.raw.multiwalk` but returns simple
Python types.
See the "raw" equivalent for detailed documentation & examples.
"""
raw_output = raw.multiwalk(ip, community, oids, port, timeout, fetcher)
async for oid, value in raw_output:
if isinstance(value, Type):
value = value.pythonize()
yield VarBind(oid, value) # type: ignore
async def set(ip, community, oid, value, port=161, timeout=DEFAULT_TIMEOUT): # pylint: disable=redefined-builtin
# type: (str, str, str, Type[T], int, int) -> T
"""
Delegates to :py:func:`~puresnmp.aio.api.raw.set` but returns simple Python
types.
See the "raw" equivalent for detailed documentation & examples.
"""
result = await multiset(ip, community, [(oid, value)],
port, timeout=timeout)
return result[oid.lstrip('.')] # type: ignore
async def multiset(ip, community, mappings, port=161, timeout=DEFAULT_TIMEOUT):
# type: (str, str, List[Tuple[str, Type[TWrappedPyType]]], int, int) -> Dict[str, TWrappedPyType]
"""
Delegates to :py:func:`~puresnmp.aio.api.raw.multiset` but returns simple
Python types.
See the "raw" equivalent for detailed documentation & examples.
"""
raw_output = await raw.multiset(ip, community, mappings, port, timeout)
pythonized = {unicode(oid): value.pythonize()
for oid, value in raw_output.items()}
return pythonized
async def bulkget(ip, community, scalar_oids, repeating_oids, max_list_size=1,
port=161, timeout=DEFAULT_TIMEOUT):
# type: (str, str, List[str], List[str], int, int, int) -> BulkResult
"""
Delegates to :py:func:`~puresnmp.aio.api.raw.bulkget` but returns simple
Python types.
See the "raw" equivalent for detailed documentation & examples.
"""
raw_output = await raw.bulkget(ip, community, scalar_oids, repeating_oids,
max_list_size=max_list_size,
port=port,
timeout=timeout)
pythonized_scalars = {oid: value.pythonize()
for oid, value in raw_output.scalars.items()}
pythonized_list = OrderedDict(
[(oid, value.pythonize())
for oid, value in raw_output.listing.items()])
return BulkResult(pythonized_scalars, pythonized_list)
async def bulkwalk(ip, community, oids, bulk_size=10, port=161,
timeout=DEFAULT_TIMEOUT):
# type: (str, str, List[str], int, int, int) -> TWalkResponse
"""
Delegates to :py:func:`~puresnmp.aio.api.raw.bulkwalk` but returns simple
Python types.
See the "raw" equivalent for detailed documentation & examples.
"""
result = multiwalk(
ip, community, oids, port=port,
fetcher=raw._bulkwalk_fetcher( # pylint: disable=protected-access
bulk_size),
timeout=timeout)
async for oid, value in result:
yield VarBind(oid, value) # type: ignore
async def table(ip, community, oid, port=161, num_base_nodes=0):
# type: (str, str, str, int, int) -> AsyncGenerator[Dict[str, Any], None]
"""
Fetches a table from the SNMP agent. Each value will be converted to a
pure-python type.
See :py:func:`puresnmp.api.raw.table` for more information of the returned
structure.
"""
if num_base_nodes:
warn('Usage of "num_base_nodes" in table operations is no longer '
'required', DeprecationWarning)
else:
parsed_oid = OID(oid)
num_base_nodes = len(parsed_oid) + 1 # type: ignore
tmp = raw.table(ip, community, oid, port=port,
num_base_nodes=num_base_nodes)
async for row in tmp:
index = row.pop('0')
pythonized = {key: value.pythonize() for key, value in row.items()}
pythonized['0'] = index
yield pythonized
async def bulktable(ip, community, oid, port=161, num_base_nodes=0, bulk_size=10):
# type: (str, str, str, int, int, int) -> AsyncGenerator[Dict[str, Any], None]
"""
Fetch an SNMP table using "bulk" requests converting the values into pure
Python types.
See :py:func:`puresnmp.api.raw.table` for more information of the returned
structure.
.. versionadded: 1.7.0
"""
if num_base_nodes:
warn('Usage of "num_base_nodes" in table operations is no longer '
'required', DeprecationWarning)
else:
parsed_oid = OID(oid)
num_base_nodes = len(parsed_oid) + 1 # type: ignore
tmp = raw.bulktable(ip, community, oid, port=port, bulk_size=bulk_size)
for row in tmp:
index = row.pop('0')
pythonized = {key: value.pythonize() for key, value in row.items()}
pythonized['0'] = index
yield pythonized
```
#### File: puresnmp/test/test_types.py
```python
import pytest
from puresnmp import types as t
@pytest.mark.parametrize('value, expected', [
(-42, 0), # Underflow below threshold
(-1, 0), # Underflow at threshold
(0, 0), # The minimum value
(42, 42), # A normal value
(2**32-1, 2**32-1), # max value
(2**32, 0), # overflow at threshold
(2**32+42, 42), # overflow above threshold
((2**32)*2+42, 42), # overflow above threshold
])
def test_counter(value, expected):
"""
A counter instance should be a non-negative integer
"""
instance = t.Counter(value)
assert instance.value == expected
def test_counter_issue_75():
"""
GitHub issue #75 reports incorrect counter decoding.
This test covers this issue.
"""
data = b'\x41\x04\x84\x43\x20\xf8'
result = t.Counter.from_bytes(data)
expected = t.Counter(2218991864)
assert result == expected
@pytest.mark.parametrize('value, expected', [
(-42, 0), # Underflow below threshold
(-1, 0), # Underflow at threshold
(0, 0), # The minimum value
(42, 42), # A normal value
(2**64-1, 2**64-1), # max value
(2**64, 0), # overflow at threshold
((2**64)*2+42, 42), # overflow above threshold
])
def test_counter64(value, expected):
"""
A counter instance should be a non-negative integer
"""
instance = t.Counter64(value)
assert instance.value == expected
```
|
{
"source": "jetbridge/smorest-crud",
"score": 2
}
|
#### File: test/app/__init__.py
```python
from flask import Flask, jsonify
from flask_sqlalchemy import SQLAlchemy
from smorest_crud import ResourceView, CRUD, CollectionView
from flask_smorest import Api, Blueprint, abort
from marshmallow import fields as f, Schema
from sqlalchemy import inspect
import os
from flask_jwt_extended import JWTManager
db = SQLAlchemy()
from smorest_crud.test.app.model import Pet, Human, Car
api = Api()
debug = bool(os.getenv("DEBUG"))
USER_NAME = "mischa"
def create_app() -> Flask:
app = Flask("CRUDTest")
app.config.update(
OPENAPI_VERSION="3.0.2",
SQLALCHEMY_DATABASE_URI=f"sqlite://",
SQLALCHEMY_TRACK_MODIFICATIONS=False,
SQLALCHEMY_ECHO=debug,
CRUD_GET_USER=lambda: Human(name=USER_NAME),
CRUD_ACCESS_CHECKS_ENABLED=True,
SECRET_KEY="wnt2die",
)
JWTManager(app)
db.init_app(app)
api.init_app(app)
CRUD(app)
app.register_blueprint(pet_blp)
app.register_blueprint(human_blp)
app.register_blueprint(pointless_blp)
return app
class HumanSchema(Schema):
id = f.Integer(dump_only=True) # not editable
name = f.String()
pets = f.Nested("PetSchemaLite", many=True, exclude=("human",))
not_allowed = f.String(load_only=True) # disallowed for create
class PetSchemaLite(Schema):
id = f.Integer(dump_only=True) # not editable
genus = f.String()
species = f.String()
human = f.Nested(HumanSchema, exclude=("pets",))
class PetSchema(PetSchemaLite):
edible = f.Boolean()
class CarSchema(Schema):
id = f.Integer()
pet_blp = Blueprint("pets", "pets", url_prefix="/pet")
@pet_blp.route("")
class PetCollection(CollectionView):
model = Pet
prefetch = [Pet.human, (Pet.human, Human.cars)] # joinedload
access_checks_enabled = False
create_enabled = True
list_enabled = True
def get(self):
query = super().get()
# check prefetch worked
first = query.first()
return jsonify(
{
"loaded": {
"first.human": is_rel_loaded(first, "human"),
"first.human.cars": is_rel_loaded(first.human, "cars"),
}
}
)
@pet_blp.arguments(PetSchema)
@pet_blp.response(PetSchema)
def post(self, args):
return super().post(args)
@pet_blp.route("/<int:pk>")
class PetResource(ResourceView):
model = Pet
access_checks_enabled = False
get_enabled = True
update_enabled = True
delete_enabled = True
@pet_blp.response(PetSchema)
def get(self, pk):
return super().get(pk)
@pet_blp.arguments(PetSchema)
@pet_blp.response(PetSchema)
def patch(self, args, pk):
return super().patch(args, pk)
@pet_blp.response(PetSchema)
def delete(self, pk):
return super().delete(pk)
human_blp = Blueprint("humans", "humans", url_prefix="/human")
@human_blp.route("")
class HumanCollection(CollectionView):
model = Human
list_enabled = True
create_enabled = True
@human_blp.response(HumanSchema(many=True))
def get(self):
return super().get()
@human_blp.arguments(HumanSchema)
@human_blp.response(HumanSchema)
def post(self, args):
if "not_allowed" in args:
abort(403)
return super().post(args)
@human_blp.route("/<int:pk>")
class HumanResource(ResourceView):
model = Human
update_enabled = True
get_enabled = True
@human_blp.response(HumanSchema)
def get(self, pk):
return super().get(pk)
@human_blp.arguments(HumanSchema)
@human_blp.response(HumanSchema)
def patch(self, args, pk):
return super().patch(args, pk)
pointless_blp = Blueprint(
"pointless", "pointless", url_prefix="/pointless", description="No methods allowed"
)
@pointless_blp.route("")
class PointlessCollection(CollectionView):
model = Car
@pointless_blp.route("/<int:pk>")
class PointlessResource(ResourceView):
model = Car
@human_blp.route("/car")
class CarCollection(CollectionView):
model = Car
access_checks_enabled = False
list_enabled = True
@human_blp.response(CarSchema(many=True))
def get(self):
return super().get()
def is_rel_loaded(item, attr_name):
"""Test if a relationship was prefetched."""
ins = inspect(item)
# not unloaded aka loaded aka chill
return attr_name not in ins.unloaded
```
|
{
"source": "JetChars/learn_py",
"score": 2
}
|
#### File: hello/polls/views.py
```python
from django.shortcuts import render_to_response
from django.http import HttpResponse
import os, sys, subprocess
# Create your views here.
def index(req, id):
hello = 'helloworlder'
#return HttpResponse('<h1>helloworld!</h1>')
os.system('pwd > /Users/JetChars/github/learn_py/hello/test.txt')
p = subprocess.Popen('for i in `ls`; do [[ -d $i ]]&&echo $i;done', stdout=subprocess.PIPE, shell=True)
(output, err) = p.communicate()
p_status = p.wait()
return render_to_response('index.html',{'hello':hello, 'tid':output, 'output':output.split()})
```
|
{
"source": "JetChars/vim",
"score": 2
}
|
#### File: libs/pylama/errors.py
```python
from collections import defaultdict
DUPLICATES = (
# multiple statements on one line
[('pep8', 'E701'), ('pylint', 'C0321')],
# unused variable
[('pylint', 'W0612'), ('pyflakes', 'W0612')],
# undefined variable
[('pylint', 'E0602'), ('pyflakes', 'E0602')],
# unused import
[('pylint', 'W0611'), ('pyflakes', 'W0611')],
# whitespace before ')'
[('pylint', 'C0326'), ('pep8', 'E202')],
# whitespace before '('
[('pylint', 'C0326'), ('pep8', 'E211')],
# multiple spaces after operator
[('pylint', 'C0326'), ('pep8', 'E222')],
# missing whitespace around operator
[('pylint', 'C0326'), ('pep8', 'E225')],
# unexpected spaces
[('pylint', 'C0326'), ('pep8', 'E251')],
# long lines
[('pylint', 'C0301'), ('pep8', 'E501')],
# statement ends with a semicolon
[('pylint', 'W0301'), ('pep8', 'E703')],
# multiple statements on one line
[('pylint', 'C0321'), ('pep8', 'E702')],
# bad indentation
[('pylint', 'W0311'), ('pep8', 'E111')],
# wildcart import
[('pylint', 'W00401'), ('pyflakes', 'W0401')],
# module docstring
[('pep257', 'D100'), ('pylint', 'C0111')],
)
DUPLICATES = dict((key, values) for values in DUPLICATES for key in values)
def remove_duplicates(errors):
""" Filter duplicates from given error's list. """
passed = defaultdict(list)
for error in errors:
key = error.linter, error.number
if key in DUPLICATES:
if key in passed[error.lnum]:
continue
passed[error.lnum] = DUPLICATES[key]
yield error
class Error(object):
""" Store an error's information. """
def __init__(self, linter="", col=1, lnum=1, type="E",
text="unknown error", filename="", **kwargs):
""" Init error information with default values. """
text = ' '.join(str(text).strip().split('\n'))
if linter:
text = "%s [%s]" % (text, linter)
number = text.split(' ', 1)[0]
self._info = dict(linter=linter, col=col, lnum=lnum, type=type[:1],
text=text, filename=filename, number=number)
def __getattr__(self, name):
return self._info[name]
def __getitem__(self, name):
return self._info[name]
def get(self, name, default=None):
""" Implement dictionary `get` method. """
return self._info.get(name, default)
def __repr__(self):
return "<Error: %s %s>" % (self.number, self.linter)
# pylama:ignore=W0622,D,R0924
```
#### File: lint/pylama_pylint/main.py
```python
from os import path as op, environ
import logging
from pylama.lint import Linter as BaseLinter
CURDIR = op.abspath(op.dirname(__file__))
from astroid import MANAGER
from pylint.lint import Run
from pylint.reporters import BaseReporter
HOME_RCFILE = op.abspath(op.join(environ.get('HOME', ''), '.pylintrc'))
LAMA_RCFILE = op.abspath(op.join(CURDIR, 'pylint.rc'))
logger = logging.getLogger('pylama')
class Linter(BaseLinter):
""" Check code with pylint. """
@staticmethod
def run(path, code, params=None, ignore=None, select=None, **meta):
""" Pylint code checking.
:return list: List of errors.
"""
logger.debug('Start pylint')
MANAGER.astroid_cache.clear()
class Reporter(BaseReporter):
def __init__(self):
self.errors = []
super(Reporter, self).__init__()
def _display(self, layout):
pass
def add_message(self, msg_id, location, msg):
_, _, line, col = location[1:]
self.errors.append(dict(
lnum=line,
col=col,
text="%s %s" % (msg_id, msg),
type=msg_id[0]
))
params = _Params(ignore=ignore, select=select, params=params)
logger.debug(params)
runner = Run(
[path] + params.to_attrs(), reporter=Reporter(), exit=False)
return runner.linter.reporter.errors
class _Params(object):
""" Store pylint params. """
def __init__(self, select=None, ignore=None, params=None):
params = dict(params.items())
rcfile = params.get('rcfile', LAMA_RCFILE)
enable = params.get('enable', None)
disable = params.get('disable', None)
if op.exists(HOME_RCFILE):
rcfile = HOME_RCFILE
if select:
enable = select | set(enable.split(",") if enable else [])
if ignore:
disable = ignore | set(disable.split(",") if disable else [])
params.update(dict(
report=params.get('report', False), rcfile=rcfile,
enable=enable, disable=disable))
self.params = dict(
(name.replace('_', '-'), self.prepare_value(value))
for name, value in params.items() if value is not None)
@staticmethod
def prepare_value(value):
""" Prepare value to pylint. """
if isinstance(value, (list, tuple, set)):
return ",".join(value)
if isinstance(value, bool):
return "y" if value else "n"
return str(value)
def to_attrs(self):
""" Convert to argument list. """
return ["--%s=%s" % item for item in self.params.items()]
def __str__(self):
return " ".join(self.to_attrs())
def __repr__(self):
return "<Pylint %s>" % self
# pylama:ignore=W0403
```
|
{
"source": "jetchirag/backops",
"score": 2
}
|
#### File: backups_operator/servers/views.py
```python
from django.shortcuts import render
from django.http import HttpResponse
from backups_operator.servers.models import Server
# Create your views here.
def home(request):
servers = Server.objects.all()
data = {
'servers': servers
}
return render(request, 'sources/home.html', data)
def test(request):
return HttpResponse('test')
def manage(request, id):
return HttpResponse('test')
def authHome(request):
return HttpResponse('test')
```
|
{
"source": "jetd1/Normal-Assisted-Stereo",
"score": 2
}
|
#### File: Normal-Assisted-Stereo/models/MVDNet.py
```python
import torch
import torch.nn as nn
import torch.utils.data
from torch.autograd import Variable
import torch.nn.functional as F
from models.submodule import *
from inverse_warp import inverse_warp, pixel2cam
import matplotlib.pyplot as plt
def convtext(in_planes, out_planes, kernel_size = 3, stride = 1, dilation = 1):
return nn.Sequential(
nn.Conv2d(in_planes, out_planes, kernel_size = kernel_size, stride = stride, dilation = dilation, padding = ((kernel_size - 1) * dilation) // 2, bias = False),
nn.LeakyReLU(0.1,inplace=True)
)
class MVDNet(nn.Module):
def __init__(self, nlabel, mindepth, no_pool = False):
super(MVDNet, self).__init__()
self.nlabel = nlabel
self.mindepth = mindepth
self.no_pool = no_pool
self.feature_extraction = feature_extraction()
self.convs = nn.Sequential(
convtext(33, 128, 3, 1, 1),
convtext(128, 128, 3, 1, 2),
convtext(128, 128, 3, 1, 4),
convtext(128, 96, 3, 1, 8),
convtext(96, 64, 3, 1, 16),
convtext(64, 32, 3, 1, 1),
convtext(32, 1, 3, 1, 1)
)
self.dres0 = nn.Sequential(convbn_3d(64, 32, 3, 1, 1),
nn.ReLU(inplace=True),
convbn_3d(32, 32, 3, 1, 1),
nn.ReLU(inplace=True))
self.dres1 = nn.Sequential(convbn_3d(32, 32, 3, 1, 1),
nn.ReLU(inplace=True),
convbn_3d(32, 32, 3, 1, 1))
self.dres2 = nn.Sequential(convbn_3d(32, 32, 3, 1, 1),
nn.ReLU(inplace=True),
convbn_3d(32, 32, 3, 1, 1))
self.dres3 = nn.Sequential(convbn_3d(32, 32, 3, 1, 1),
nn.ReLU(inplace=True),
convbn_3d(32, 32, 3, 1, 1))
self.dres4 = nn.Sequential(convbn_3d(32, 32, 3, 1, 1),
nn.ReLU(inplace=True),
convbn_3d(32, 32, 3, 1, 1))
self.classify = nn.Sequential(convbn_3d(32, 32, 3, 1, 1),
nn.ReLU(inplace=True),
nn.Conv3d(32, 1, kernel_size=3, padding=1, stride=1,bias=False))
self.softmax = nn.Softmax(dim = -1)
self.wc0 = nn.Sequential(convbn_3d(64 + 3, 32, 3, 1, 1),
nn.ReLU(inplace=True),
convbn_3d(32, 32, 3, 1, 1),
nn.ReLU(inplace=True))
self.pool1 = nn.Sequential(convbn_3d(32, 32, (2,3,3), (2,1,1), (0,1,1)),
nn.ReLU(inplace=True))
self.pool2 = nn.Sequential(convbn_3d(32, 32, (2,3,3), (2,1,1), (0,1,1)),
nn.ReLU(inplace=True))
self.pool3 = nn.Sequential(convbn_3d(32, 32, (2,3,3), (2,1,1), (0,1,1)),
nn.ReLU(inplace=True))
self.n_convs = nn.Sequential(
convtext(32, 96, 3, 1, 1),
convtext(96, 96, 3, 1, 2),
convtext(96, 96, 3, 1, 4),
convtext(96, 64, 3, 1, 8),
convtext(64, 64, 3, 1, 16),
convtext(64, 32, 3, 1, 1),
convtext(32, 3, 3, 1, 1)
)
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d) or isinstance(m, nn.Linear) or isinstance(m, nn.Conv3d):
nn.init.xavier_uniform_(m.weight.data)
if m.bias is not None:
m.bias.data.zero_()
elif isinstance(m, nn.BatchNorm2d) or isinstance(m, nn.BatchNorm3d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def forward(self, ref, targets, pose, intrinsics, intrinsics_inv, factor = None):
intrinsics4 = intrinsics.clone()
intrinsics_inv4 = intrinsics_inv.clone()
intrinsics4[:,:2,:] = intrinsics4[:,:2,:] / 4
intrinsics_inv4[:,:2,:2] = intrinsics_inv4[:,:2,:2] * 4
refimg_fea = self.feature_extraction(ref)
_b,_ch,_h,_w = refimg_fea.size()
disp2depth = Variable(torch.ones(_b, _h, _w)).cuda() * self.mindepth * self.nlabel
disps = Variable(torch.linspace(0,self.nlabel-1,self.nlabel).view(1,self.nlabel,1,1).expand(_b,self.nlabel,_h,_w)).type_as(disp2depth)
depth = disp2depth.unsqueeze(1)/(disps + 1e-16)
if factor is not None:
depth = depth*factor
for j, target in enumerate(targets):
cost = Variable(torch.FloatTensor(refimg_fea.size()[0], refimg_fea.size()[1]*2, self.nlabel, refimg_fea.size()[2], refimg_fea.size()[3]).zero_()).cuda()
targetimg_fea = self.feature_extraction(target)
targetimg_fea = inverse_warp(targetimg_fea, depth, pose[:,j], intrinsics4, intrinsics_inv4)
cost[:, :refimg_fea.size()[1],:,:,:] = refimg_fea.unsqueeze(2).expand(_b,_ch,self.nlabel,_h,_w)
cost[:, refimg_fea.size()[1]:,:,:,:] = targetimg_fea.squeeze(-1)
cost = cost.contiguous()
cost0 = self.dres0(cost)
cost_in0 = cost0.clone()
cost0 = self.dres1(cost0) + cost0
cost0 = self.dres2(cost0) + cost0
cost0 = self.dres3(cost0) + cost0
cost0 = self.dres4(cost0) + cost0
cost_in0 = torch.cat((cost_in0, cost0.clone()), dim = 1)
cost0 = self.classify(cost0)
if j == 0:
costs = cost0
cost_in = cost_in0
else:
costs = costs + cost0
cost_in = cost_in + cost_in0
costs = costs/len(targets)
costss = Variable(torch.FloatTensor(refimg_fea.size()[0], 1, self.nlabel, refimg_fea.size()[2], refimg_fea.size()[3]).zero_()).cuda()
for i in range(self.nlabel):
costt = costs[:, :, i, :, :]
costss[:, :, i, :, :] = self.convs(torch.cat([refimg_fea, costt],1)) + costt
costs = F.interpolate(costs, [self.nlabel,ref.size()[2],ref.size()[3]], mode='trilinear', align_corners = False)
costs = torch.squeeze(costs,1)
pred0 = F.softmax(costs,dim=1)
pred0_r = pred0.clone()
pred0 = disparityregression(self.nlabel)(pred0)
depth0 = self.mindepth*self.nlabel/(pred0.unsqueeze(1)+1e-16)
costss = F.interpolate(costss, [self.nlabel,ref.size()[2],ref.size()[3]], mode='trilinear', align_corners = False)
costss = torch.squeeze(costss,1)
pred = F.softmax(costss,dim=1)
pred = disparityregression(self.nlabel)(pred)
depth1 = self.mindepth*self.nlabel/(pred.unsqueeze(1)+1e-16)
b,ch,d,h,w = cost_in.size()
with torch.no_grad():
intrinsics_inv[:,:2,:2] = intrinsics_inv[:,:2,:2] * (4)
disp2depth = Variable(torch.ones(b, h, w).cuda() * self.mindepth * self.nlabel).cuda()
disps = Variable(torch.linspace(0,self.nlabel-1,self.nlabel).view(1,self.nlabel,1,1).expand(b,self.nlabel,h,w)).type_as(disp2depth)
depth = disp2depth.unsqueeze(1)/(disps + 1e-16)
if factor is not None:
depth = depth*factor
wc = pixel2cam(depth, intrinsics_inv)
wc = wc.squeeze(-1)
if factor is not None:
wc = wc/(2*self.nlabel*self.mindepth*factor.unsqueeze(-1))
else:
wc = wc/(2*self.nlabel*self.mindepth)
wc = wc.clamp(-1,1)
wc = torch.cat((wc.clone(),cost_in), dim = 1) #B,ch+3,D,H,W
wc = wc.contiguous()
if self.no_pool:
wc0 = self.pool1(self.wc0(wc))
else:
wc0 = self.pool3(self.pool2(self.pool1(self.wc0(wc))))
slices = []
nmap = torch.zeros((b,3,h,w)).type_as(wc0)
for i in range(wc0.size(2)):
slices.append(self.n_convs(wc0[:,:,i]))
nmap += slices[-1]
nmap_norm = torch.norm(nmap, dim = 1).unsqueeze(1)
nmap = F.interpolate(nmap, [ref.size(2), ref.size(3)], mode = 'bilinear', align_corners = False)
nmap = nmap.permute(0,2,3,1)
nmap = F.normalize(nmap,dim = -1)
return_vals = []
if self.training:
return_vals += [depth0, depth1]
else:
return_vals += [depth1]
return_vals += [nmap]
return return_vals
```
|
{
"source": "JetDeveloping/summer-code-jam-2020-qualifier",
"score": 3
}
|
#### File: JetDeveloping/summer-code-jam-2020-qualifier/qualifier.py
```python
import datetime
import typing
import re #For splitting strings
import collections #For sorting
import itertools #For sequential IDs
import random
typo;
class ArticleField:
"""The `ArticleField` class for the Advanced Requirements."""
def __init__(self, field_type: typing.Type[typing.Any]):
pass
class Article:
"""The `Article` class you need to write for the qualifier."""
unique_id = itertools.count(0) #Create an Iterable List of Objects
def __init__(self, title: str, author: str, publication_date: datetime.datetime, content: str):
#Initialize variables
self.id = next(self.unique_id) #Create the Unique ID
#Define the Article's Attributes (based on the args)
self.title = title
self.author = author
self.publication_date = publication_date
self._content = content
#Create the ISO Datetime String
self.iso_datetime = self.publication_date.isoformat()
self.last_edited = None
self.compare_datetime = self.publication_date.timestamp()
def __repr__(self): #Repr Function to return a specific format
'''
Format:
<Article title="Title" author='Author' publication_date='ISOTimeStamp'>
'''
return '<Article title="{self.title}" author=\'{self.author}\' publication_date=\'{self.iso_datetime}\'>'.format(self=self) #Returns our text (using format())
def __len__(self): #Len function to return the length of content
return len(self._content)
def short_introduction(self, n_characters): #Function to return a short introduction
cut_string = self._content[:n_characters + 1] #Cut the original string based on our original number (n_characters)
last_space = cut_string.rindex(' ') #Gets the index of the last space
try: #Check to see if there is a line break
last_line_break = cut_string.rindex('\n')
except:
last_line_break = 0
#Checks whether the space is located further towards the end or if the line break is
if last_space > last_line_break:
last_char = last_space
else:
last_char = last_line_break
return self._content[:last_char] #Cuts the content based on where the last space or linebreak was
def most_common_words(self, num): #Function to return a dictionary of the most common words
char_list = self.clear_list(self._content) #Splits the article content into list based on special characters that it finds
return dict(collections.Counter(char_list).most_common(num)) #Returns a dictionary of the most common words
''' @property
def content(self):
return self.content
@content.setter
def content(self, new_value):
self.content = new_value
self.last_edited = datetime.datetime.now()'''
@property
def content(self):
return self._content
@content.setter
def content(self, new_content):
self._content = new_content
self.last_edited = datetime.datetime.now()
def __eq__(self, other_article):
if self.compare_datetime == other_article.compare_datetime:
return True
else:
return False
def __gt__(self, other_article):
if self.compare_datetime > other_article.compare_datetime:
return True
else:
return False
x = Article(
title = "The emperor's new clothes",
author = "<NAME>",
content = "'But he has nothing at all on!' at last cried out all the people.",
publication_date = datetime.datetime(1837, random.randint(1, 12), random.randint(1, 7), 12, 15, 0)
)
y = Article(
title = "The emperor's new clothes",
author = "<NAME>",
content = "'But he has nothing at all on!' at last cried out all the people.",
publication_date = datetime.datetime(1837, random.randint(1, 12), random.randint(1, 7), 12, 15, 0)
)
```
|
{
"source": "jet-dev-team/drupal-dockerizer-cli",
"score": 2
}
|
#### File: drupal-dockerizer-cli/drupal_dockerizer/dockerizer_config.py
```python
import os
from pathlib import Path
import yaml
CONFIG_NAME = "config.yml"
CONFIG_NOT_FOUND_MESSAGE = (
"Can`t find config. Please ensure that config exist in project."
)
def findConfigPath(current_dir: Path) -> str:
config_path = str(current_dir.joinpath(CONFIG_NAME))
if not os.path.exists(config_path):
folder = current_dir.parent
for i in range(len(folder.parts) + 1):
if os.path.exists(folder.joinpath(CONFIG_NAME)):
config_path = str(folder.joinpath(CONFIG_NAME))
break
folder = folder.parent
if not os.path.exists(config_path):
raise FileNotFoundError(CONFIG_NOT_FOUND_MESSAGE)
return config_path
class DockerizerConfig:
data = {
"user_uid": 1000,
"user_gid": 1000,
"compose_project_name": "drupal-project",
"docker_runtime_dir": "drupal-project",
"drupal_root_dir": "",
"drupal_web_root": "",
"drupal_files_dir": "",
"advanced_networking": False,
"network_id": 2,
"domain_name": "drupal-project.devel",
"xdebug_enviroment": "",
"solr": 4,
"solr": False,
"solr_version": 4,
"solr_configs_path": "",
"memcache": False,
"install_adminer": False,
"drush_commands": ["cc drush", "si --account-pass=admin --site-name='Drupal Dockerizer'", "cr"],
"drush_version": 8,
"phpversion": "7.4-develop",
"ssl_cert_path": "",
"ssl_key_path": "",
"ssl_enabled": False,
"custom_drupal_settings": """if (file_exists($app_root . '/' . $site_path . '/settings.local.php')) {
include $app_root . '/' . $site_path . '/settings.local.php';
}
""",
}
def __init__(self, current_dir, config_file_path=False, load=True) -> None:
self.current_dir = current_dir
if config_file_path:
self.config_file_path = config_file_path
if load:
if os.path.exists(self.config_file_path):
self.load(config_file_path=self.config_file_path)
else:
raise FileNotFoundError(CONFIG_NOT_FOUND_MESSAGE)
def save(self) -> None:
file_config = open(self.config_file_path, "w")
yaml.safe_dump(self.data, file_config, sort_keys=True)
file_config.close()
def load(self, config_file_path=False) -> None:
if not config_file_path:
self.config_file_path = findConfigPath(self.current_dir)
else:
self.config_file_path = config_file_path
if not os.path.exists(self.config_file_path):
raise FileNotFoundError(CONFIG_NOT_FOUND_MESSAGE)
file_config = open(self.config_file_path, "r")
self.data = dict(yaml.full_load(file_config))
file_config.close()
```
|
{
"source": "jetdillo/Sawppy_Rover",
"score": 2
}
|
#### File: tenacity_ros/scripts/dynamixel_joint_publish_exercise.py
```python
import rospy
import time
from control_msgs.msg import FollowJointTrajectoryFeedback
from std_msgs.msg import Float64
from geometry_msgs.msg import Twist
from sensor_msgs.msg import Joy,JointState
from trajectory_msgs.msg import JointTrajectory
#subscribes to /cmd_vel and processes angular_vel data out to dynamixels for corner steering.
steer_min=102
steer_max=915
steering_joints=[]
steering_positions=[]
steer_vel=0.0
def cmdvel_cb(data):
t = Twist()
t.angular.z = data.angular.z
#Magic happens here.
#Get Joint states from JointStatePublisher
#publish_steering(steer_angle)
#def publish_steering(data):
#
# #Publish steer_angle to the front servos
# #Publish the mirror of steer_angle to the rear ones
#
def steering_state_cb(data):
steering_joints=data.joint_names
steering_positions=data.actual.positions
#steer_min=data.dynamixel_msg.min
#steer_max=data.dynamixel_msg.max
def motor_state_cb(data):
print(data.name)
#def twist_to_radian(zdata):
#
# #if zdata >=0:
#
# if zdata < 0:
# Intializes everything
def start():
rospy.init_node('corner_steering')
steer_controllers=['front_left','front_right','rear_left','rear_right']
rospy.Subscriber("/cmd_vel",Twist,cmdvel_cb)
rospy.Subscriber("/f_arm_controller/state",FollowJointTrajectoryFeedback,steering_state_cb)
steering_state_publisher=rospy.Publisher('/f_arm_controller/command',JointTrajectory,queue_size=10)
#right_rear_sp=rospy.Publisher('rear_right_controller/command',Float64,queue_size=10)
exercise_positions=[0.0,0.785,1.5757,0.0,-0.785,-1.5757,0.0]
for e in exercise_positions:
jt=JointTrajectory()
for j in range(0,(len(steering_joints))):
print e
jt.names[j]=steering_joints[j]
jt.positions[j]=e
steering_state_publisher.publish(jt)
time.sleep(1)
# subscribe to Dynamixel channel to get list of servos
# There should be 4 IDs: 1,2,5,6
# We need to error out of there are less or if the IDs are different
# Is there a way to verify a topic exists ?
if __name__ == '__main__':
start()
```
|
{
"source": "jetedonner/ch.kimhauser.python.remac",
"score": 2
}
|
#### File: server/libs/reMac_libserver.py
```python
import sys
from apps.server.modules import mod_clipboard, mod_keylogger, mod_hello, mod_chrome_logins
from apps.server.modules import mod_chrome_history
from apps.server.modules import mod_shellcmd
from apps.server.modules import mod_screenshot
from apps.server.modules import mod_webcam
from apps.server.modules import mod_recmic
from apps.server.modules import mod_modHelp
from apps.server.modules import mod_info
from apps.libs.reMac_libbase import reMac_libbase
reMacModules = {
'hw': [mod_hello.mod_hello(), 'helloworld', 'Call HelloWorld module', 'hw'],
'cb': [mod_clipboard.mod_clipboard(), 'clipboard', 'Call clipboard module', 'cb'],
'ch': [mod_chrome_history.mod_chrome_history(), 'chromehist', 'Call Chrome-History module', 'ch'],
'cl': [mod_chrome_logins.mod_chrome_logins(), 'chromelogin', 'Call Chrome-Logins module', 'cl'],
'sh': [mod_shellcmd.mod_shellcmd(), 'shellcmd', 'Call shell command module', 'sh <cmd to send>'],
'sc': [mod_screenshot.mod_screenshot(), 'screenshot', 'Call screenshot module', 'sc'],
'wc': [mod_webcam.mod_webcam(), 'webcam', 'Call webcam module', 'wc'],
'kl': [mod_keylogger.mod_keylogger(), 'keylogger', 'Call keylogger module', 'kl'],
'rm': [mod_recmic.mod_recmic(), 'recmic', 'Call record microphone module', 'rm <seconds to record>'],
'mh': [mod_modHelp.mod_modHelp(), 'modHelp', 'Call server modules help module', 'mh <module>'],
'in': [mod_info.mod_info(), 'info', 'Call info module', 'in']
}
class reMac_libserver(reMac_libbase):
def __init__(self, selector, sock, addr):
reMac_libbase.__init__(self, selector, sock, addr)
self._recv_buffer = b""
self._send_buffer = b""
self._jsonheader_len = None
self.jsonheader = None
self.request = None
self.response_created = False
def _read(self):
try:
# Should be ready to read
data = self.sock.recv(4096)
except BlockingIOError:
# Resource temporarily unavailable (errno EWOULDBLOCK)
pass
else:
if data:
self._recv_buffer += data
else:
raise RuntimeError("Peer closed.")
def _write(self):
if self._send_buffer:
# print("sending", repr(self._send_buffer), "to", self.addr)
try:
# Should be ready to write
sent = self.sock.send(self._send_buffer)
except BlockingIOError:
# Resource temporarily unavailable (errno EWOULDBLOCK)
pass
else:
self._send_buffer = self._send_buffer[sent:]
# Close when the buffer is drained. The response has been sent.
if sent and not self._send_buffer:
self.close()
def processInput(self, input):
if input == "q": # or input == "quit":
sys.exit(1)
elif input == "h": # or input == "help":
# print_help()
pass
elif input == "hw" \
or input == "cb" \
or input == "ch" \
or input == "cl" \
or input == "sh" \
or input == "sc" \
or input == "wc" \
or input.startswith("rm") \
or input == "in" \
or input == "d": # or input == "help":
return reMacModules[input][0].run_mod()
elif input.startswith("mh"):
return reMacModules["mh"][0].print_client_help("reMac", reMacModules, input)
else:
print(f"Command '{input}' NOT FOUND! Check the following command list")
# print_help()
def _create_response_json_content(self):
action = self.request.get("action")
if action == "hw" \
or action == "cb" \
or action == "ch" \
or action == "cl" \
or action == "sh" \
or action == "sc" \
or action == "wc" \
or action == "rm" \
or action == "in" \
or action.startswith("mh"):
answer = self.processInput(action)
content = {"action": action, "result": answer}
else:
content = {"action": action, "result": f'Error: invalid action "{action}".'}
content_encoding = "utf-8"
response = {
"content_bytes": self._json_encode(content, content_encoding),
"content_type": "text/json",
"content_encoding": content_encoding,
}
return response
def _create_response_binary_content(self):
response = {
"content_bytes": b"First 10 bytes of request: "
+ self.request[:10],
"content_type": "binary/custom-server-binary-type",
"content_encoding": "binary",
}
return response
def read(self):
self._read()
if self._jsonheader_len is None:
self.process_protoheader()
if self._jsonheader_len is not None:
if self.jsonheader is None:
self.process_jsonheader()
if self.jsonheader:
if self.request is None:
self.process_request()
def write(self):
if self.request:
if not self.response_created:
self.create_response()
self._write()
def process_request(self):
content_len = self.jsonheader["content-length"]
if not len(self._recv_buffer) >= content_len:
return
data = self._recv_buffer[:content_len]
self._recv_buffer = self._recv_buffer[content_len:]
if self.jsonheader["content-type"] == "text/json":
encoding = self.jsonheader["content-encoding"]
self.request = self._json_decode(data, encoding)
print("received request", repr(self.request), "from", self.addr)
else:
# Binary or unknown content-type
self.request = data
print(
f'received {self.jsonheader["content-type"]} request from',
self.addr,
)
# Set selector to listen for write events, we're done reading.
self._set_selector_events_mask("w")
def create_response(self):
if self.jsonheader["content-type"] == "text/json":
response = self._create_response_json_content()
else:
# Binary or unknown content-type
response = self._create_response_binary_content()
message = self._create_message(**response)
self.response_created = True
self._send_buffer += message
```
#### File: server/modules/mod_info.py
```python
import platform
import socket
from apps.server.modules.mod_interfaceRunCmd import mod_interfaceRunCmd
class mod_info(mod_interfaceRunCmd):
def setup_mod(self):
print(f'Module Setup (mod_info) called successfully!')
def run_mod(self, cmd = ""):
print(f'Info Module')
hostname = socket.gethostname()
local_ip = socket.gethostbyname(hostname)
sRet = f'#========================================================================#\n'
sRet += f'| Info for server - IP: {local_ip}\n'
sRet += f"| System: " + self.get_model()
sRet += f"| macOS version: " + self.get_macVer() + "\n"
sRet += f"| WiFi: \n" + self.get_wifi()
sRet += f" Battery: " + self.get_battery()
sRet += f'#========================================================================#\n'
return sRet
def get_macVer(self):
return str(platform.mac_ver()[0])
def get_model(self):
return self.run_command("sysctl -n hw.model")#.decode('utf-8')
def get_wifi(self):
command = "/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -I" # | grep -w SSID"
sRet = self.run_command(command).replace("\n", "\n|")
return "|" + sRet #self.run_command(command)#.decode('utf-8')#.replace("SSID: ", "").strip()
def get_battery(self):
sRet = self.run_command("pmset -g batt").replace("\n", "\n|")
return sRet #.decode("utf-8")# | egrep \"([0-9]+\\%).*\" -o | cut -f1 -d\';\'")
```
#### File: server/modules/mod_shellcmd.py
```python
import subprocess
from apps.server.modules.mod_interface import mod_interface
EXIT_CMD = "exit"
class mod_shellcmd(mod_interface):
def setup_mod(self):
print(f'Module Setup (mod_shellcmd) called successfully!')
pass
def run_mod(self, cmd = ""):
answer = ""
while True:
cmd2send = input("$:")
#print(f'Sending command: "{cmd2send}" to shell ...')
try:
args = cmd2send.split(" ")
if args[0] == EXIT_CMD:
break
answer = subprocess.check_output(cmd2send, shell=True)
print(answer.decode("utf-8"))
except subprocess.CalledProcessError:
answer = f'Error sending comand "{cmd2send}" to shell!'
return answer
```
#### File: apps/server/reMac_server.py
```python
import socket
import selectors
import traceback
import sys
# import keyboard
from pynput import keyboard
from apps.server.libs import reMac_libserver
# conHost = "192.168.0.49"
conHost = "127.0.0.1"
conPort = "6890"
sel = selectors.DefaultSelector()
class reMac_server():
global doExit
doExit = False
def __init__(self):
self.setup_server()
def setup_server(self):
print(f'Server setup successfully!')
def accept_connection(self, sock):
conn, addr = sock.accept() # Should be ready to read
print("accepted connection from", addr)
conn.setblocking(False)
message = reMac_libserver.reMac_libserver(sel, conn, addr)
sel.register(conn, selectors.EVENT_READ, data=message)
def on_press(self, key):
if key.char == None:
return
if key == keyboard.Key.esc or key.char == 'q':
# Stop listener
self.doExit = True
# message.close()
# sel.close()
sys.exit(1)
# return False
# else:
# _start()
# Collect events until released
def start_server(self, myHost = conHost, myPort = conPort):
host, port = myHost, int(myPort)
lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Avoid bind() exception: OSError: [Errno 48] Address already in use
lsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
lsock.bind((host, port))
lsock.listen()
print("reMac Server started successfully - Listening on:", (host, port))
lsock.setblocking(False)
sel.register(lsock, selectors.EVENT_READ, data=None)
# with keyboard.Listener(on_press=self.on_press) as listener:
# listener.join()
try:
while True:
# if self.doExit:
# break
events = sel.select(timeout=None)
for key, mask in events:
if key.data is None:
self.accept_connection(key.fileobj)
else:
message = key.data
try:
message.process_events(mask)
except Exception:
print(
"main: error: exception for",
f"{message.addr}:\n{traceback.format_exc()}",
)
message.close()
except KeyboardInterrupt:
print("caught keyboard interrupt, exiting")
finally:
sel.close()
# a = [1, 2, 3, 4]
# print("Press Enter to continue or press Esc to exit: ")
# while True:
# try:
# if keyboard.is_pressed('ENTER'):
# print("you pressed Enter, so printing the list..")
# print(a)
# break
# if keyboard.is_pressed('Esc'):
# print("\nyou pressed Esc, so exiting...")
# sys.exit(0)
# except:
# break
```
#### File: jetedonner/ch.kimhauser.python.remac/devHelperMain.py
```python
import sys
from apps.server import reMac_server
from apps.client import reMac_client
from apps.server.modules import mod_clipboard, mod_keylogger, mod_hello, mod_chrome_logins, mod_recmic, \
mod_chrome_history, mod_webcam, mod_shellcmd, mod_info, mod_modHelp, mod_screenshot
myreMac_server = reMac_server.reMac_server()
myreMac_client = reMac_client.reMac_client()
reMacModules = {
'hw': [mod_hello.mod_hello(), 'helloworld', 'Call HelloWorld module', 'hw'],
'cb': [mod_clipboard.mod_clipboard(), 'clipboard', 'Call clipboard module', 'cb'],
'ch': [mod_chrome_history.mod_chrome_history(), 'chromehist', 'Call Chrome-History module', 'ch'],
'cl': [mod_chrome_logins.mod_chrome_logins(), 'chromelogin', 'Call Chrome-Logins module', 'cl'],
'sh': [mod_shellcmd.mod_shellcmd(), 'shellcmd', 'Call shell command module', 'sh <cmd to send>'],
'sc': [mod_screenshot.mod_screenshot(), 'screenshot', 'Call screenshot module', 'sc'],
'wc': [mod_webcam.mod_webcam(), 'webcam', 'Call webcam module', 'wc'],
'kl': [mod_keylogger.mod_keylogger(), 'keylogger', 'Call keylogger module', 'kl'],
'rm': [mod_recmic.mod_recmic(), 'recmic', 'Call record microphone module', 'rm <seconds to record>'],
'mh': [mod_modHelp.mod_modHelp(), 'modHelp', 'Call server modules help module', 'mh <module>'],
'in': [mod_info.mod_info(), 'info', 'Call info module', 'in']#,
#'in': [mod_info.mod_info(), 'info', 'Call info module', 'in']
}
authorName = "JeteDonner"
appVer = "0.0.1"
appName = "reMac"
appDesc = "Remote administration and surveillance for macOS - With Python"
appDate = "2021-08-18"
conHost = "192.168.0.49"
conPort = "6890"
# clientStarted = False
def print_client_help():
print(f'#========================================================================#')
print(f'| {appName} - Client Command-Help:')
# print(f'| Created by: {authorName}, v.{appVer} {appDate}')
for keyTmp in list(reMacModules):
altCmd = reMacModules[keyTmp]
print(f'| -{keyTmp} / {altCmd[1]}: {altCmd[2]}')
print(f'#========================================================================#')
def print_help():
print(f'#========================================================================#')
print(f'| {appName} - {appDesc} |')
print(f'| Created by: {authorName}, v.{appVer} {appDate} |')
print(f'| |')
print(f'| Script usage / parameters: |')
print(f'| -help, -h\t\t\tDisplay this help text |')
print(f'| -server, -s\t\tStart the server |')
print(f'| -client, -c\t\tStart the server |')
print(f'| -dev, -d\t\t\tStart developer mode |')
print(f'#========================================================================#')
#global clientStarted
clientStarted = False
def processInput(input):
global clientStarted
if clientStarted == True and not input == "c" and not input == "s":
myreMac_client.send2_client(input)
return
inp_args = input.split(" ")
if len(inp_args) > 1:
if inp_args[0] == "s":
if len(inp_args) == 3:
myreMac_server.start_server(inp_args[1], inp_args[2])
return
elif inp_args[0] == "c":
if len(inp_args) == 3:
myreMac_client.start_client(inp_args[1], inp_args[2])
return
if input == "q":
sys.exit(1)
elif input == "h":
print_help()
elif input == "hw":
reMacModules[input][0].run_mod()
elif input == "s":
myreMac_server.start_server()
elif input == "hh":
print_client_help()
elif input == "c":
myreMac_client.start_client()
clientStarted = True
elif input == "kl":
reMacModules[input][0].run_mod()
elif input == "cb":
if clientStarted == True:
myreMac_client.send2_client("cb")
else:
reMacModules[input][0].run_mod()
elif input == "ch":
if clientStarted == True:
myreMac_client.send2_client(input)
else:
reMacModules[input][0].run_mod()
elif input == "in":
if clientStarted == True:
myreMac_client.send2_client(input)
else:
reMacModules[input][0].run_mod()
elif input == "cl":
reMacModules[input][0].run_mod()
elif input == "sh":
reMacModules[input][0].run_mod()
elif input == "sc":
if clientStarted == True:
myreMac_client.send2_client(input)
else:
reMacModules[input][0].run_mod()
elif input == "wc":
if clientStarted == True:
myreMac_client.send2_client(input)
else:
reMacModules[input][0].run_mod()
elif input == "rm":
if clientStarted == True:
myreMac_client.send2_client(input)
else:
reMacModules["mh"][0].print_client_help(appName, reMacModules, input)
elif input.startswith("mh"):
if clientStarted == True:
myreMac_client.send2_client(input)
else:
reMacModules["mh"][0].print_client_help(appName, reMacModules, input)
elif input == "d" or input == "dev":
reMacModules['sc'][0].run_mod()
else:
print(f"Command '{input}' NOT FOUND! Check the following command list")
print_help()
def enterWaitForInput(argv):
while True:
c = input("Select your option and press enter:")
processInput(c.lower())
if __name__ == "__main__":
if len(sys.argv) == 1:
print_help()
enterWaitForInput(sys.argv)
```
#### File: jetedonner/ch.kimhauser.python.remac/main.py
```python
import sys, getopt
import os
authorName = "JeteDonner"
appVersion = "0.0.1"
appDate = "2021-08-17"
conHost = "192.168.0.49"
conPort = "6890"
def print_hi(name):
print(f'Hi, {name}')
def print_help():
print(f'Client-Server python script by {authorName}\nVersion: {appVersion}, {appDate}\n')
print(f'Usage: ')
print(f'-help, -h\t\t\tDisplay this help text')
print(f'-server, -s\t\tStart the server')
print(f'-client, -c\t\tStart the server')
def main(argv):
opts, args = getopt.getopt(argv,"h:s:c:")
for opt, arg in opts:
if opt == '--help':
print_help()
sys.exit()
elif opt == '-s':
host = arg[0:]
port = argv[2]
cur_dir = os.path.abspath(".")
print(f'{cur_dir}/app-server.py {host} {port}')
os.system(f'{cur_dir}/app-server.py {host} {port}')
else:
print_help()
def wait_key():
result = None
if os.name == 'nt':
import msvcrt
result = msvcrt.getch()
else:
import termios
fd = sys.stdin.fileno()
oldterm = termios.tcgetattr(fd)
newattr = termios.tcgetattr(fd)
newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO
termios.tcsetattr(fd, termios.TCSANOW, newattr)
try:
result = sys.stdin.read(1)
except IOError:
pass
finally:
termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
return result
def enterWaitForInput(argv):
while True:
c = input("Select your option and press enter:")
print(c)
if c == "q":
sys.exit(1)
break
elif c == "c":
print(f'Staring client ... connecting to {conHost}:{conPort}')
cur_dir = os.path.abspath(".")
cmd = "clipboard"
msg = "hello"
os.system(f'{cur_dir}/app-client.py {conHost} {conPort} {cmd} {msg}')
elif c == "s":
print(f'Staring server @ {conHost}:{conPort}')
cur_dir = os.path.abspath(".")
os.system(f'{cur_dir}/app-server.py {conHost} {conPort}')
if __name__ == "__main__":
print(f'Number of arguments:', len(sys.argv), 'arguments.')
if len(sys.argv) == 1:
print_help()
enterWaitForInput(sys.argv)
else:
main(sys.argv[1:])
```
|
{
"source": "jeteokeeffe/flatpak-sync",
"score": 2
}
|
#### File: flatpak-sync/flatpaksync/main.py
```python
import click
import logging
from flatpaksync.commands.add import add as addcmd
from flatpaksync.commands.remove import remove as removecmd
from flatpaksync.commands.run import run as runcmd
from flatpaksync.commands.generate import generate as generatecmd
mylog = logging.getLogger("fps")
@click.group()
def cli():
pass
@cli.command()
@click.option('-v', '--verbose', is_flag=True, help='verbose output')
@click.option('-c', '--conf', default=".config/flatpak-sync/flatpak.json", help='configuration file')
@click.option('-d', '--dryrun', is_flag=True, help='no action performed')
def generate(conf, dryrun, verbose):
"""
Generate a configuration file from existing,installed flatpak applications
"""
cmd = generatecmd()
cmd.setConfig(conf)
cmd.setDebug(verbose)
cmd.setDryRun(dryrun)
cmd.checkFlatpak()
cmd.execute()
# Run (install/remove) applications from your configuration
@click.option('-v', '--verbose', is_flag=True)
@click.option('-c', '--conf', default=".config/flatpak-sync/flatpak.json", help='configuration file')
@click.option('-d', '--dryrun', is_flag=True, help='no action performed')
@cli.command()
def run(conf, dryrun, verbose):
"""
Run (add/remove) flatpak applications
"""
cmd = runcmd()
cmd.setConfig(conf)
cmd.setDebug(verbose)
cmd.setDryRun(dryrun)
cmd.checkFlatpak()
cmd.execute()
# Add an Application to be sync'd
@cli.command()
@click.option('-c', '--conf', default=".config/flatpak-sync/flatpak.json", help='configuration file')
@click.option('-v', '--verbose', is_flag=True)
@click.argument('repo')
@click.argument('appid')
def add(repo, appid, conf, verbose):
"""
Add a flatpak application to be managed
REPO is the flatpak repository (eg. flathub)
APPID is name of flatpak application (eg. com.gnome.meld)
"""
cmd = addcmd()
cmd.setConfig(conf)
cmd.setDebug(verbose)
#cmd.setDryRun(dryrun)
cmd.checkFlatpak()
cmd.execute(repo, appid)
# Remove an Application to be sync'd
@cli.command()
@click.option('-c', '--conf', default=".config/flatpak-sync/flatpak.json", help='configuration file')
@click.option('-v', '--verbose', is_flag=True)
@click.argument('repo')
@click.argument('appid')
def remove(repo, appid, conf, verbose):
"""
Remove a flatpak application from being managed
REPO is the flatpak repository (eg. flathub)
APPID is name of flatpak application (eg. com.gnome.meld)
"""
cmd = removecmd()
cmd.setConfig(conf)
cmd.setDebug(verbose)
#cmd.setDryRun(dryrun)
cmd.checkFlatpak()
cmd.execute(repo, appid)
#<EMAIL>()
#@<EMAIL>.option('-v', '--verbose', is_flag=True, help='verbose output')
#@<EMAIL>.option('-c', '--conf', default=".config/flatpak-sync/app.yaml", help='configuration file')
#def download(conf, verbose):
# """
# Download configuration file from remote site
#
# REPO is the flatpak repository (eg. flathub)
#
# APPID is name of flatpak application (eg. com.gnome.meld)
# """
# logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
<EMAIL>()
#@click.option('-v', '--verbose', is_flag=True, help='verbose output')
<EMAIL>.option('-c', '--conf', default=".config/flatpak-sync/app.yaml", help='configuration file')
#def upload(conf, verbose):
# """
# Upload configuration file to remote site
#
# REPO is the flatpak repository (eg. flathub)
#
# APPID is name of flatpak application (eg. com.gnome.meld)
# """
# logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
<EMAIL>()
#@<EMAIL>.option('-v', '--verbose', is_flag=True, help='verbose output')
<EMAIL>.option('-c', '--conf', default=".config/flatpak-sync/app.yaml", help='configuration file')
#def downloadrun(conf, verbose):
# """
# Download and Run configuration file from remote site (Installing Apps and Permissions)
#
# REPO is the flatpak repository (eg. flathub)
#
# APPID is name of flatpak application (eg. com.gnome.meld)
# """
def main():
cli()
```
#### File: flatpaksync/parsers/permission.py
```python
import configparser
import io
from flatpaksync.structs.permission import permission as permissiondata
from flatpaksync.structs.permissionlist import permissionlist
class permission:
def __init__(self):
self.permlist = permissionlist()
def parse(self, output: str):
buf = io.StringIO(output)
config = configparser.ConfigParser()
config.read_file(buf)
for section in config.sections():
for permname in config[section]:
#print(permname)
for val in config[section][permname].split(';'):
if len(val) > 0:
perm = permissiondata()
perm.setPermission(permname, val)
self.permlist.add(perm)
def getPermissions(self):
return self.permlist
def safetype(self, permname: str):
"""
List of permissions
'share':
'unshare':
'socket':
'nosocket':
'device':
'nodevice':
'allow':
'disallow':
'filesystem':
'nofilesystem':
'add-policy':
'remove-policy':
'env':
'own-name':
'talk-name':
'no-talk-name':
'system-own-name':
'system-talk-name':
'system-no-talk-name':
'persist':
"""
options = {
'filesystems': 'filesystem',
'filesystem': 'filesystem',
'sockets': 'socket',
'persist': 'persist',
'env': 'env',
'persist': 'persist',
}
return options.get(permname, 'invalid');
```
#### File: flatpaksync/parsers/repo.py
```python
from flatpaksync.structs.repolist import repolist
from flatpaksync.structs.repo import repo as repodata
class repo:
"""
Parse flatpak output
"""
def __init__(self):
self.repoList = repolist()
def parse(self, output: str):
name = 0
location = 1
for line in output.splitlines():
cols = line.split("\t")
myrepo = repodata(cols[name])
myrepo.setLocation(repodata.nameToLocation(cols[name]))
self.repoList.add(myrepo)
return True
def getRepoList(self):
return self.repoList
```
#### File: flatpaksync/structs/applist.py
```python
from flatpaksync.structs.app import app
class applist:
'''
Flatpak Application list
'''
def __init__(self):
self.applist = []
self.count = 0
def getAll(self):
return self.applist
def get(self, name) -> app:
return self.applist[name]
def add(self, app: app) -> bool:
if app.getAppId().endswith(".BaseApp"):
return False
self.applist.append(app)
self.count += 1
return True
def remove(self, app: app) -> bool:
for i, stored in enumerate(self.applist):
if stored.getAppId() == app.getAppId() and stored.getRepoName() == app.getRepoName():
self.applist.pop(i)
return True
def exists(self, myApp: app) -> bool:
for i, stored in enumerate(self.applist):
if stored.getAppId() == myApp.getAppId() and stored.getRepoName() == myApp.getRepoName():
return True
return False
def getCount(self) -> int:
return self.count
```
#### File: flatpaksync/structs/permissionlist.py
```python
from flatpaksync.structs.permission import permission
class permissionlist():
"""
list of flatpak permissions for a specific app
"""
def __init__(self):
self.permlist = []
self.count = 0
def getAll(self):
return self.permlist
def get(self, name: str):
return self.permlist[name]
def getCount(self) -> int:
return self.count
def add(self, perm) -> bool:
self.permlist.append(perm)
self.count = self.count + 1
return True
def exists(self, perm: permission) -> bool:
return False
```
|
{
"source": "jeteokeeffe/gtk-python-examples",
"score": 3
}
|
#### File: events/mouse/mouse-stuff.py
```python
import sys
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
class EventsTest(Gtk.Grid):
def __init__(self):
super(EventsTest, self).__init__()
btn = Gtk.Button("Top right")
btn.connect("clicked", lambda x: print("Button clicked"))
self.attach(Gtk.Label("Top left"), 0, 0, 1, 1)
self.attach(btn, 1, 0, 1, 1)
self.attach(Gtk.SpinButton(), 0, 1, 1, 1)
class MainWindow(Gtk.Window):
def __init__(self):
super(MainWindow, self).__init__()
self.connect("destroy", lambda x: Gtk.main_quit())
self.connect("button-press-event", self.on_button_pressed)
self.connect("event-after", self.on_event_after)
evtest = EventsTest()
self.add(evtest)
self.show_all()
def on_button_pressed(self, btn, event):
print("Main window button pressed")
return True
def on_event_after(self, wdg, event):
print("Event after")
def run(self):
Gtk.main()
def main(args):
mainwdw = MainWindow()
mainwdw.run()
return 0
if __name__ == '__main__':
sys.exit(main(sys.argv))
```
#### File: gtk-python-examples/window/fullscreen.py
```python
import sys
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
class AppWindow(Gtk.ApplicationWindow):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
label = Gtk.Label.new("Hello World")
self.add(label)
class Application(Gtk.Application):
def __init__(self, *args, **kwargs):
super().__init__(*args, application_id="org.example.myapp", **kwargs)
self.window = None
def do_activate(self):
if not self.window:
self.window = AppWindow(application=self, title="Main Window")
self.window.fullscreen()
self.window.present()
self.window.show_all()
app = Application()
app.run(sys.argv)
```
|
{
"source": "jeteon/python-nomad",
"score": 2
}
|
#### File: nomad/api/agent.py
```python
import nomad.api.exceptions
class Agent(object):
"""The self endpoint is used to query the state of the target agent."""
ENDPOINT = "agent"
def __init__(self, requester):
self._requester = requester
def __str__(self):
return "{0}".format(self.__dict__)
def __repr__(self):
return "{0}".format(self.__dict__)
def __getattr__(self, item):
msg = "{0} does not exist".format(item)
raise AttributeError(msg)
def _get(self, *args):
url = self._requester._endpointBuilder(Agent.ENDPOINT, *args)
agent = self._requester.get(url)
return agent.json()
def get_agent(self):
""" Query the state of the target agent.
https://www.nomadproject.io/docs/http/agent-self.html
returns: dict
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
return self._get("self")
def get_members(self):
"""Lists the known members of the gossip pool.
https://www.nomadproject.io/docs/http/agent-members.html
returns: list
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
return self._get("members")
def get_servers(self):
""" Lists the known members of the gossip pool.
https://www.nomadproject.io/docs/http/agent-servers.html
returns: list
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
return self._get("servers")
def _post(self, *args, **kwargs):
try:
url = self._requester._endpointBuilder(Agent.ENDPOINT, *args)
response = self._requester.post(url, params=kwargs["params"])
return response.json()
except ValueError:
return response.status_code
def join_agent(self, addresses):
"""Initiate a join between the agent and target peers.
https://www.nomadproject.io/docs/http/agent-join.html
returns: dict
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
params = "address=" + "&address=".join(addresses)
return self._post("join", params=params)
def update_servers(self, addresses):
"""Updates the list of known servers to the provided list.
Replaces all previous server addresses with the new list.
https://www.nomadproject.io/docs/http/agent-servers.html
returns: 200 status code
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
params = "address=" + "&address=".join(addresses)
return self._post("servers", params=params)
def force_leave(self, node):
"""Force a failed gossip member into the left state.
https://www.nomadproject.io/docs/http/agent-force-leave.html
returns: 200 status code
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
params = "node={node}".format(node=node)
return self._post("force-leave", params=params)
```
#### File: nomad/api/allocations.py
```python
class Allocations(object):
"""
The allocations endpoint is used to query the status of allocations.
By default, the agent's local region is used; another region can be
specified using the ?region= query parameter.
https://www.nomadproject.io/docs/http/allocs.html
"""
ENDPOINT = "allocations"
def __init__(self, requester):
self._requester = requester
def __str__(self):
return "{0}".format(self.__dict__)
def __repr__(self):
return "{0}".format(self.__dict__)
def __getattr__(self, item):
raise AttributeError
def __len__(self):
response = self._get()
return len(response)
def __iter__(self):
response = self._get()
return iter(response)
def _get(self, *args):
url = self._requester._endpointBuilder(Allocations.ENDPOINT, *args)
response = self._requester.get(url)
return response.json()
def get_allocations(self):
""" Lists all the allocations.
https://www.nomadproject.io/docs/http/allocs.html
returns: list
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
return self._get()
```
#### File: nomad/api/regions.py
```python
import nomad.api.exceptions
class Regions(object):
"""
https://www.nomadproject.io/docs/http/regions.html
"""
ENDPOINT = "regions"
def __init__(self, requester):
self._requester = requester
def __str__(self):
return "{0}".format(self.__dict__)
def __repr__(self):
return "{0}".format(self.__dict__)
def __getattr__(self, item):
raise AttributeError
def __contains__(self, item):
try:
regions = self._get()
for r in regions:
if r == item:
return True
else:
return False
except nomad.api.exceptions.URLNotFoundNomadException:
return False
def __len__(self):
regions = self._get()
return len(regions)
def __getitem__(self, item):
try:
regions = self._get()
for r in regions:
if r == item:
return r
else:
raise KeyError
except nomad.api.exceptions.URLNotFoundNomadException:
raise KeyError
def __iter__(self):
regions = self._get()
return iter(regions)
def _get(self, *args):
url = self._requester._endpointBuilder(Regions.ENDPOINT, *args)
nodes = self._requester.get(url)
return nodes.json()
def get_regions(self):
""" Returns the known region names.
https://www.nomadproject.io/docs/http/regions.html
returns: list
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
return self._get()
```
#### File: nomad/api/sentinel.py
```python
import nomad.api.exceptions
class Sentinel(object):
"""
The endpoint manage sentinel policies (Enterprise Only)
https://www.nomadproject.io/api/sentinel-policies.html
"""
ENDPOINT = "sentinel"
def __init__(self, requester):
self._requester = requester
def __str__(self):
return "{0}".format(self.__dict__)
def __repr__(self):
return "{0}".format(self.__dict__)
def __getattr__(self, item):
raise AttributeError
def _get(self, *args, **kwargs):
url = self._requester._endpointBuilder(Sentinel.ENDPOINT, *args)
response = self._requester.get(url,
params=kwargs.get("params", None))
return response.json()
def _post(self, *args, **kwargs):
url = self._requester._endpointBuilder(Sentinel.ENDPOINT, *args)
if kwargs:
response = self._requester.post(url, json=kwargs.get("json_dict", None), params=kwargs.get("params", None))
else:
response = self._requester.post(url)
return response.json()
def _post_no_json(self, *args, **kwargs):
url = self._requester._endpointBuilder(Sentinel.ENDPOINT, *args)
if kwargs:
response = self._requester.post(url, json=kwargs.get("json_dict", None), params=kwargs.get("params", None))
else:
response = self._requester.post(url)
return response
def get_policies(self):
""" Get a list of policies.
https://www.nomadproject.io/api/sentinel-policies.html
returns: list
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
return self._get("policies")
def create_policy(self, id, policy):
""" Create policy.
https://www.nomadproject.io/api/sentinel-policies.html
arguments:
- policy
returns: dict
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
return self._post_no_json("policy", id, json_dict=policy)
def get_policy(self, id):
""" Get a spacific policy.
https://www.nomadproject.io/api/sentinel-policies.html
returns: dict
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
return self._get("policy", id)
def update_policy(self, id, policy):
""" Create policy.
https://www.nomadproject.io/api/sentinel-policies.html
arguments:
- name
- policy
returns: dict
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
return self._post_no_json("policy", id, json_dict=policy)
def delete_policy(self, id):
""" Delete specific policy.
https://www.nomadproject.io/api/sentinel-policies.html
arguments:
- id
raises:
- nomad.api.exceptions.BaseNomadException
- nomad.api.exceptions.URLNotFoundNomadException
"""
return self._delete("policy", id)
def _delete(self, *args, **kwargs):
url = self._requester._endpointBuilder(Sentinel.ENDPOINT, *args)
response = self._requester.delete(url,
params=kwargs.get("params", None))
return response.ok
```
#### File: python-nomad/tests/test_namespace.py
```python
import json
from mock import patch, MagicMock
import requests
# integration tests was mocked. If you have an enterprise nomad please uncomenet ##### ENTERPRISE TEST #####
@patch('nomad.api.namespace.Namespace._post')
def test_create_namespace(mock_post, nomad_setup):
mock_post.return_value = requests.codes.ok
namespace_api='{"Name":"api","Description":"api server namespace"}'
namespace = json.loads(namespace_api)
assert 200 == nomad_setup.namespace.create_namespace(namespace)
@patch('nomad.api.namespace.Namespace._post')
def test_update_namespace(mock_post, nomad_setup):
mock_post.return_value = requests.codes.ok
namespace_api='{"Name":"api","Description":"updated namespace"}'
namespace = json.loads(namespace_api)
assert 200 == nomad_setup.namespace.update_namespace("api", namespace)
@patch('nomad.api.namespace.Namespace._get')
def test_get_namespace(mock_get, nomad_setup):
mock_get.return_value = {"Name":"api","Description":"api server namespace"}
assert "api" in nomad_setup.namespace.get_namespace("api")["Name"]
@patch('nomad.api.namespace.Namespace._delete')
def test_delete_namespace(mock_delete, nomad_setup):
mock_delete.return_value = {"Name":"api","Description":"api server namespace"}
nomad_setup.namespace.delete_namespace("api")
assert "api" == nomad_setup.namespace.delete_namespace("api")["Name"]
######### ENTERPRISE TEST ###########
# def test_apply_namespace(nomad_setup):
# namespace_api='{"Name":"api","Description":"api server namespace"}'
# namespace = json.loads(namespace_api)
# nomad_setup.namespace.apply_namespace("api", namespace)
# assert "api" in nomad_setup.namespace
#
# def test_get_namespace(nomad_setup):
# assert "api" in nomad_setup.namespace.get_namespace("api")["Name"]
#
# def test_delete_namespace(nomad_setup):
# nomad_setup.namespace.delete_namespace("api")
# try:
# assert "api" != nomad_setup.namespace.get_namespace("api")["Name"]
# except nomad.api.exceptions.URLNotFoundNomadException:
# pass
```
|
{
"source": "JeterG/TriviaGame",
"score": 4
}
|
#### File: JeterG/TriviaGame/main.py
```python
import requests
import random
import json
from tkinter import Tk, Label, Button, StringVar
from random import randrange
# response=requests.get("https://opentdb.com/api.php?amount=1")#use this for api call
# data=response.json()['results']#use this with api call
with open('api.json') as f:
response=json.load(f)
data=response['results']
counter=0
def nextValue():
global counter
counter+=1
Q.set(counter)
window=Tk()
Q=StringVar()
Q.set("Testf")
window.title("Trivia Game")
window.geometry("800x600")
window.label = Label(window, textvariable=Q).pack()
NextProblem=Button(window,text="text",command=nextValue).pack()
def display(problem):
letters=['A','B','C','D']
if data[problem]['type']=='multiple':
print(problem+1,": ",data[problem]['question'])
choices=[data[problem]['incorrect_answers'][0],
data[problem]['incorrect_answers'][1],
data[problem]['incorrect_answers'][2],
data[problem]['correct_answer']]
random.shuffle(choices)
labledChoice={
'A': choices[0],
'B': choices[1],
'C': choices[2],
'D': choices[3]
}
for key,value in labledChoice.items():
print("\t\t",key,':',value)
submission = input("Choice:")
if submission.upper() in letters:
if labledChoice[submission.upper()]==data[problem]['correct_answer']:
print('Correct')
return 0
else:
print('Incorrect')
return -1
else:
print('Incorrect')
return -1
else:
print(problem+1,": ",data[problem]['question'])
print("\t\t",'True')
print("\t\t",'False')
submission = input("Choice:")
if submission.upper()==data[problem]['correct_answer'].upper():
print('Correct')
return 0
else:
print('Incorrect')
return -1
def problems(amount):
score=amount
for problem in range(amount):
score+=display(problem)
print (100*score/amount,'%')
# display(randrange(50))
# problems(randrange(50))
# problems(10)
class GUI:
def __init__(self,master):
self.master = master
master.title("Trivia Game")
self.label = Label(master, textvariable=Q)
self.label.pack()
self.greet_button = Button(master, text="Choice",command=self.greet )
self.greet_button.pack()
self.close_button = Button(master, text="Close", command=master.quit)
self.close_button.pack()
def greet(self):
print("Greetings!")
# root = Tk()
# gui=GUI(root)
# root.mainloop()
window.mainloop()
```
|
{
"source": "jetesdal/cmip6_preprocessing",
"score": 2
}
|
#### File: cmip6_preprocessing/cmip6_preprocessing/utils.py
```python
try:
import intake
except ImportError:
intake = None
def google_cmip_col(catalog="main"):
"""A tiny utility function to point to the 'official' pangeo cmip6 cloud files."""
if intake is None:
raise ValueError(
"This functionality requires intake-esm. Install with `conda install -c conda-forge intake-esm"
)
if catalog == "main":
return intake.open_esm_datastore(
"https://storage.googleapis.com/cmip6/pangeo-cmip6.json"
)
# this doesnt work anymore, but ill leave it here as an example for the future
# elif catalog == "testing":
# return intake.open_esm_datastore(
# "https://storage.googleapis.com/cmip6/pangeo-cmip6-testing.json"
# )
else:
raise ValueError("Catalog not recognized. Should be `main` or `testing`")
def model_id_match(match_list, id_tuple):
"""Matches `id_tuple` to the list of tuples `exception_list`, which can contain
wildcards (match any entry) and lists (match any entry that is in the list).
Parameters
----------
match_list : list
list of tuples with id strings corresponding to e.g. `source_id`, `grid_label`...
id_tuple : tuple
single tuple with id strings.
"""
# Check the size of tuples
if any([len(t) != len(id_tuple) for t in match_list]):
raise ValueError(
"Each tuple in `match_list` must have the same number of elements as `match_id`"
)
match_list_checked = []
for ml in match_list:
ml_processed = []
for i in range(len(ml)):
match_element = ml[i]
if isinstance(match_element, str) and match_element != "*":
match_element = [match_element]
if id_tuple[i] in match_element or match_element == "*":
ml_processed.append(True)
else:
ml_processed.append(False)
match_list_checked.append(all(ml_processed))
return any(match_list_checked)
```
|
{
"source": "jetesdal/ecco_utils",
"score": 2
}
|
#### File: jetesdal/ecco_utils/ecco_utils.py
```python
import os
import numpy as np
import xarray as xr
import matplotlib.pyplot as plt
def quick_llc_plot(data, axis_off=False, **kwargs):
face_to_axis = {0: (2, 0), 1: (1, 0), 2: (0, 0),
3: (2, 1), 4: (1, 1), 5: (0, 1),
7: (0, 2), 8: (1, 2), 9: (2, 2),
10: (0, 3), 11: (1, 3), 12: (2, 3)}
transpose = [7, 8, 9, 10, 11, 12]
gridspec_kw = dict(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
fig, axes = plt.subplots(nrows=3, ncols=4, gridspec_kw=gridspec_kw, figsize=(10,4))
for face, (j, i) in face_to_axis.items():
data_ax = data.sel(face=face)
ax = axes[j,i]
yincrease = True
if face in transpose:
data_ax = data_ax.transpose()
yincrease = False
p = data_ax.plot(ax=ax, yincrease=yincrease, **kwargs)
#p = data_ax.plot(ax=ax, **kwargs)
if axis_off:
ax.axis('off')
ax.set_title('')
# use implicit way
cbar = fig.colorbar(p, ax=axes.ravel().tolist(), shrink=0.95)
def v4_basin(nameBasin, mskBasins, lons, lats):
"""Obtains the mask of an ocean basin
Input nameBasin: Name of the basin of interest (atl, pac, ind, arctic, etc.)
mskBasins: Data array with basin masks (coords.basin)
lons: Longitude of LLC grid (coords.XC)
lons: Latitude of LLC grid (coords.YC)
Output mskC: Mask for tracer points (0 = outside basin; 1 = inside basin)
Function is based on gcmfaces v4_basin.m function. Additonal basin masks are added:
'npac', 'tropac', 'spac', 'spna', 'natl', 'troatl', 'satl', 'so'
'npac': North Pacific ('pac' where lat > 20)
'tropac': Tropical Pacific ('pac' where 20 >= lat >= -20)
'spac': South Pacific ('pac' where lat < -20)
'spna': Subpolar North Atlantic( 'atlExt' where 46 < lat < 65)
'natl': North Atlantic ('atl' where lat > 20)
'troatl': Tropical Atlantic ('atl' where 20 >= lat >= -20)
'satl': South Atlantic ('atl' where lat < -20)
'so': Southern Ocean (where lat < -50)
'troind': Tropical Indian Ocean ('ind' where lat >= -20)
'sind': Southern Indian Ocean ('ind' where lat <= -20)"""
basins = ['pac','atl','ind','arct','bering',
'southChina','mexico','okhotsk','hudson','med',
'java','north','japan','timor','eastChina','red','gulf',
'baffin','gin','barents']
atlExt = ['atl','mexico','hudson','med','north','baffin','gin']
pacExt = ['pac','bering','okhotsk','japan','eastChina']
indExt = ['ind','southChina','java','timor','red','gulf']
# list of selected basins:
if not isinstance(nameBasin, list):
nameBasin = [nameBasin]
if 'atlExt' in nameBasin:
nameBasin = nameBasin + atlExt
if 'pacExt' in nameBasin:
nameBasin = nameBasin + pacExt
if 'indExt' in nameBasin:
nameBasin = nameBasin + indExt
# derive tracer points mask
mskC = 0 * mskBasins
for idx, name in enumerate(basins):
if name in nameBasin:
mskC.values[mskBasins.values == idx + 1] = 1
for name in nameBasin:
if name == 'npac':
mskC.values[(mskBasins.values == basins.index('pac')+1)&(lats.values>20)] = 1
if name == 'tropac':
mskC.values[(mskBasins.values == basins.index('pac')+1)&(lats.values>=-20)&(lats.values<=20)] = 1
if name == 'spac':
mskC.values[(mskBasins.values == basins.index('pac')+1)&(lats.values<-20)] = 1
if name == 'spna':
for _name in atlExt:
mskC.values[(mskBasins.values == basins.index(_name)+1)&(lats.values>46)&(lats.values<65)] = 1
if name == 'natl':
mskC.values[(mskBasins.values == basins.index('atl')+1)&(lats.values>20)] = 1
if name == 'troatl':
mskC.values[(mskBasins.values == basins.index('atl')+1)&(lats.values>=-20)&(lats.values<=20)] = 1
if name == 'satl':
mskC.values[(mskBasins.values == basins.index('atl')+1)&(lats.values<-20)] = 1
if name == 'so':
for _name in ['pac','atl','ind']:
mskC.values[(mskBasins.values == basins.index(_name)+1)&(lats.values<-50)] = 1
if name == 'troind':
mskC.values[(mskBasins.values == basins.index('ind')+1)&(lats.values>=-20)] = 1
if name == 'sind':
mskC.values[(mskBasins.values == basins.index('ind')+1)&(lats.values<=-20)] = 1
# check for invalid (empty) output mask
if np.nansum(mskC.values) == 0:
raise ValueError('The basin(s) is unknown', nameBasin)
mskC.values[mskC.values == 0] = np.nan
return mskC
def open_ecco_grid(grid_dir):
"""
Load ECCOv4 grid into xarray dataset.
Parameters
----------
grid_dir : str
Directory path of ECCOv4 grid files
Returns
-------
xarray.Dataset with ECCOv4 grid info
"""
grid = xr.open_mfdataset(os.path.join(grid_dir, 'GRID.*.nc'), concat_dim='face')
# Renaming dimensions to match data variables
grid = grid.rename({'i3': 'i4'}).rename({'i2': 'i3'}).rename({'i1': 'i2'})
return grid
def open_ecco_single_variable(ncdir, varname):
"""
Load ECCOv4 variable into xarray dataset.
Parameters
----------
ncdir : str
Directory path of ECCOv4 variable files
varname: str
Name of variable
Returns
-------
xarray.Dataset with ECCOv4 variable
"""
ds = xr.open_mfdataset(os.path.join(ncdir, varname, '*.nc'),concat_dim='face')
# Make time an actual dimension
if 'tim' in ds:
tdim = ds['tim'].dims[0]
ds = ds.swap_dims({tdim: 'tim'})
ds = ds.rename({'tim': 'time'})
# Make sure that the dimension names are consistent
if ds['area'].dims == ('face', 'i2', 'i3'):
# we probably have a 2D field
ds = ds.rename({'i3': 'i4'}).rename({'i2': 'i3'})
ds = ds.reset_coords()
da = ds[varname]
dims = list(da.dims)
# Possibly transpose
if 'time' in dims:
if dims[0] != 'time':
newdims = [d for d in dims]
newdims[0] = 'time'
newdims[1] = dims[0]
da = da.transpose(*newdims)
return da
def open_ecco_variables(ncdir, grid_dir=None, variables=None):
"""
Load multiple ECCOv4 variables into single xarray dataset.
Parameters
----------
ncdir : str
Directory path of ECCOv4 variable files
grid_dir : str
Directory path of ECCOv4 grid files
variables:
List of variables to be imported
Returns
-------
xarray.Dataset with ECCOv4 variables
"""
if variables is None:
variables = []
for fname in os.listdir(ncdir):
if os.path.isdir(os.path.join(ncdir,fname)):
variables.append(fname)
darrays = [open_ecco_single_variable(ncdir, v) for v in variables]
if not grid_dir is None:
grid = open_ecco_grid(grid_dir)
grid = grid.set_coords(grid.data_vars)
darrays.append(grid)
return xr.merge(darrays)
def open_ecco_single_tendency(ncdir, dirname):
"""
Load ECCOv4 tendency field into xarray dataset. This function is useful for ECCOv4r2 files.
Parameters
----------
ncdir : str
Directory path of tendency files
dirname: str
Name of tendency
Returns
-------
xarray.Dataset with ECCOv4 tendency
"""
ds = xr.open_mfdataset(os.path.join(ncdir, dirname, '*.nc'),concat_dim='face')
# make time an actual dimension
if 'tim' in ds:
tdim = ds['tim'].dims[0]
ds = ds.swap_dims({tdim: 'tim'})
ds = ds.rename({'tim': 'time'})
# make depth an actual dimension
if 'dep' in ds:
ddim = ds['dep'].dims[0]
ds = ds.swap_dims({ddim: 'dep'})
ds = ds.rename({'dep': 'depth'})
# drop fake coordinates
for dim in list(ds.coords):
if dim not in ('time','depth') and len(ds[dim].dims) == 1 and ds[dim].dims[0] in ('time','depth'):
ds.__delitem__(dim)
# get coordinates before processing
dims = list(ds.dims)
ds.coords['area'] = ds.area
ds.coords['land'] = ds.land
ds.coords['thic'] = ds.thic
ds.coords['timstep'] = ds.timstep
ds.coords['face'] = ds.face
# face should be starting from 1 like it is defined in the file names
ds.face.values = ds.face.values + 1
# possibly transpose
dims0 = ['time','face','depth']
newdims = []
for dim in dims0:
if dim in dims:
newdims.append(dim)
for dim in dims:
if not dim in dims0:
newdims.append(dim)
if dims != newdims:
ds = ds.transpose(*newdims)
return ds
def open_ecco_tendencies(ncdir, grid_dir=None, variables=None):
"""
Load multiple ECCOv4 tendencies into single xarray dataset. This function is useful for ECCOv4r2 files.
Parameters
----------
ncdir : str
Directory path of ECCOv4 variable files
grid_dir : str
Directory path of ECCOv4 grid files
variables:
List of variables to be imported
Returns
-------
xarray.Dataset with ECCOv4 tendencies
"""
if variables is None:
variables = []
for fname in os.listdir(ncdir):
if os.path.isdir(os.path.join(ncdir,fname)):
variables.append(fname)
darrays = [open_ecco_single_tendency(ncdir, v) for v in variables]
if not grid_dir is None:
grid = open_ecco_grid(grid_dir)
grid = grid.set_coords(grid.data_vars)
darrays.append(grid)
return xr.merge(darrays)
def open_ecco_snapshots(ncdir, grid_dir=None, variables=None):
"""
Load ECCOv4 snapshots into xarray dataset. This function is useful for ECCOv4r2 files.
Parameters
----------
ncdir : str
Directory path of snapshot files
grid_dir : str
Directory path of ECCOv4 grid files
variables:
List of variables to be imported
Returns
-------
xarray.Dataset with ECCOv4 snapshots
"""
if variables is None:
variables = []
for fname in os.listdir(ncdir):
if os.path.isdir(os.path.join(ncdir,fname)):
variables.append(fname)
darrays = [open_ecco_single_tendency(ncdir, 'Ssnapshot' if v == 'SALT' else 'Tsnapshot') for v in variables]
if not grid_dir is None:
grid = open_ecco_grid(grid_dir)
grid = grid.set_coords(grid.data_vars)
darrays.append(grid)
return xr.merge(darrays)
```
|
{
"source": "jethac/ATF",
"score": 3
}
|
#### File: FunctionalTests/CommonTestScripts/FsmUtil.py
```python
import Test
def AddNewStateAndVerify(editingContext, xPos, yPos, label, size=64):
newState = editingContext.InsertState(xPos, yPos, label, size)
Test.Equal(label, newState.Name, "Verify label")
Test.Equal(xPos, newState.Position.X, "Verify x position")
Test.Equal(yPos, newState.Position.Y, "Verify y position")
return newState
def AddNewCommentAndVerify(editingContext, xPos, yPos, text):
newComment = editingContext.InsertComment(xPos, yPos, text)
Test.Equal(text, newComment.Text, "Verify text")
#Difficult to verify the exact position because it is now the
#center (previously was top left corner). Needs a calculation
#of the center of the comment based on the text length
#Test.Equal(xPos, newComment.Location.X, "Verify x position")
#Test.Equal(yPos, newComment.Location.Y, "Verify y position")
return newComment
def AddNewTransitionAndVerify(editingContext, state1, state2):
newTransition = editingContext.InsertTransition(state1, state2)
Test.Equal(state1.Name, newTransition.FromState.Name, "Verify from state name")
Test.Equal(state2.Name, newTransition.ToState.Name, "Verify to state name")
return newTransition
```
#### File: FunctionalTests/CommonTestScripts/LevelEditorUtil.py
```python
import System
import Test
import Sce.Atf.Dom
import LevelEditorSample
from System import Environment
from System.IO import Path
from System.IO import File
def SetSchema(schema):
global Schema
Schema = schema
return
def AddObjectAndVerify(editingContext, domNodeType, vector):
domNode = Sce.Atf.Dom.DomNode(domNodeType)
gameObject = editingContext.Insert(domNode, vector[0], vector[1], vector[2])
Test.Equal(gameObject.DomNode.Type.Name, domNodeType.Name, "Verify the correct type was added")
Test.Equal(System.Decimal(vector[0]), System.Decimal(gameObject.Translation[0]), "Verify new object X pos")
Test.Equal(System.Decimal(vector[1]), System.Decimal(gameObject.Translation[1]), "Verify new object Y pos")
Test.Equal(System.Decimal(vector[2]), System.Decimal(gameObject.Translation[2]), "Verify new object Z pos")
#More generic (and cluttered) way if domNode is returned from insertion
#Test.Equal(domNode.GetAttribute(domNode.Type.GetAttributeInfo("name")), name, "Verify new object name")
#Test.EqualSystem.(Decimal(domNode.GetAttribute(domNode.Type.GetAttributeInfo("translate"))[0]), System.Decimal(x), "Verify new object X pos")
#...
return gameObject
def AddObjectSetPropertiesAndVerify(editingContext, domNodeType, vTranslation, vScale, vRotation, vRotatePivot):
domNode = Sce.Atf.Dom.DomNode(domNodeType)
gameObject = editingContext.Insert(domNode, vTranslation[0], vTranslation[1], vTranslation[2])
editingContext.SetProperty(gameObject.DomNode, Schema.gameObjectType.scaleAttribute, Test.ConstructArray([vScale[0], vScale[1], vScale[2]]))
editingContext.SetProperty(gameObject.DomNode, Schema.gameObjectType.rotatePivotAttribute, Test.ConstructArray([vRotatePivot[0], vRotatePivot[1], vRotatePivot[2]]))
editingContext.SetProperty(gameObject.DomNode, Schema.gameObjectType.rotateAttribute, Test.ConstructArray([vRotation[0], vRotation[1], vRotation[2]]))
Test.Equal(gameObject.DomNode.Type.Name, domNodeType.Name, "Verify the correct type was added")
Test.Equal(System.Decimal(vTranslation[0]), System.Decimal(gameObject.Translation[0]), "Verify new object X pos")
Test.Equal(System.Decimal(vTranslation[1]), System.Decimal(gameObject.Translation[1]), "Verify new object Y pos")
Test.Equal(System.Decimal(vTranslation[2]), System.Decimal(gameObject.Translation[2]), "Verify new object Z pos")
Test.Equal(System.Decimal(vScale[0]), System.Decimal(gameObject.Scale[0]), "Verify new object X scale")
Test.Equal(System.Decimal(vScale[1]), System.Decimal(gameObject.Scale[1]), "Verify new object Y scale")
Test.Equal(System.Decimal(vScale[2]), System.Decimal(gameObject.Scale[2]), "Verify new object Z scale")
VerifyAttributeAngle(gameObject.DomNode, Schema.gameObjectType.rotateAttribute, vRotation)
Test.Equal(System.Decimal(vRotatePivot[0]), System.Decimal(gameObject.RotatePivot[0]), "Verify new object X rotate pivot")
Test.Equal(System.Decimal(vRotatePivot[1]), System.Decimal(gameObject.RotatePivot[1]), "Verify new object Y rotate pivot")
Test.Equal(System.Decimal(vRotatePivot[2]), System.Decimal(gameObject.RotatePivot[2]), "Verify new object Z rotate pivot")
return gameObject
def VerifyAttribute(domNode, attr, expected):
Test.Equal(expected, domNode.GetAttribute(attr), "Verify attribute")
return
def VerifyAttributeVector(domNode, attr, vector):
Test.Equal(System.Decimal(vector[0]), System.Decimal(domNode.GetAttribute(attr)[0]), "Verify X axis")
Test.Equal(System.Decimal(vector[1]), System.Decimal(domNode.GetAttribute(attr)[1]), "Verify Y axis")
Test.Equal(System.Decimal(vector[2]), System.Decimal(domNode.GetAttribute(attr)[2]), "Verify Z axis")
return
#internally, angles are stored as radians, but the api/ui displays degrees
#need to convert the internal radian to degrees, and use a fuzzy compare
#to account for floating point precision differences
def VerifyAttributeAngle(domNode, attr, vector):
Test.FuzzyCompare(System.Decimal(vector[0]), System.Decimal(domNode.GetAttribute(attr)[0]), "Verify X angle")
Test.FuzzyCompare(System.Decimal(vector[1]), System.Decimal(domNode.GetAttribute(attr)[1]), "Verify Y angle")
Test.FuzzyCompare(System.Decimal(vector[2]), System.Decimal(domNode.GetAttribute(attr)[2]), "Verify Z angle")
return
#This function constructs the full path to a resource under the Data folder.
def GetResourceFilePath(relativeFilePath):
#current directory is something like:
#LevelEditor\bin\Debug.vs2010
#Data directory is:
#LevelEditor\Data
#so the relative path to the data directory is:
dataDir = Path.Combine(Environment.CurrentDirectory, "../../Data")
resourcePath = Path.Combine(dataDir, relativeFilePath)
resourcePath = Path.GetFullPath(resourcePath)
return resourcePath
#Helper to convert an array of domNodes, sets each name based on its type, and returns a c# array of objects
def ConstructDomNodeArray(domNodes):
ret = System.Array.CreateInstance(System.Object, domNodes.Count)
for i in range(domNodes.Count):
name = domNodes[i].Type.Name.Replace("gap:", "")
domNodes[i].SetAttribute(LevelEditorSample.Schema.gameObjectType.nameAttribute, name)
ret[i] = domNodes[i]
return ret
```
|
{
"source": "jethar/options-charts",
"score": 3
}
|
#### File: src/options_charts/ticker_fullmode.py
```python
import logging, os
import json
from kiteconnect import KiteTicker
# from db import insert_ticks
import sqlite3
from datetime import datetime
from dateutil import tz
API_KEY = os.getenv("API_KEY")
API_SECRET = os.getenv("API_SECRET")
ACCESS_TOKEN = os.getenv("ACCESS_TOKEN")
DB_FILE = f"{os.getenv('DB_FILE')}_{datetime.now().strftime('%Y-%m-%d')}.db"
INSTRUMENT_CSV = os.getenv('INSTRUMENT_CSV')
CREATE_TICK_TABLE_SCRIPT = f"""
CREATE TABLE IF NOT EXISTS ticks (
tick_date DATETIME,
token INTEGER,
price REAL,
tick_json JSON
);
"""
def get_instruments():
import csv
data = []
with open(INSTRUMENT_CSV, newline='') as f:
reader = csv.DictReader(f)
# header = next(reader) # ignore header
data_nifty = [int(row['instrument_token']) for row in reader if ("NIFTY" in row['tradingsymbol']) or ("ETF" in row['tradingsymbol'])]
with open(INSTRUMENT_CSV, newline='') as f:
reader = csv.DictReader(f)
data_oth = [int(row['instrument_token']) for row in reader if ("NIFTY" not in row['tradingsymbol']) and ("ETF" not in row['tradingsymbol'])]
return data_nifty, data_oth
# instruments = [12219650, 12219906]
instruments_nifty, instruments_oth = get_instruments()
instruments = [*instruments_nifty, *instruments_oth]
logging.basicConfig(level=logging.INFO)
db = sqlite3.connect(DB_FILE)
cur = db.cursor()
cur.execute(CREATE_TICK_TABLE_SCRIPT)
# Timezone information for timezone conversion
utc_tz= tz.gettz('UTC')
india_tz= tz.gettz('Asia/Kolkata')
def get_time_in_timezone(timezone):
"""
Get time in given timezone, assuming starting with UTC.
source: https://stackoverflow.com/a/53914639
"""
utc = datetime.now()
# utc = utc.replace(tzinfo=utc_tz)
time_with_offset = utc.astimezone(timezone)
time_without_offset = time_with_offset.replace(tzinfo=None)
return time_without_offset
def get_IST_time():
return get_time_in_timezone(india_tz)
def delete_keys(tick, keys):
"""
Delete keys from tick dict.
Use "dot" notaion for representing nested keys. e.g. ohlc.close
"""
for key in keys:
t = tick
*key_prefix, last_part = key.split('.')
for k in key_prefix:
t = t[k]
try:
del t[last_part]
except KeyError:
logging.debug(f'Key {key}" is not in the tick dictionary')
# Task to insert to SQLite db
def insert_ticks(ticks):
c = db.cursor()
qry = "insert into ticks (tick_date, token, price) values "
qry_full = "insert into ticks (tick_date, token, price, tick_json) values "
count = 0
count_full = 0
time = get_IST_time()
for tick in ticks:
# c.execute(f"insert into ticks values ('{datetime.now()}', {tick['instrument_token']}, {tick['last_price']})")
# c.execute(insert_tick_statement, {
# "date": datetime.now(),
# "token": tick["instrument_token"],
# "price": tick["last_price"]})
if tick['mode'] == "full":
if count_full > 0:
qry_full += ", "
delete_keys(tick, ["depth", "oi_day_high", "oi_day_low", "buy_quantity", "sell_quantity", "ohlc.open", "ohlc.close"])
qry_full += f"('{time}', {tick['instrument_token']}, {tick['last_price']}, json('{json.dumps(tick, default=str)}'))"
count_full += 1
else:
if count > 0:
qry += ", "
qry += f"('{time}', {tick['instrument_token']}, {tick['last_price']})"
count += 1
if count:
c.execute(qry)
if count_full:
c.execute(qry_full)
# logging.debug("Inserting ticks to db : {}".format(json.dumps(ticks)))
logging.debug(f"Inserting ticks to db {time}.")
try:
db.commit()
except Exception:
db.rollback()
logging.exception("Couldn't write ticks to db: ")
# Initialise
# kws = KiteTicker("your_api_key", "your_access_token")
kws = KiteTicker(API_KEY, ACCESS_TOKEN)
def on_ticks(ws, ticks):
# Callback to receive ticks.
if len(ticks) > 0:
# on json.dumps
# TypeError: Object of type datetime is not JSON serializable formatting issue on datetime object
# http://127.0.0.1:7777/?token=473bbc2c11c1b9b0865b35b31c0ba704c151a06b833ab<PASSWORD>
logging.debug("Ticks: {}".format(json.dumps(ticks, indent=4, default=str)))
insert_ticks(ticks)
def on_connect(ws, response):
# Callback on successful connect.
# Subscribe to a list of instrument_tokens (RELIANCE and ACC here).
# ws.subscribe([738561, 5633])
ws.subscribe(instruments)
# Set RELIANCE to tick in `full` mode.
# ws.MODE_FULL , ws.MODE_LTP
# ws.set_mode(ws.MODE_FULL, [738561])
ws.set_mode(ws.MODE_LTP, instruments)
ws.set_mode(ws.MODE_FULL, instruments_nifty)
def on_close(ws, code, reason):
# On connection close stop the main loop
# Reconnection will not happen after executing `ws.stop()`
ws.stop()
# Assign the callbacks.
kws.on_ticks = on_ticks
kws.on_connect = on_connect
kws.on_close = on_close
# Infinite loop on the main thread. Nothing after this will run.
# You have to use the pre-defined callbacks to manage subscriptions.
kws.connect()
```
|
{
"source": "JetHong/PaddleGAN",
"score": 2
}
|
#### File: ppgan/models/gan_model.py
```python
import paddle
import numpy as np
from .base_model import BaseModel
from .builder import MODELS
from .generators.builder import build_generator
from .discriminators.builder import build_discriminator
from .losses import GANLoss
from ..solver import build_optimizer
from ..modules.init import init_weights
from ..utils.visual import make_grid
@MODELS.register()
class GANModel(BaseModel):
""" This class implements the vanilla GAN model with some tricks.
vanilla GAN paper: https://arxiv.org/abs/1406.2661
"""
def __init__(self, cfg):
"""Initialize the GAN Model class.
Parameters:
cfg (config dict)-- stores all the experiment flags; needs to be a subclass of Dict
"""
super(GANModel, self).__init__(cfg)
self.step = 0
self.n_critic = cfg.model.get('n_critic', 1)
self.visual_interval = cfg.log_config.visiual_interval
self.samples_every_row = cfg.model.get('samples_every_row', 8)
# define networks (both generator and discriminator)
self.nets['netG'] = build_generator(cfg.model.generator)
init_weights(self.nets['netG'])
# define a discriminator
if self.is_train:
self.nets['netD'] = build_discriminator(cfg.model.discriminator)
init_weights(self.nets['netD'])
if self.is_train:
self.losses = {}
# define loss functions
self.criterionGAN = GANLoss(cfg.model.gan_mode)
# build optimizers
self.build_lr_scheduler()
self.optimizers['optimizer_G'] = build_optimizer(
cfg.optimizer,
self.lr_scheduler,
parameter_list=self.nets['netG'].parameters())
self.optimizers['optimizer_D'] = build_optimizer(
cfg.optimizer,
self.lr_scheduler,
parameter_list=self.nets['netD'].parameters())
def set_input(self, input):
"""Unpack input data from the dataloader and perform necessary pre-processing steps.
Parameters:
input (list): include the data itself and its metadata information.
"""
if isinstance(input, (list, tuple)):
input = input[0]
if not isinstance(input, dict):
input = {'img': input}
self.D_real_inputs = [paddle.to_tensor(input['img'])]
if 'class_id' in input: # n class input
self.n_class = self.nets['netG'].n_class
self.D_real_inputs += [paddle.to_tensor(input['class_id'], dtype='int64')]
else:
self.n_class = 0
batch_size = self.D_real_inputs[0].shape[0]
self.G_inputs = self.nets['netG'].random_inputs(batch_size)
if not isinstance(self.G_inputs, (list, tuple)):
self.G_inputs = [self.G_inputs]
if not hasattr(self, 'G_fixed_inputs'):
self.G_fixed_inputs = [t for t in self.G_inputs]
if self.n_class > 0:
rows_num = (batch_size - 1) // self.samples_every_row + 1
class_ids = paddle.randint(0, self.n_class, [rows_num, 1])
class_ids = class_ids.tile([1, self.samples_every_row])
class_ids = class_ids.reshape([-1,])[:batch_size].detach()
self.G_fixed_inputs[1] = class_ids.detach()
def forward(self):
"""Run forward pass; called by both functions <optimize_parameters> and <test>."""
self.fake_imgs = self.nets['netG'](*self.G_inputs) # G(img, class_id)
# put items to visual dict
self.visual_items['fake_imgs'] = make_grid(self.fake_imgs, self.samples_every_row).detach()
def backward_D(self):
"""Calculate GAN loss for the discriminator"""
# Fake; stop backprop to the generator by detaching fake_imgs
# use conditional GANs; we need to feed both input and output to the discriminator
self.loss_D = 0
self.D_fake_inputs = [self.fake_imgs.detach()]
if len(self.G_inputs) > 1 and self.G_inputs[1] is not None:
self.D_fake_inputs += [self.G_inputs[1]]
pred_fake = self.nets['netD'](*self.D_fake_inputs)
# Real
real_imgs = self.D_real_inputs[0]
self.visual_items['real_imgs'] = make_grid(real_imgs, self.samples_every_row).detach()
pred_real = self.nets['netD'](*self.D_real_inputs)
self.loss_D_fake = self.criterionGAN(pred_fake, False, True)
self.loss_D_real = self.criterionGAN(pred_real, True, True)
# combine loss and calculate gradients
if self.cfg.model.gan_mode in ['vanilla', 'lsgan']:
self.loss_D = self.loss_D + (self.loss_D_fake + self.loss_D_real) * 0.5
else:
self.loss_D = self.loss_D + self.loss_D_fake + self.loss_D_real
self.loss_D.backward()
self.losses['D_fake_loss'] = self.loss_D_fake
self.losses['D_real_loss'] = self.loss_D_real
def backward_G(self):
"""Calculate GAN loss for the generator"""
# First, G(imgs) should fake the discriminator
self.D_fake_inputs = [self.fake_imgs]
if len(self.G_inputs) > 1 and self.G_inputs[1] is not None:
self.D_fake_inputs += [self.G_inputs[1]]
pred_fake = self.nets['netD'](*self.D_fake_inputs)
self.loss_G_GAN = self.criterionGAN(pred_fake, True, False)
# combine loss and calculate gradients
self.loss_G = self.loss_G_GAN
self.loss_G.backward()
self.losses['G_adv_loss'] = self.loss_G_GAN
def optimize_parameters(self):
# compute fake images: G(imgs)
self.forward()
# update D
self.set_requires_grad(self.nets['netD'], True)
self.optimizers['optimizer_D'].clear_grad()
self.backward_D()
self.optimizers['optimizer_D'].step()
self.set_requires_grad(self.nets['netD'], False)
# weight clip
if self.cfg.model.gan_mode == 'wgan':
with paddle.no_grad():
for p in self.nets['netD'].parameters():
p[:] = p.clip(-0.01, 0.01)
if self.step % self.n_critic == 0:
# update G
self.optimizers['optimizer_G'].clear_grad()
self.backward_G()
self.optimizers['optimizer_G'].step()
if self.step % self.visual_interval == 0:
with paddle.no_grad():
self.visual_items['fixed_generated_imgs'] = make_grid(
self.nets['netG'](*self.G_fixed_inputs), self.samples_every_row
)
self.step += 1
```
|
{
"source": "jethornton/7i76e",
"score": 2
}
|
#### File: src/lib7i76e/utilities.py
```python
import os, subprocess
from PyQt5.QtWidgets import QMessageBox, QApplication
def isNumber(s):
try:
s[-1].isdigit()
float(s)
return True
except ValueError:
return False
def checks(parent):
try:
subprocess.check_output('mesaflash', encoding='UTF-8')
except FileNotFoundError:
t = ('Mesaflash not found go to\n'
'https://github.com/LinuxCNC/mesaflash\n'
'for installation instructions.')
parent.outputPTE.appendPlainText(t)
parent.readPB.setEnabled(False)
parent.flashPB.setEnabled(False)
parent.reloadPB.setEnabled(False)
def axisChanged(parent):
joint = parent.sender().objectName()[-1]
axis = parent.sender().currentText()
if axis in ['X', 'Y', 'Z', 'U', 'V', 'W']:
getattr(parent, f'axisType_{joint}').setText('LINEAR')
elif axis in ['A', 'B', 'C']:
getattr(parent, f'axisType_{joint}').setText('ANGULAR')
else:
getattr(parent, f'axisType_{joint}').setText('')
coordList = []
for i in range(parent.card['joints']):
axisLetter = getattr(parent, f'axisCB_{i}').currentText()
if axisLetter != 'Select':
coordList.append(axisLetter)
parent.coordinatesLB.setText(''.join(coordList))
parent.axes = len(parent.coordinatesLB.text())
def configNameChanged(parent, text):
if text:
parent.configNameUnderscored = text.replace(' ','_').lower()
parent.configPath = os.path.expanduser('~/linuxcnc/configs') + '/' + parent.configNameUnderscored
parent.pathLabel.setText(parent.configPath)
else:
parent.pathLabel.setText('')
def pidSetDefault(parent):
tab = parent.sender().objectName()[-1]
if not parent.linearUnitsCB.currentData():
QMessageBox.warning(parent,'Warning', 'Machine Tab\nLinear Units\nmust be selected', QMessageBox.Ok)
return
p = int(1000/(int(parent.servoPeriodSB.cleanText())/1000000))
getattr(parent, 'p_' + tab).setText(f'{p}')
getattr(parent, 'i_' + tab).setText('0')
getattr(parent, 'd_' + tab).setText('0')
getattr(parent, 'ff0_' + tab).setText('0')
getattr(parent, 'ff1_' + tab).setText('1')
getattr(parent, 'ff2_' + tab).setText('0.00013')
getattr(parent, 'bias_' + tab).setText('0')
getattr(parent, 'maxOutput_' + tab).setText('0')
if parent.linearUnitsCB.itemData(parent.linearUnitsCB.currentIndex()) == 'inch':
maxError = '0.0005'
else:
maxError = '0.0127'
getattr(parent, 'maxError_' + tab).setText(maxError)
getattr(parent, 'deadband_' + tab).setText('0')
def spindlePidDefault(parent):
if not parent.linearUnitsCB.currentData():
QMessageBox.warning(parent,'Warning', 'Machine Tab\nLinear Units\nmust be selected', QMessageBox.Ok)
return
if parent.spindleMaxRpm.text() == '':
QMessageBox.warning(parent,'Warning', 'Spindle Tab\nMax RPM\nmust be specified', QMessageBox.Ok)
return
if not isNumber(parent.spindleMaxRpm.text()):
QMessageBox.warning(parent,'Warning', 'Spindle Tab\nMax RPM\nnot a valid number', QMessageBox.Ok)
return
getattr(parent, 'p_s').setText('0.0')
getattr(parent, 'i_s').setText('0.0')
getattr(parent, 'd_s').setText('0.0')
getattr(parent, 'ff0_s').setText('1.0')
getattr(parent, 'ff1_s').setText('0.0')
getattr(parent, 'ff2_s').setText('0.0')
getattr(parent, 'bias_s').setText('0.0')
getattr(parent, 'deadband_s').setText('0.0')
getattr(parent, 'maxOutput_s').setText(f'{parent.spindleMaxRpm.text()}')
def driveChanged(parent):
timing = parent.sender().itemData(parent.sender().currentIndex())
joint = parent.sender().objectName()[-1]
if timing:
getattr(parent, 'stepTime_' + joint).setText(timing[0])
getattr(parent, 'stepSpace_' + joint).setText(timing[1])
getattr(parent, 'dirSetup_' + joint).setText(timing[2])
getattr(parent, 'dirHold_' + joint).setText(timing[3])
getattr(parent, 'stepTime_' + joint).setEnabled(False)
getattr(parent, 'stepSpace_' + joint).setEnabled(False)
getattr(parent, 'dirSetup_' + joint).setEnabled(False)
getattr(parent, 'dirHold_' + joint).setEnabled(False)
else:
getattr(parent, 'stepTime_' + joint).setEnabled(True)
getattr(parent, 'stepSpace_' + joint).setEnabled(True)
getattr(parent, 'dirSetup_' + joint).setEnabled(True)
getattr(parent, 'dirHold_' + joint).setEnabled(True)
def plcOptions():
return ['ladderRungsSB', 'ladderBitsSB', 'ladderWordsSB',
'ladderTimersSB', 'iecTimerSB', 'ladderMonostablesSB', 'ladderCountersSB',
'ladderInputsSB', 'ladderOutputsSB', 'ladderExpresionsSB',
'ladderSectionsSB', 'ladderSymbolsSB', 'ladderS32InputsSB',
'ladderS32OuputsSB', 'ladderFloatInputsSB', 'ladderFloatOutputsSB']
def updateAxisInfo(parent):
if parent.sender().objectName() == 'actionOpen':
return
joint = parent.sender().objectName()[-1]
scale = getattr(parent, 'scale_' + joint).text()
if scale and isNumber(scale):
scale = float(scale)
else:
return
maxVelocity = getattr(parent, 'maxVelocity_' + joint).text()
if maxVelocity and isNumber(maxVelocity):
maxVelocity = float(maxVelocity)
else:
return
maxAccel = getattr(parent, 'maxAccel_' + joint).text()
if maxAccel and isNumber(maxAccel):
maxAccel = float(maxAccel)
else:
return
if not parent.linearUnitsCB.currentData():
parent.errorMsg('Machine Tab:\nLinear Units must be selected', 'Error')
return
accelTime = maxVelocity / maxAccel
getattr(parent, 'timeJoint_' + joint).setText(f'{accelTime:.2f} seconds')
accelDistance = accelTime * 0.5 * maxVelocity
getattr(parent, 'distanceJoint_' + joint).setText(f'{accelDistance:.2f} {parent.linearUnitsCB.currentData()}')
stepRate = scale * maxVelocity
getattr(parent, 'stepRateJoint_' + joint).setText(f'{abs(stepRate):.0f} pulses')
def spindleTypeChanged(parent):
pass
"""
#print(parent.spindleTypeCB.itemData(parent.spindleTypeCB.currentIndex()))
if parent.spindleTypeCB.currentData():
parent.spindleGB.setEnabled(True)
parent.spindleInfoGB.setEnabled(True)
parent.encoderGB.setEnabled(True)
parent.spindlepidGB.setEnabled(True)
if parent.spindleTypeCB.itemData(parent.spindleTypeCB.currentIndex()) == '1':
parent.spindleInfo1Lbl.setText("PWM on Step 4")
parent.tb2p3LB.setText("PWM +")
parent.tb2p2LB.setText("PWM -")
parent.spindleInfo2Lbl.setText("Direction on Dir 4")
parent.tb2p5LB.setText("Direction +")
parent.tb2p4LB.setText("Direction -")
parent.spindleInfo3Lbl.setText("Select Enable on the Outputs tab")
if parent.spindleTypeCB.itemData(parent.spindleTypeCB.currentIndex()) == '2':
parent.spindleInfo1Lbl.setText("UP on Step 4")
parent.tb2p3LB.setText("UP +")
parent.tb2p2LB.setText("UP -")
parent.spindleInfo2Lbl.setText("Down on Dir 4")
parent.tb2p5LB.setText("DOWN +")
parent.tb2p4LB.setText("DOWN -")
parent.spindleInfo3Lbl.setText("Select Enable on the Outputs tab")
if parent.spindleTypeCB.itemData(parent.spindleTypeCB.currentIndex()) == '3':
parent.spindleInfo1Lbl.setText("PDM on Step 4")
parent.tb2p3LB.setText("PDM +")
parent.tb2p2LB.setText("PDM -")
parent.spindleInfo2Lbl.setText("Direction on Dir 4")
parent.tb2p5LB.setText("Direction +")
parent.tb2p4LB.setText("Direction -")
parent.spindleInfo3Lbl.setText("Select Enable on the Outputs tab")
if parent.spindleTypeCB.itemData(parent.spindleTypeCB.currentIndex()) == '4':
parent.spindleInfo1Lbl.setText("Direction on Step 4")
parent.tb2p3LB.setText("Direction +")
parent.tb2p2LB.setText("Direction -")
parent.spindleInfo2Lbl.setText("PWM on Dir 4")
parent.tb2p5LB.setText("PWM +")
parent.tb2p4LB.setText("PWM -")
parent.spindleInfo3Lbl.setText("Select Enable on the Outputs tab")
else:
parent.spindleGB.setEnabled(False)
parent.spindleInfoGB.setEnabled(False)
parent.encoderGB.setEnabled(False)
parent.spindlepidGB.setEnabled(False)
parent.spindleInfo1Lbl.setText("No Spindle")
parent.spindleInfo2Lbl.setText("")
parent.spindleInfo3Lbl.setText("")
parent.spindleInfo4Lbl.setText("")
"""
def fileNew(parent):
parent.errorMsgOk('Close the Tool,\n Then open', 'Info!')
def fileSaveAs(parent):
parent.errorMsgOk('Change the Name,\n Then Save', 'Info!')
def copyOutput(parent):
qclip = QApplication.clipboard()
qclip.setText(parent.outputPTE.toPlainText())
parent.statusbar.showMessage('Output copied to clipboard')
```
|
{
"source": "jethornton/7i80",
"score": 2
}
|
#### File: src/lib7i80/buildini.py
```python
import os
from datetime import datetime
def build(parent):
buildErrors = []
iniFilePath = os.path.join(parent.configPath, parent.configNameUnderscored + '.ini')
parent.machinePTE.appendPlainText(f'Building {iniFilePath}')
if os.path.isfile(iniFilePath):
pass
if not os.path.exists(parent.configPath):
try:
os.mkdir(parent.configPath)
except OSError:
parent.machinePTE.appendPlainText(f'OS error\n {traceback.print_exc()}')
iniContents = ['# This file was created with the 7i80 Configuration Tool on ']
iniContents.append(datetime.now().strftime('%b %d %Y %H:%M:%S') + '\n')
iniContents.append('# Changes to most things are ok and will be read by the Configuration Tool\n')
# build the [7i80] section
iniContents.append('\n[7i80]\n')
iniContents.append(f'VERSION = {parent.version}\n')
iniContents.append(f'BOARD = {parent.boardCB.currentData()}\n')
iniContents.append(f'FIRMWARE = {parent.firmwareCB.currentText()}\n')
for i in range(4):
iniContents.append(f'CARD_{i} = {getattr(parent, "cardCB_" + str(i)).currentData()}\n')
#iniContents.append(f'CONNECTOR = {parent.connectorCB.currentText()}\n')
# build the [EMC] section
iniContents.append('\n[EMC]\n')
iniContents.append(f'VERSION = {parent.emcVersion}\n')
iniContents.append(f'MACHINE = {parent.configNameUnderscored}\n')
iniContents.append(f'DEBUG = {parent.debugCB.currentData()}\n')
# build the [HOSTMOT2] section
iniContents.append('\n[HOSTMOT2]\n')
iniContents.append('DRIVER = hm2_eth\n')
iniContents.append(f'IPADDRESS = {parent.ipAddressCB.currentData()}\n')
iniContents.append('BOARD = 7i80\n')
# build the [DISPLAY] section maxFeedOverrideLE
iniContents.append('\n[DISPLAY]\n')
iniContents.append(f'DISPLAY = {parent.guiCB.itemData(parent.guiCB.currentIndex())}\n')
if parent.editorCB.currentData():
iniContents.append(f'EDITOR = {parent.editorCB.currentData()}\n')
iniContents.append(f'PROGRAM_PREFIX = {os.path.expanduser("~/linuxcnc/nc_files")}\n')
iniContents.append(f'POSITION_OFFSET = {parent.positionOffsetCB.currentData()}\n')
iniContents.append(f'POSITION_FEEDBACK = {parent.positionFeedbackCB.currentData()}\n')
iniContents.append(f'MAX_FEED_OVERRIDE = {parent.maxFeedOverrideSB.value()}\n')
iniContents.append(f'DEFAULT_LINEAR_VELOCITY = {parent.defaultJogSpeedDSB.value()}\n')
iniContents.append('CYCLE_TIME = 0.1\n')
iniContents.append(f'INTRO_GRAPHIC = {parent.introGraphicLE.text()}\n')
iniContents.append(f'INTRO_TIME = {parent.splashScreenSB.value()}\n')
iniContents.append('OPEN_FILE = "{}"\n'.format(''))
if parent.pyvcpCB.isChecked():
iniContents.append(f'PYVCP = {parent.configNameUnderscored}.xml\n')
if parent.frontToolLatheCB.isChecked():
iniContents.append('LATHE = 1\n')
if parent.frontToolLatheCB.isChecked():
iniContents.append('BACK_TOOL_LATHE = 1\n')
# build the [KINS] section
iniContents.append('\n[KINS]\n')
if len(set(parent.coordinatesLB.text())) == len(parent.coordinatesLB.text()): # 1 joint for each axis
iniContents.append('KINEMATICS = {} coordinates={}\n'.format('trivkins', parent.coordinatesLB.text()))
else: # more than one joint per axis
iniContents.append(f'KINEMATICS = trivkins coordinates={parent.coordinatesLB.text()} kinstype=BOTH\n')
iniContents.append(f'JOINTS = {len(parent.coordinatesLB.text())}\n')
# build the [EMCIO] section
iniContents.append('\n[EMCIO]\n')
iniContents.append('EMCIO = iov2\n')
iniContents.append('CYCLE_TIME = 0.100\n')
iniContents.append('TOOL_TABLE = tool.tbl\n')
# build the [RS274NGC] section
iniContents.append('\n[RS274NGC]\n')
iniContents.append(f'PARAMETER_FILE = {parent.configNameUnderscored}.var\n')
iniContents.append(f'SUBROUTINE_PATH = {os.path.expanduser("~/linuxcnc/subroutines")}\n')
# build the [EMCMOT] section
iniContents.append('\n[EMCMOT]\n')
iniContents.append('EMCMOT = motmod\n')
iniContents.append('COMM_TIMEOUT = 1.0\n')
iniContents.append(f'SERVO_PERIOD = {parent.servoPeriodSB.value()}\n')
# build the [TASK] section
iniContents.append('\n[TASK]\n')
iniContents.append('TASK = milltask\n')
iniContents.append('CYCLE_TIME = 0.010\n')
# build the [TRAJ] section
iniContents.append('\n[TRAJ]\n')
iniContents.append(f'COORDINATES = {parent.coordinatesLB.text()}\n')
iniContents.append(f'LINEAR_UNITS = {parent.linearUnitsCB.currentData()}\n')
iniContents.append('ANGULAR_UNITS = degree\n')
iniContents.append(f'MAX_LINEAR_VELOCITY = {parent.maxLinearVel.text()}\n')
if parent.noforcehomingCB.isChecked():
iniContents.append(f'NO_FORCE_HOMING = 0\n')
else:
iniContents.append(f'NO_FORCE_HOMING = 1\n')
# build the [HAL] section
iniContents.append('\n[HAL]\n')
iniContents.append(f'HALFILE = {parent.configNameUnderscored}.hal\n')
iniContents.append('HALFILE = io.hal\n')
if parent.ssCardCB.currentData():
iniContents.append('HALFILE = sserial.hal\n')
if parent.customhalCB.isChecked():
iniContents.append('HALFILE = custom.hal\n')
if parent.postguiCB.isChecked():
iniContents.append('POSTGUI_HALFILE = postgui.hal\n')
if parent.shutdownCB.isChecked():
iniContents.append('SHUTDOWN = shutdown.hal\n')
iniContents.append('HALUI = halui\n')
# build the [HALUI] section
iniContents.append('\n[HALUI]\n')
# build the axes
axes = []
for i in range(5):
axis = getattr(parent, f'axisCB_{i}').currentData()
if axis and axis not in axes:
axes.append(axis)
jointTab = getattr(parent,'axisCB_' + str(i)).objectName()[7]
iniContents.append(f'\n[AXIS_{axis}]\n')
iniContents.append(f'MIN_LIMIT = {getattr(parent, "minLimit_" + jointTab).text()}\n')
iniContents.append(f'MAX_LIMIT = {getattr(parent, "maxLimit_" + jointTab).text()}\n')
iniContents.append(f'MAX_VELOCITY = {getattr(parent, "maxVelocity_" + jointTab).text()}\n')
iniContents.append(f'MAX_ACCELERATION = {getattr(parent, "maxAccel_" + jointTab).text()}\n')
# build the [JOINT_n] sections
for i in range(parent.joints):
if getattr(parent, "axisCB_" + str(i)).currentData():
iniContents.append(f'\n[JOINT_{i}]\n')
iniContents.append(f'AXIS = {getattr(parent, "axisCB_" + str(i)).currentData()}\n')
iniContents.append(f'MIN_LIMIT = {getattr(parent, "minLimit_" + str(i)).text()}\n')
iniContents.append(f'MAX_LIMIT = {getattr(parent, "maxLimit_" + str(i)).text()}\n')
iniContents.append(f'MAX_VELOCITY = {getattr(parent, "maxVelocity_" + str(i)).text()}\n')
iniContents.append(f'MAX_ACCELERATION = {getattr(parent, "maxAccel_" + str(i)).text()}\n')
iniContents.append(f'TYPE = {getattr(parent, "axisType_" + str(i)).text()}\n')
if getattr(parent, "reverse_" + str(i)).isChecked():
iniContents.append(f'SCALE = -{getattr(parent, "scale_" + str(i)).text()}\n')
else:
iniContents.append(f'SCALE = {getattr(parent, "scale_" + str(i)).text()}\n')
steppers = ['7i47', '7i47s', '7i76']
if parent.cardCB_0.currentText() in steppers:
iniContents.append(f'DRIVE = {getattr(parent, "driveCB_" + str(i)).currentText()}\n')
iniContents.append(f'STEPGEN_MAX_VEL = {float(getattr(parent, "maxVelocity_" + str(i)).text()) * 1.2:.2f}\n')
iniContents.append(f'STEPGEN_MAX_ACC = {float(getattr(parent, "maxAccel_" + str(i)).text()) * 1.2:.2f}\n')
iniContents.append(f'DIRSETUP = {getattr(parent, "dirSetup_" + str(i)).text()}\n')
iniContents.append(f'DIRHOLD = {getattr(parent, "dirHold_" + str(i)).text()}\n')
iniContents.append(f'STEPLEN = {getattr(parent, "stepTime_" + str(i)).text()}\n')
iniContents.append(f'STEPSPACE = {getattr(parent, "stepSpace_" + str(i)).text()}\n')
servos = ['7i33', '7i48', '7i77']
if parent.cardCB_0.currentText() in servos:
iniContents.append(f'ENCODER_SCALE = {getattr(parent, "encoderScale_" + str(i)).text()}\n')
iniContents.append(f'ANALOG_SCALE_MAX = {getattr(parent, "analogScaleMax_" + str(i)).text()}\n')
iniContents.append(f'ANALOG_MIN_LIMIT = {getattr(parent, "analogMinLimit_" + str(i)).text()}\n')
iniContents.append(f'ANALOG_MAX_LIMIT = {getattr(parent, "analogMaxLimit_" + str(i)).text()}\n')
if parent.linearUnitsCB.currentData() == 'inch':
iniContents.append('FERROR = 0.5\n')
iniContents.append('MIN_FERROR = 0.05\n')
else:
iniContents.append('FERROR = 0.0051\n')
iniContents.append('MIN_FERROR = 0.0025\n')
iniContents.append(f'DEADBAND = {getattr(parent, "deadband_" + str(i)).text()}\n')
iniContents.append(f'P = {getattr(parent, "p_" + str(i)).text()}\n')
iniContents.append(f'I = {getattr(parent, "i_" + str(i)).text()}\n')
iniContents.append(f'D = {getattr(parent, "d_" + str(i)).text()}\n')
iniContents.append(f'FF0 = {getattr(parent, "ff0_" + str(i)).text()}\n')
iniContents.append(f'FF1 = {getattr(parent, "ff1_" + str(i)).text()}\n')
iniContents.append(f'FF2 = {getattr(parent, "ff2_" + str(i)).text()}\n')
iniContents.append(f'BIAS = {getattr(parent, "bias_" + str(i)).text()}\n')
iniContents.append(f'MAX_OUTPUT = {getattr(parent, "maxOutput_" + str(i)).text()}\n')
iniContents.append(f'MAX_ERROR = {getattr(parent, "maxError_" + str(i)).text()}\n')
if getattr(parent, "home_" + str(i)).text():
iniContents.append(f'HOME = {getattr(parent, "home_" + str(i)).text()}\n')
if getattr(parent, "homeOffset_" + str(i)).text():
iniContents.append(f'HOME_OFFSET = {getattr(parent, "homeOffset_" + str(i)).text()}\n')
if getattr(parent, "homeSearchVel_" + str(i)).text():
iniContents.append(f'HOME_SEARCH_VEL = {getattr(parent, "homeSearchVel_" + str(i)).text()}\n')
if getattr(parent, "homeLatchVel_" + str(i)).text():
iniContents.append(f'HOME_LATCH_VEL = {getattr(parent, "homeLatchVel_" + str(i)).text()}\n')
if getattr(parent, "homeFinalVelocity_" + str(i)).text():
iniContents.append(f'HOME_FINAL_VEL = {getattr(parent, "homeFinalVelocity_" + str(i)).text()}\n')
if getattr(parent, "homeSequence_" + str(i)).text():
iniContents.append(f'HOME_SEQUENCE = {getattr(parent, "homeSequence_" + str(i)).text()}\n')
if getattr(parent, "homeIgnoreLimits_" + str(i)).isChecked():
iniContents.append('HOME_IGNORE_LIMITS = True\n')
if getattr(parent, "homeUseIndex_" + str(i)).isChecked():
iniContents.append('HOME_USE_INDEX = True\n')
if getattr(parent, "homeSwitchShared_" + str(i)).isChecked():
iniContents.append('HOME_IS_SHARED = True\n')
# build the [SPINDLE] section if enabled
iniContents.append('\n[SPINDLE]\n')
iniContents.append(f'SCALE = {parent.spindleScale.value()}\n')
iniContents.append(f'PWM_FREQUENCY = {parent.pwmFrequencySB.value()}\n')
iniContents.append(f'MAX_RPM = {parent.spindleMaxRpm.value()}\n')
iniContents.append(f'MIN_RPM = {parent.spindleMinRpm.value()}\n')
iniContents.append(f'DEADBAND = {parent.deadband_s.value()}\n')
iniContents.append(f'P = {parent.p_s.value()}\n')
iniContents.append(f'I = {parent.i_s.value()}\n')
iniContents.append(f'D = {parent.d_s.value()}\n')
iniContents.append(f'FF0 = {parent.ff0_s.value()}\n')
iniContents.append(f'FF1 = {parent.ff1_s.value()}\n')
iniContents.append(f'FF2 = {parent.ff2_s.value()}\n')
iniContents.append(f'BIAS = {parent.bias_s.value()}\n')
iniContents.append(f'MAX_ERROR = {parent.maxError_s.value()}\n')
iniContents.append(f'MAX_OUTPUT = {parent.maxOutput_s.value()}\n')
iniContents.append('\n# Everything below this line is only used to\n')
iniContents.append('# setup the Configuration Tool when loading the ini.\n')
# build the [INPUTS] section from pushbuttons
iniContents.append('\n[INPUT_PB]\n')
iniContents.append('# DO NOT change the inputs text\n')
for i in range(32):
iniContents.append(f'INPUT_PB_{i} = {getattr(parent, "inputPB_" + str(i)).text()}\n')
iniContents.append(f'INPUT_INVERT_{i} = {getattr(parent, "inputInvertCB_" + str(i)).isChecked()}\n')
# build the [OUTPUTS] section from pushbuttons
iniContents.append('\n[OUTPUT_PB]\n')
iniContents.append('# DO NOT change the outputs text\n')
for i in range(16):
iniContents.append(f'OUTPUT_PB_{i} = {getattr(parent, "outputPB_" + str(i)).text()}\n')
# build the [OPTIONS] section
iniContents.append('\n[OPTIONS]\n')
iniContents.append('# DO NOT change the options text\n')
iniContents.append(f'INTRO_GRAPHIC = {parent.introGraphicLE.text()}\n')
iniContents.append(f'INTRO_GRAPHIC_TIME = {parent.splashScreenSB.value()}\n')
iniContents.append(f'MANUAL_TOOL_CHANGE = {parent.manualToolChangeCB.isChecked()}\n'.format())
iniContents.append(f'CUSTOM_HAL = {parent.customhalCB.isChecked()}\n')
iniContents.append(f'POST_GUI_HAL = {parent.postguiCB.isChecked()}\n')
iniContents.append(f'SHUTDOWN_HAL = {parent.shutdownCB.isChecked()}\n')
iniContents.append(f'HALUI = {parent.haluiCB.isChecked()}\n')
iniContents.append(f'PYVCP = {parent.pyvcpCB.isChecked()}\n')
iniContents.append(f'GLADEVCP = {parent.gladevcpCB.isChecked()}\n')
iniContents.append(f'LADDER = {parent.ladderGB.isChecked()}\n')
iniContents.append(f'BACKUP = {parent.backupCB.isChecked()}\n')
if parent.ladderGB.isChecked(): # check for any options
for option in parent.ladderOptionsList:
if getattr(parent, option).value() > 0: #******** work to be done here
iniContents.append(f'{getattr(parent, option).property("item")} = {getattr(parent, option).value()}\n')
# build the [SSERIAL] section
if parent.ssCardCB.currentData():
iniContents.append('\n[SSERIAL]\n')
iniContents.append('# DO NOT change the sserial text\n')
iniContents.append(f'ssCardCB = {parent.ssCardCB.currentText()}\n')
if parent.ssCardCB.currentText() == '7i64':
# 24 ss7i64in_
# 24 ss7i64out_
for i in range(24):
iniContents.append(f'ss7i64in_{i} = {getattr(parent, "ss7i64in_" + str(i)).text()}\n')
for i in range(24):
iniContents.append(f'ss7i64out_{i} = {getattr(parent, "ss7i64out_" + str(i)).text()}\n')
elif parent.ssCardCB.currentText() == '7i69':
# 24 ss7i69in_
# 24 ss7i69out_
for i in range(24):
iniContents.append(f'SS_INPUT_{i} = {getattr(parent, "ss7i69in_" + str(i)).text()}\n')
for i in range(24):
iniContents.append(f'SS_OUTPUT_{i} = {getattr(parent, "ss7i69out_" + str(i)).text()}\n')
elif parent.ssCardCB.currentText() == '7i70':
# 48 ss7i70in_
for i in range(48):
iniContents.append(f'SS_INPUT_{i} = {getattr(parent, "ss7i70in_" + str(i)).text()}\n')
elif parent.ssCardCB.currentText() == '7i71':
# 48 ss7i71out_
for i in range(48):
iniContents.append(f'SS_OUTPUT_{i} = {getattr(parent, "ss7i71out_" + str(i)).text()}\n')
elif parent.ssCardCB.currentText() == '7i72':
# 48 ss7i72out_
for i in range(48):
iniContents.append(f'SS_OUTPUT_{i} = {getattr(parent, "ss7i72out_" + str(i)).text()}\n')
elif parent.ssCardCB.currentText() == '7i73':
# 16 ss7i73key_
# 12 ss7i73lcd_
# 16 ss7i73in_
# 2 ss7i73out_
for i in range(16):
iniContents.append(f'SS_KEY_{i} = {getattr(parent, "ss7i73key_" + str(i)).text()}\n')
for i in range(12):
iniContents.append(f'SS_LCD_{i} = {getattr(parent, "ss7i73lcd_" + str(i)).text()}\n')
for i in range(16):
iniContents.append(f'SS_INPUT_{i} = {getattr(parent, "ss7i73in_" + str(i)).text()}\n')
for i in range(2):
iniContents.append(f'SS_OUTPUT_{i} = {getattr(parent, "ss7i73out_" + str(i)).text()}\n')
elif parent.ssCardCB.currentText() == '7i84':
# 32 ss7i84in_
# 16 ss7i84out_
for i in range(32):
iniContents.append(f'SS_INPUT_{i} = {getattr(parent, "ss7i84in_" + str(i)).text()}\n')
for i in range(16):
iniContents.append(f'SS_OUTPUT_{i} = {getattr(parent, "ss7i84out_" + str(i)).text()}\n')
elif parent.ssCardCB.currentText() == '7i87':
# 8 ss7i87in_
for i in range(8):
iniContents.append(f'SS_INPUT_{i} = {getattr(parent, "ss7i87in_" + str(i)).text()}\n')
try:
with open(iniFilePath, 'w') as iniFile:
iniFile.writelines(iniContents)
except OSError:
parent.machinePTE.appendPlainText(f'OS error\n {traceback.print_exc()}')
```
#### File: src/lib7i80/updates.py
```python
import os, requests
import urllib.request
from packaging import version
from PyQt5.QtWidgets import QApplication, QFileDialog
REPO = '7i80'
def checkUpdates(parent):
response = requests.get(f"https://api.github.com/repos/jethornton/{REPO}/releases/latest")
repoVersion = response.json()["name"]
if version.parse(repoVersion) > version.parse(parent.version):
parent.machinePTE.appendPlainText(f'A newer version {repoVersion} is available for download')
elif version.parse(repoVersion) == version.parse(parent.version):
parent.machinePTE.appendPlainText(f'The Repo version {repoVersion} is the same as this version')
def downloadDeb(parent):
directory = str(QFileDialog.getExistingDirectory(parent, "Select Directory"))
parent.statusbar.showMessage('Checking Repo')
response = requests.get(f"https://api.github.com/repos/jethornton/{REPO}/releases/latest")
repoVersion = response.json()["name"]
parent.statusbar.showMessage(f'Mesa Configuration Tool Version {repoVersion} Download Starting')
destination = os.path.join(directory, f'{REPO}_' + repoVersion + '_amd64.deb')
deburl = os.path.join(f'https://github.com/jethornton/{REPO}/raw/master/{REPO}_' + repoVersion + '_amd64.deb')
download(parent, deburl, destination)
parent.statusbar.showMessage(f'Mesa Configuration Tool Version {repoVersion} Download Complete')
def downloadtZip(parent):
directory = str(QFileDialog.getExistingDirectory(parent, "Select Directory"))
parent.statusbar.showMessage('Checking Repo')
response = requests.get("https://api.github.com/repos/jethornton/{REPO}/releases/latest")
repoVersion = response.json()["name"]
parent.statusbar.showMessage(f'Mesa Configuration Tool Version {repoVersion} Download Starting')
destination = os.path.join(directory, f'{REPO}_' + repoVersion + '.zip')
zipurl = 'https://github.com/jethornton/{REPO}/archive/master.zip'
download(parent, zipurl, destination)
parent.statusbar.showMessage(f'Mesa Configuration Tool Version {repoVersion} Download Complete')
def download(parent, down_url, save_loc):
def Handle_Progress(blocknum, blocksize, totalsize):
## calculate the progress
readed_data = blocknum * blocksize
if totalsize > 0:
download_percentage = readed_data * 100 / totalsize
parent.progressBar.setValue(int(download_percentage))
QApplication.processEvents()
urllib.request.urlretrieve(down_url, save_loc, Handle_Progress)
parent.progressBar.setValue(100)
parent.timer.start(10000)
def clearProgressBar(parent):
parent.progressBar.setValue(0)
parent.statusbar.clearMessage()
parent.machinePTE.clear()
parent.machinePTE.appendPlainText('Close the Configuration Tool and reinstall')
```
|
{
"source": "jethornton/7i92",
"score": 2
}
|
#### File: src/lib7i92/buildfiles.py
```python
import os, subprocess
from datetime import datetime
def build(parent):
parent.tabs.setCurrentIndex(0)
parent.machinePTE.clear()
backup(parent)
builddirs(parent)
buildini(parent)
buildhal(parent)
buildio(parent)
buildmisc(parent)
def backup(parent):
if parent.backupCB.isChecked():
if os.path.exists(parent.configPath): # there is something to backup
backupDir = os.path.join(parent.configPath, 'backups')
if not os.path.exists(backupDir):
os.mkdir(backupDir)
backupFile = os.path.join(backupDir, f'{datetime.now():%m-%d-%y-%H:%M:%S}')
parent.machinePTE.appendPlainText(f'Backing up Files to {backupFile}')
p1 = subprocess.Popen(['find',parent.configPath,'-maxdepth','1','-type','f','-print'], stdout=subprocess.PIPE)
p2 = subprocess.Popen(['zip','-j',backupFile,'-@'], stdin=p1.stdout, stdout=subprocess.PIPE)
p1.stdout.close()
output = p2.communicate()[0]
parent.machinePTE.appendPlainText(output.decode())
def builddirs(parent):
if not os.path.exists(os.path.expanduser('~/linuxcnc')):
os.mkdir(os.path.expanduser('~/linuxcnc'))
parent.machinePTE.appendPlainText('Building LinuxCNC Directories')
if not os.path.exists(os.path.expanduser('~/linuxcnc/configs')):
os.mkdir(os.path.expanduser('~/linuxcnc/configs'))
if not os.path.exists(os.path.expanduser('~/linuxcnc/nc_files')):
os.mkdir(os.path.expanduser('~/linuxcnc/nc_files'))
if not os.path.exists(os.path.expanduser('~/linuxcnc/subroutines')):
os.mkdir(os.path.expanduser('~/linuxcnc/subroutines'))
def buildini(parent):
iniFile = os.path.join(parent.configPath, parent.configName + '.ini')
parent.machinePTE.appendPlainText(f'Building the ini file: {iniFile}')
def buildhal(parent):
halFile = os.path.join(parent.configPath, parent.configName + '.hal')
parent.machinePTE.appendPlainText(f'Building the hal file: {halFile}')
def buildio(parent):
ioFile = os.path.join(parent.configPath, parent.configName + '.ini')
parent.machinePTE.appendPlainText(f'Building the io file: {ioFile}')
def buildmisc(parent):
# if Axis is the GUI add the shutup file
print(parent.guiCB.currentData())
if parent.guiCB.currentData() == 'axis':
shutupFilepath = os.path.expanduser('~/.axisrc')
shutupContents = ['root_window.tk.call("wm","protocol",".","WM_DELETE_WINDOW","destroy .")']
try: # if this file exists don't write over it
with open(shutupFilepath, 'x') as shutupFile:
shutupFile.writelines(shutupContents)
parent.machinePTE.appendPlainText(f'Building the .axisrc file: {shutupFilepath}')
except FileExistsError:
pass
except OSError:
parent.outputPTE.appendPlainText(f'OS error\n {traceback.print_exc()}')
#iniFile = os.path.join(parent.configPath, parent.configName + '.ini')
#parent.machinePTE.appendPlainText(f'Building the ini file: {iniFile}')
```
#### File: src/lib7i92/loadini.py
```python
import configparser, os
def openFile(parent, ini):
config = configparser.ConfigParser(strict=False)
parent.machinePTE.clear()
if config.read(ini):
if config.has_option('7I92', 'VERSION'):
iniVersion = config['7I92']['VERSION']
if not iniVersion == parent.version:
msg = ('The ini file version is {iniVersion}\n'
'The Configuration Tool version is {self.version}\n'
'Try and open the ini?')
if not parent.errorMsgOkCancel(msg, 'Version Difference'):
return False
else:
msg = ('This ini file has been built with an different version\n'
'of this Configuration Tool\n'
'Try and open?')
if not parent.errorMsgOkCancel(msg, 'No Version'):
return False
parent.open_gui = True
parent.nameLE.setText(os.path.splitext(os.path.basename(ini))[0])
parent.pathOkLbl.setText('Config Opened')
parent.open_gui = False
#print(os.path.splitext(os.path.basename(ini))[0])
```
|
{
"source": "jethornton/7i97",
"score": 3
}
|
#### File: src/lib7i97/extcmd.py
```python
import os
from PyQt5.QtCore import QProcess
"""
Usage extcmd.job(self, cmd="something", args="",
dest=self.QPlainTextEdit, clean="file to delete when done")
To pipe the output of cmd1 to cmd2 use the following
Usage extcmd.pipe_job(self, cmd1="something", arg1="", cmd2="pipe to",
arg2, "", dest=self.QPlainTextEdit)
"""
class extcmd:
def __init__(self):
super().__init__()
self.p1 = None # Default empty value.
self.p2 = None # Default empty value.
self.destination = None
self.cleanup = None
def message(self, text):
if self.destination:
self.destination.appendPlainText(text)
def pipe_job(self, **kwargs):
cmd1 = kwargs.get('cmd1')
arg1 = kwargs.get('arg1')
cmd2 = kwargs.get('cmd2')
arg2 = kwargs.get('arg2')
self.destination = kwargs.get('dest')
self.destination.clear()
self.p1 = QProcess()
self.p2 = QProcess()
self.p1.setStandardOutputProcess(self.p2)
self.p1.errorOccurred.connect(self.p1_handle_error)
self.p1.stateChanged.connect(self.p1_handle_state)
self.p2.readyReadStandardOutput.connect(self.p2_handle_stdout)
self.p2.readyReadStandardError.connect(self.p2_handle_stderr)
self.p2.stateChanged.connect(self.p2_handle_state)
self.p2.errorOccurred.connect(self.p2_handle_error)
# Clean up once complete.
self.p2.finished.connect(self.p2_process_finished)
if arg1:
self.p1.start(cmd1, [arg1])
else:
self.p1.start(cmd1)
if arg2:
self.p2.start(cmd2, [arg2])
else:
self.p2.start(cmd2)
def job(self, **kwargs):
cmd = kwargs.get('cmd')
args = kwargs.get('args')
self.destination = kwargs.get('dest')
#self.destination.clear()
self.cleanup = kwargs.get('clean')
self.p1 = QProcess()
if self.destination:
self.destination.clear()
self.p1.readyReadStandardOutput.connect(self.p1_handle_stdout)
self.p1.readyReadStandardError.connect(self.p1_handle_stderr)
self.p1.errorOccurred.connect(self.p1_handle_error)
self.p1.stateChanged.connect(self.p1_handle_state)
# Clean up once complete.
self.p1.finished.connect(self.p1_process_finished)
if args:
self.p1.start(cmd, args)
else:
self.p1.start(cmd)
if self.destination:
self.message(f"Executing process {self.p1.program()}")
def p1_handle_stderr(self):
data = self.p1.readAllStandardError()
stderr = bytes(data).decode("utf8")
if type(self.destination) != str:
self.message(stderr)
else:
self.message = stderr
def p1_handle_stdout(self):
data = self.p1.readAllStandardOutput()
stdout = bytes(data).decode("utf8")
if type(self.destination) != str:
self.message(stdout)
else:
self.message = stdout
def p1_handle_state(self, state):
states = {
QProcess.NotRunning: 'Not running',
QProcess.Starting: 'Starting',
QProcess.Running: 'Running',
}
state_name = states[state]
if not self.p1.errorOccurred:
self.message(f"State changed: {state_name}")
def p1_process_finished(self):
self.message("Process finished.")
self.p1 = None
if self.cleanup:
os.remove(self.cleanup)
def p1_handle_error(self):
errors = {
0:'Failed to Start',
1:'Crashed',
2:'Timedout',
3:'ReadError',
4:'WriteError',
5:'UnknownError',
}
if type(self.destination) != str:
self.message(f"{self.p1.program()} had the following error:\nerrors.get(self.p.error())")
def p2_handle_stderr(self):
data = self.p2.readAllStandardError()
stderr = bytes(data).decode("utf8")
self.message(stderr)
def p2_handle_stdout(self):
data = self.p2.readAllStandardOutput()
stdout = bytes(data).decode("utf8")
self.message(stdout)
def p2_handle_state(self, state):
states = {
QProcess.NotRunning: 'Not running',
QProcess.Starting: 'Starting',
QProcess.Running: 'Running',
}
state_name = states[state]
if not self.p2.errorOccurred:
self.message(f"State changed: {state_name}")
def p2_process_finished(self):
self.message("Process finished.")
self.p2 = None
def p2_handle_error(self):
errors = {
0:'Failed to Start',
1:'Crashed',
2:'Timedout',
3:'ReadError',
4:'WriteError',
5:'UnknownError',
}
self.message(f"{self.p2.program()} had the following error:\nerrors.get(self.p.error())")
```
#### File: src/lib7i97/pcinfo.py
```python
def cpuInfo(parent):
parent.extcmd.job(cmd="lscpu", args=None, dest=parent.infoPTE)
def nicInfo(parent):
parent.extcmd.job(cmd="lspci", args=None, dest=parent.infoPTE)
def nicCalc(parent):
if parent.tMaxLE.text() != '' and parent.cpuSpeedLE.text() != '':
tMax = int(int(parent.tMaxLE.text()) / 1000)
cpuSpeed = float(parent.cpuSpeedLE.text()) * parent.cpuSpeedCB.currentData()
packetTime = tMax / cpuSpeed
parent.packetTimeLB.setText('{:.1%}'.format(packetTime))
threshold = (cpuSpeed * 0.7) / cpuSpeed
parent.thresholdLB.setText('{:.0%}'.format(threshold))
else:
errorText = []
if parent.cpuSpeedLE.text() == '':
errorText.append('CPU Speed can not be empty')
if parent.tMaxLE.text() == '':
errorText.append('tMax can not be empty')
parent.errorMsgOk('\n'.join(errorText))
def readTmax(parent):
parent.extcmd.job(cmd="halcmd", args=['show', 'param', 'hm2*.tmax'], dest=parent.tmaxPTE)
```
#### File: 7i97/src/ui_7i97.py
```python
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_mainWindow(object):
def setupUi(self, mainWindow):
mainWindow.setObjectName("mainWindow")
mainWindow.resize(1000, 851)
mainWindow.setWindowTitle("")
mainWindow.setStyleSheet("")
self.centralwidget = QtWidgets.QWidget(mainWindow)
self.centralwidget.setObjectName("centralwidget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.centralwidget)
self.verticalLayout.setContentsMargins(8, 8, 8, 8)
self.verticalLayout.setSpacing(5)
self.verticalLayout.setObjectName("verticalLayout")
self.tabWidget = QtWidgets.QTabWidget(self.centralwidget)
self.tabWidget.setFocusPolicy(QtCore.Qt.NoFocus)
self.tabWidget.setStyleSheet("QGroupBox {\n"
" font: bold;\n"
" border: 2px solid silver;\n"
" border-radius: 6px;\n"
" margin-top: 6px;\n"
"}\n"
"\n"
"QGroupBox::title {\n"
" subcontrol-origin: margin;\n"
" top: -5px;\n"
" left: 7px;\n"
" padding: 0px 5px 0px 5px;\n"
"}")
self.tabWidget.setObjectName("tabWidget")
self.machine = QtWidgets.QWidget()
self.machine.setObjectName("machine")
self.gridLayout_49 = QtWidgets.QGridLayout(self.machine)
self.gridLayout_49.setContentsMargins(8, 8, 8, 8)
self.gridLayout_49.setSpacing(5)
self.gridLayout_49.setObjectName("gridLayout_49")
self.gridGroupBox = QtWidgets.QGroupBox(self.machine)
self.gridGroupBox.setStyleSheet("QGroupBox {\n"
" font: bold;\n"
" border: 2px solid silver;\n"
" border-radius: 6px;\n"
" margin-top: 6px;\n"
"}\n"
"\n"
"QGroupBox::title {\n"
" subcontrol-origin: margin;\n"
" left: 7px;\n"
" padding: 0px 5px 0px 5px;\n"
"}")
self.gridGroupBox.setObjectName("gridGroupBox")
self.gridLayout_46 = QtWidgets.QGridLayout(self.gridGroupBox)
self.gridLayout_46.setContentsMargins(9, 15, 9, 9)
self.gridLayout_46.setSpacing(5)
self.gridLayout_46.setObjectName("gridLayout_46")
self.label_2 = QtWidgets.QLabel(self.gridGroupBox)
self.label_2.setObjectName("label_2")
self.gridLayout_46.addWidget(self.label_2, 1, 0, 1, 1)
self.label_3 = QtWidgets.QLabel(self.gridGroupBox)
self.label_3.setObjectName("label_3")
self.gridLayout_46.addWidget(self.label_3, 2, 0, 1, 1)
self.maxLinearVel = QtWidgets.QLineEdit(self.gridGroupBox)
self.maxLinearVel.setObjectName("maxLinearVel")
self.gridLayout_46.addWidget(self.maxLinearVel, 3, 1, 1, 1)
self.label_37 = QtWidgets.QLabel(self.gridGroupBox)
self.label_37.setObjectName("label_37")
self.gridLayout_46.addWidget(self.label_37, 3, 0, 1, 1)
self.label = QtWidgets.QLabel(self.gridGroupBox)
self.label.setObjectName("label")
self.gridLayout_46.addWidget(self.label, 0, 0, 1, 1)
self.label_10 = QtWidgets.QLabel(self.gridGroupBox)
self.label_10.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter)
self.label_10.setObjectName("label_10")
self.gridLayout_46.addWidget(self.label_10, 4, 0, 1, 1)
self.maxVelMinLB = QtWidgets.QLabel(self.gridGroupBox)
self.maxVelMinLB.setMinimumSize(QtCore.QSize(100, 0))
self.maxVelMinLB.setFrameShape(QtWidgets.QFrame.Box)
self.maxVelMinLB.setText("")
self.maxVelMinLB.setObjectName("maxVelMinLB")
self.gridLayout_46.addWidget(self.maxVelMinLB, 3, 2, 1, 1)
self.coordinatesLB = QtWidgets.QLabel(self.gridGroupBox)
self.coordinatesLB.setFrameShape(QtWidgets.QFrame.Box)
self.coordinatesLB.setText("")
self.coordinatesLB.setObjectName("coordinatesLB")
self.gridLayout_46.addWidget(self.coordinatesLB, 4, 1, 1, 2)
self.linearUnitsCB = QtWidgets.QComboBox(self.gridGroupBox)
self.linearUnitsCB.setObjectName("linearUnitsCB")
self.gridLayout_46.addWidget(self.linearUnitsCB, 2, 1, 1, 2)
self.pathLabel = QtWidgets.QLabel(self.gridGroupBox)
self.pathLabel.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.pathLabel.setText("")
self.pathLabel.setObjectName("pathLabel")
self.gridLayout_46.addWidget(self.pathLabel, 1, 1, 1, 2)
self.configName = QtWidgets.QLineEdit(self.gridGroupBox)
self.configName.setObjectName("configName")
self.gridLayout_46.addWidget(self.configName, 0, 1, 1, 2)
self.gridLayout_49.addWidget(self.gridGroupBox, 0, 0, 3, 1)
self.scrollArea = QtWidgets.QScrollArea(self.machine)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setObjectName("scrollArea")
self.scrollAreaWidgetContents = QtWidgets.QWidget()
self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 958, 420))
self.scrollAreaWidgetContents.setObjectName("scrollAreaWidgetContents")
self.horizontalLayout = QtWidgets.QHBoxLayout(self.scrollAreaWidgetContents)
self.horizontalLayout.setContentsMargins(8, 8, 8, 8)
self.horizontalLayout.setSpacing(5)
self.horizontalLayout.setObjectName("horizontalLayout")
self.machinePTE = QtWidgets.QPlainTextEdit(self.scrollAreaWidgetContents)
font = QtGui.QFont()
font.setFamily("Courier")
self.machinePTE.setFont(font)
self.machinePTE.setObjectName("machinePTE")
self.horizontalLayout.addWidget(self.machinePTE)
self.scrollArea.setWidget(self.scrollAreaWidgetContents)
self.gridLayout_49.addWidget(self.scrollArea, 4, 0, 1, 3)
self.label_292 = QtWidgets.QLabel(self.machine)
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
font.setItalic(True)
font.setWeight(75)
self.label_292.setFont(font)
self.label_292.setObjectName("label_292")
self.gridLayout_49.addWidget(self.label_292, 5, 0, 1, 1)
self.gridGroupBox1 = QtWidgets.QGroupBox(self.machine)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.gridGroupBox1.sizePolicy().hasHeightForWidth())
self.gridGroupBox1.setSizePolicy(sizePolicy)
self.gridGroupBox1.setMinimumSize(QtCore.QSize(350, 0))
self.gridGroupBox1.setStyleSheet("QGroupBox {\n"
" font: bold;\n"
" border: 2px solid silver;\n"
" border-radius: 6px;\n"
" margin-top: 6px;\n"
"}\n"
"\n"
"QGroupBox::title {\n"
" subcontrol-origin: margin;\n"
" left: 7px;\n"
" padding: 0px 5px 0px 5px;\n"
"}")
self.gridGroupBox1.setObjectName("gridGroupBox1")
self.gridLayout_26 = QtWidgets.QGridLayout(self.gridGroupBox1)
self.gridLayout_26.setContentsMargins(8, 15, 8, 8)
self.gridLayout_26.setSpacing(5)
self.gridLayout_26.setObjectName("gridLayout_26")
self.ipAddressCB = QtWidgets.QComboBox(self.gridGroupBox1)
self.ipAddressCB.setObjectName("ipAddressCB")
self.gridLayout_26.addWidget(self.ipAddressCB, 0, 1, 1, 1)
self.label_27 = QtWidgets.QLabel(self.gridGroupBox1)
self.label_27.setObjectName("label_27")
self.gridLayout_26.addWidget(self.label_27, 0, 0, 1, 1)
self.gridLayout_49.addWidget(self.gridGroupBox1, 0, 1, 3, 2)
self.gridGroupBox2 = QtWidgets.QGroupBox(self.machine)
self.gridGroupBox2.setStyleSheet("QGroupBox {\n"
" font: bold;\n"
" border: 2px solid silver;\n"
" border-radius: 6px;\n"
" margin-top: 6px;\n"
"}\n"
"\n"
"QGroupBox::title {\n"
" subcontrol-origin: margin;\n"
" left: 7px;\n"
" padding: 0px 5px 0px 5px;\n"
"}")
self.gridGroupBox2.setObjectName("gridGroupBox2")
self.gridLayout_29 = QtWidgets.QGridLayout(self.gridGroupBox2)
self.gridLayout_29.setContentsMargins(8, 15, 8, 8)
self.gridLayout_29.setSpacing(5)
self.gridLayout_29.setObjectName("gridLayout_29")
self.readPB = QtWidgets.QPushButton(self.gridGroupBox2)
self.readPB.setObjectName("readPB")
self.gridLayout_29.addWidget(self.readPB, 1, 2, 1, 1)
self.firmwareCB = QtWidgets.QComboBox(self.gridGroupBox2)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.firmwareCB.sizePolicy().hasHeightForWidth())
self.firmwareCB.setSizePolicy(sizePolicy)
self.firmwareCB.setMinimumSize(QtCore.QSize(200, 0))
self.firmwareCB.setObjectName("firmwareCB")
self.gridLayout_29.addWidget(self.firmwareCB, 1, 0, 1, 1)
self.reloadPB = QtWidgets.QPushButton(self.gridGroupBox2)
self.reloadPB.setObjectName("reloadPB")
self.gridLayout_29.addWidget(self.reloadPB, 1, 4, 1, 1)
self.copyPB = QtWidgets.QPushButton(self.gridGroupBox2)
self.copyPB.setObjectName("copyPB")
self.gridLayout_29.addWidget(self.copyPB, 1, 6, 1, 1)
self.firmwarePinsPB = QtWidgets.QPushButton(self.gridGroupBox2)
self.firmwarePinsPB.setObjectName("firmwarePinsPB")
self.gridLayout_29.addWidget(self.firmwarePinsPB, 1, 1, 1, 1)
self.flashPB = QtWidgets.QPushButton(self.gridGroupBox2)
self.flashPB.setObjectName("flashPB")
self.gridLayout_29.addWidget(self.flashPB, 1, 3, 1, 1)
self.verifyPB = QtWidgets.QPushButton(self.gridGroupBox2)
self.verifyPB.setObjectName("verifyPB")
self.gridLayout_29.addWidget(self.verifyPB, 1, 5, 1, 1)
self.gridLayout_49.addWidget(self.gridGroupBox2, 3, 0, 1, 2)
self.groupBox_27 = QtWidgets.QGroupBox(self.machine)
self.groupBox_27.setObjectName("groupBox_27")
self.gridLayout_66 = QtWidgets.QGridLayout(self.groupBox_27)
self.gridLayout_66.setContentsMargins(8, 8, 8, 8)
self.gridLayout_66.setSpacing(5)
self.gridLayout_66.setObjectName("gridLayout_66")
self.backupCB = QtWidgets.QCheckBox(self.groupBox_27)
self.backupCB.setChecked(True)
self.backupCB.setObjectName("backupCB")
self.gridLayout_66.addWidget(self.backupCB, 0, 0, 1, 1)
self.gridLayout_49.addWidget(self.groupBox_27, 3, 2, 1, 1)
self.tabWidget.addTab(self.machine, "")
self.display = QtWidgets.QWidget()
self.display.setObjectName("display")
self.gridGroupBox3 = QtWidgets.QGroupBox(self.display)
self.gridGroupBox3.setGeometry(QtCore.QRect(500, 10, 211, 80))
self.gridGroupBox3.setStyleSheet("QGroupBox {\n"
" font: bold;\n"
" border: 2px solid silver;\n"
" border-radius: 6px;\n"
" margin-top: 6px;\n"
"}\n"
"\n"
"QGroupBox::title {\n"
" subcontrol-origin: margin;\n"
" left: 7px;\n"
" padding: 0px 5px 0px 5px;\n"
"}")
self.gridGroupBox3.setObjectName("gridGroupBox3")
self.gridLayout_32 = QtWidgets.QGridLayout(self.gridGroupBox3)
self.gridLayout_32.setContentsMargins(8, 8, 8, 8)
self.gridLayout_32.setSpacing(5)
self.gridLayout_32.setObjectName("gridLayout_32")
self.frontToolLatheCB = QtWidgets.QCheckBox(self.gridGroupBox3)
self.frontToolLatheCB.setObjectName("frontToolLatheCB")
self.gridLayout_32.addWidget(self.frontToolLatheCB, 0, 0, 1, 1)
self.backToolLatheCB = QtWidgets.QCheckBox(self.gridGroupBox3)
self.backToolLatheCB.setObjectName("backToolLatheCB")
self.gridLayout_32.addWidget(self.backToolLatheCB, 1, 0, 1, 1)
self.gridGroupBox4 = QtWidgets.QGroupBox(self.display)
self.gridGroupBox4.setGeometry(QtCore.QRect(10, 10, 441, 171))
self.gridGroupBox4.setStyleSheet("QGroupBox {\n"
" font: bold;\n"
" border: 2px solid silver;\n"
" border-radius: 6px;\n"
" margin-top: 6px;\n"
"}\n"
"\n"
"QGroupBox::title {\n"
" subcontrol-origin: margin;\n"
" left: 7px;\n"
" padding: 0px 5px 0px 5px;\n"
"}")
self.gridGroupBox4.setObjectName("gridGroupBox4")
self.gridLayout_47 = QtWidgets.QGridLayout(self.gridGroupBox4)
self.gridLayout_47.setContentsMargins(9, 15, 9, 9)
self.gridLayout_47.setSpacing(5)
self.gridLayout_47.setObjectName("gridLayout_47")
self.positionOffsetCB = QtWidgets.QComboBox(self.gridGroupBox4)
self.positionOffsetCB.setObjectName("positionOffsetCB")
self.gridLayout_47.addWidget(self.positionOffsetCB, 1, 1, 1, 1)
self.positionFeedbackCB = QtWidgets.QComboBox(self.gridGroupBox4)
self.positionFeedbackCB.setObjectName("positionFeedbackCB")
self.gridLayout_47.addWidget(self.positionFeedbackCB, 2, 1, 1, 1)
self.maxFeedOverrideSB = QtWidgets.QDoubleSpinBox(self.gridGroupBox4)
self.maxFeedOverrideSB.setDecimals(1)
self.maxFeedOverrideSB.setMaximum(2.0)
self.maxFeedOverrideSB.setSingleStep(0.1)
self.maxFeedOverrideSB.setProperty("value", 1.2)
self.maxFeedOverrideSB.setObjectName("maxFeedOverrideSB")
self.gridLayout_47.addWidget(self.maxFeedOverrideSB, 3, 1, 1, 1)
self.label_40 = QtWidgets.QLabel(self.gridGroupBox4)
self.label_40.setObjectName("label_40")
self.gridLayout_47.addWidget(self.label_40, 0, 0, 1, 1)
self.label_41 = QtWidgets.QLabel(self.gridGroupBox4)
self.label_41.setObjectName("label_41")
self.gridLayout_47.addWidget(self.label_41, 1, 0, 1, 1)
self.guiCB = QtWidgets.QComboBox(self.gridGroupBox4)
self.guiCB.setObjectName("guiCB")
self.gridLayout_47.addWidget(self.guiCB, 0, 1, 1, 1)
self.label_42 = QtWidgets.QLabel(self.gridGroupBox4)
self.label_42.setObjectName("label_42")
self.gridLayout_47.addWidget(self.label_42, 2, 0, 1, 1)
self.label_9 = QtWidgets.QLabel(self.gridGroupBox4)
self.label_9.setObjectName("label_9")
self.gridLayout_47.addWidget(self.label_9, 3, 0, 1, 1)
self.label_179 = QtWidgets.QLabel(self.gridGroupBox4)
self.label_179.setObjectName("label_179")
self.gridLayout_47.addWidget(self.label_179, 3, 2, 1, 1)
self.groupBox_60 = QtWidgets.QGroupBox(self.display)
self.groupBox_60.setGeometry(QtCore.QRect(10, 200, 270, 60))
self.groupBox_60.setObjectName("groupBox_60")
self.gridLayout_45 = QtWidgets.QGridLayout(self.groupBox_60)
self.gridLayout_45.setContentsMargins(8, 8, 8, 8)
self.gridLayout_45.setSpacing(5)
self.gridLayout_45.setObjectName("gridLayout_45")
self.editorCB = QtWidgets.QComboBox(self.groupBox_60)
self.editorCB.setObjectName("editorCB")
self.gridLayout_45.addWidget(self.editorCB, 0, 0, 1, 1)
self.groupBox_61 = QtWidgets.QGroupBox(self.display)
self.groupBox_61.setGeometry(QtCore.QRect(10, 270, 441, 60))
self.groupBox_61.setObjectName("groupBox_61")
self.gridLayout_107 = QtWidgets.QGridLayout(self.groupBox_61)
self.gridLayout_107.setContentsMargins(8, 8, 8, 8)
self.gridLayout_107.setSpacing(5)
self.gridLayout_107.setObjectName("gridLayout_107")
self.label_21 = QtWidgets.QLabel(self.groupBox_61)
self.label_21.setObjectName("label_21")
self.gridLayout_107.addWidget(self.label_21, 0, 0, 1, 1)
self.defaultJogSpeedDSB = QtWidgets.QDoubleSpinBox(self.groupBox_61)
self.defaultJogSpeedDSB.setDecimals(1)
self.defaultJogSpeedDSB.setSingleStep(0.1)
self.defaultJogSpeedDSB.setProperty("value", 0.5)
self.defaultJogSpeedDSB.setObjectName("defaultJogSpeedDSB")
self.gridLayout_107.addWidget(self.defaultJogSpeedDSB, 0, 1, 1, 1)
self.jogSpeedLB = QtWidgets.QLabel(self.groupBox_61)
self.jogSpeedLB.setFrameShape(QtWidgets.QFrame.Box)
self.jogSpeedLB.setText("")
self.jogSpeedLB.setObjectName("jogSpeedLB")
self.gridLayout_107.addWidget(self.jogSpeedLB, 0, 2, 1, 1)
self.tabWidget.addTab(self.display, "")
self.axisTab = QtWidgets.QWidget()
self.axisTab.setEnabled(True)
self.axisTab.setObjectName("axisTab")
self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.axisTab)
self.verticalLayout_2.setContentsMargins(8, 8, 8, 8)
self.verticalLayout_2.setSpacing(5)
self.verticalLayout_2.setObjectName("verticalLayout_2")
self.jointType_3 = QtWidgets.QTabWidget(self.axisTab)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.jointType_3.sizePolicy().hasHeightForWidth())
self.jointType_3.setSizePolicy(sizePolicy)
self.jointType_3.setToolTip("")
self.jointType_3.setTabPosition(QtWidgets.QTabWidget.North)
self.jointType_3.setObjectName("jointType_3")
self.joint0tab = QtWidgets.QWidget()
self.joint0tab.setObjectName("joint0tab")
self.gridLayout_2 = QtWidgets.QGridLayout(self.joint0tab)
self.gridLayout_2.setContentsMargins(8, 8, 8, 8)
self.gridLayout_2.setSpacing(5)
self.gridLayout_2.setObjectName("gridLayout_2")
self.groupBox_2 = QtWidgets.QGroupBox(self.joint0tab)
self.groupBox_2.setStyleSheet("")
self.groupBox_2.setObjectName("groupBox_2")
self.gridLayout = QtWidgets.QGridLayout(self.groupBox_2)
self.gridLayout.setContentsMargins(10, 10, 10, 10)
self.gridLayout.setSpacing(5)
self.gridLayout.setObjectName("gridLayout")
self.label_215 = QtWidgets.QLabel(self.groupBox_2)
self.label_215.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_215.setObjectName("label_215")
self.gridLayout.addWidget(self.label_215, 0, 0, 1, 1)
self.p_0 = QtWidgets.QLineEdit(self.groupBox_2)
self.p_0.setText("")
self.p_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.p_0.setObjectName("p_0")
self.gridLayout.addWidget(self.p_0, 0, 1, 1, 1)
self.label_214 = QtWidgets.QLabel(self.groupBox_2)
self.label_214.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_214.setObjectName("label_214")
self.gridLayout.addWidget(self.label_214, 0, 2, 1, 1)
self.deadband_0 = QtWidgets.QLineEdit(self.groupBox_2)
self.deadband_0.setText("")
self.deadband_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.deadband_0.setObjectName("deadband_0")
self.gridLayout.addWidget(self.deadband_0, 0, 3, 1, 1)
self.label_216 = QtWidgets.QLabel(self.groupBox_2)
self.label_216.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_216.setObjectName("label_216")
self.gridLayout.addWidget(self.label_216, 1, 0, 1, 1)
self.i_0 = QtWidgets.QLineEdit(self.groupBox_2)
self.i_0.setText("")
self.i_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.i_0.setObjectName("i_0")
self.gridLayout.addWidget(self.i_0, 1, 1, 1, 1)
self.label_221 = QtWidgets.QLabel(self.groupBox_2)
self.label_221.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_221.setObjectName("label_221")
self.gridLayout.addWidget(self.label_221, 1, 2, 1, 1)
self.bias_0 = QtWidgets.QLineEdit(self.groupBox_2)
self.bias_0.setText("")
self.bias_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.bias_0.setObjectName("bias_0")
self.gridLayout.addWidget(self.bias_0, 1, 3, 1, 1)
self.label_217 = QtWidgets.QLabel(self.groupBox_2)
self.label_217.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_217.setObjectName("label_217")
self.gridLayout.addWidget(self.label_217, 2, 0, 1, 1)
self.d_0 = QtWidgets.QLineEdit(self.groupBox_2)
self.d_0.setText("")
self.d_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.d_0.setObjectName("d_0")
self.gridLayout.addWidget(self.d_0, 2, 1, 1, 1)
self.label_222 = QtWidgets.QLabel(self.groupBox_2)
self.label_222.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_222.setObjectName("label_222")
self.gridLayout.addWidget(self.label_222, 2, 2, 1, 1)
self.maxOutput_0 = QtWidgets.QLineEdit(self.groupBox_2)
self.maxOutput_0.setText("")
self.maxOutput_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxOutput_0.setObjectName("maxOutput_0")
self.gridLayout.addWidget(self.maxOutput_0, 2, 3, 1, 1)
self.label_218 = QtWidgets.QLabel(self.groupBox_2)
self.label_218.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_218.setObjectName("label_218")
self.gridLayout.addWidget(self.label_218, 3, 0, 1, 1)
self.ff0_0 = QtWidgets.QLineEdit(self.groupBox_2)
self.ff0_0.setText("")
self.ff0_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff0_0.setObjectName("ff0_0")
self.gridLayout.addWidget(self.ff0_0, 3, 1, 1, 1)
self.label_219 = QtWidgets.QLabel(self.groupBox_2)
self.label_219.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_219.setObjectName("label_219")
self.gridLayout.addWidget(self.label_219, 4, 0, 1, 1)
self.ff1_0 = QtWidgets.QLineEdit(self.groupBox_2)
self.ff1_0.setText("")
self.ff1_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff1_0.setObjectName("ff1_0")
self.gridLayout.addWidget(self.ff1_0, 4, 1, 1, 1)
self.label_220 = QtWidgets.QLabel(self.groupBox_2)
self.label_220.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_220.setObjectName("label_220")
self.gridLayout.addWidget(self.label_220, 5, 0, 1, 1)
self.ff2_0 = QtWidgets.QLineEdit(self.groupBox_2)
self.ff2_0.setText("")
self.ff2_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff2_0.setObjectName("ff2_0")
self.gridLayout.addWidget(self.ff2_0, 5, 1, 1, 1)
self.pidDefault_0 = QtWidgets.QPushButton(self.groupBox_2)
self.pidDefault_0.setObjectName("pidDefault_0")
self.gridLayout.addWidget(self.pidDefault_0, 5, 3, 1, 1)
self.label_183 = QtWidgets.QLabel(self.groupBox_2)
self.label_183.setObjectName("label_183")
self.gridLayout.addWidget(self.label_183, 3, 2, 1, 1)
self.maxError_0 = QtWidgets.QLineEdit(self.groupBox_2)
self.maxError_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxError_0.setObjectName("maxError_0")
self.gridLayout.addWidget(self.maxError_0, 3, 3, 1, 1)
self.gridLayout_2.addWidget(self.groupBox_2, 1, 0, 1, 1)
self.jointAxisGroup_0 = QtWidgets.QGroupBox(self.joint0tab)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.jointAxisGroup_0.sizePolicy().hasHeightForWidth())
self.jointAxisGroup_0.setSizePolicy(sizePolicy)
self.jointAxisGroup_0.setStyleSheet("")
self.jointAxisGroup_0.setObjectName("jointAxisGroup_0")
self.gridLayout_4 = QtWidgets.QGridLayout(self.jointAxisGroup_0)
self.gridLayout_4.setContentsMargins(10, 10, 10, 10)
self.gridLayout_4.setSpacing(5)
self.gridLayout_4.setObjectName("gridLayout_4")
self.minLimit_0 = QtWidgets.QLineEdit(self.jointAxisGroup_0)
self.minLimit_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.minLimit_0.setObjectName("minLimit_0")
self.gridLayout_4.addWidget(self.minLimit_0, 2, 3, 1, 1)
self.maxLimit_0 = QtWidgets.QLineEdit(self.jointAxisGroup_0)
self.maxLimit_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxLimit_0.setObjectName("maxLimit_0")
self.gridLayout_4.addWidget(self.maxLimit_0, 2, 4, 1, 1)
self.maxVelocity_0 = QtWidgets.QLineEdit(self.jointAxisGroup_0)
self.maxVelocity_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxVelocity_0.setObjectName("maxVelocity_0")
self.gridLayout_4.addWidget(self.maxVelocity_0, 2, 5, 1, 1)
self.axisCB_0 = QtWidgets.QComboBox(self.jointAxisGroup_0)
self.axisCB_0.setObjectName("axisCB_0")
self.gridLayout_4.addWidget(self.axisCB_0, 2, 0, 1, 1)
self.maxAccel_0 = QtWidgets.QLineEdit(self.jointAxisGroup_0)
self.maxAccel_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxAccel_0.setObjectName("maxAccel_0")
self.gridLayout_4.addWidget(self.maxAccel_0, 2, 6, 1, 1)
self.reverse_0 = QtWidgets.QCheckBox(self.jointAxisGroup_0)
self.reverse_0.setObjectName("reverse_0")
self.gridLayout_4.addWidget(self.reverse_0, 2, 7, 1, 1)
self.scale_0 = QtWidgets.QLineEdit(self.jointAxisGroup_0)
self.scale_0.setObjectName("scale_0")
self.gridLayout_4.addWidget(self.scale_0, 2, 2, 1, 1)
self.axisType_0 = QtWidgets.QLabel(self.jointAxisGroup_0)
self.axisType_0.setFrameShape(QtWidgets.QFrame.Box)
self.axisType_0.setText("")
self.axisType_0.setObjectName("axisType_0")
self.gridLayout_4.addWidget(self.axisType_0, 2, 1, 1, 1)
self.label_45 = QtWidgets.QLabel(self.jointAxisGroup_0)
self.label_45.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_45.setObjectName("label_45")
self.gridLayout_4.addWidget(self.label_45, 0, 2, 1, 1)
self.label_43 = QtWidgets.QLabel(self.jointAxisGroup_0)
self.label_43.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_43.setObjectName("label_43")
self.gridLayout_4.addWidget(self.label_43, 0, 0, 1, 1)
self.label_4 = QtWidgets.QLabel(self.jointAxisGroup_0)
self.label_4.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft)
self.label_4.setObjectName("label_4")
self.gridLayout_4.addWidget(self.label_4, 0, 1, 1, 1)
self.label_62 = QtWidgets.QLabel(self.jointAxisGroup_0)
self.label_62.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_62.setWordWrap(True)
self.label_62.setObjectName("label_62")
self.gridLayout_4.addWidget(self.label_62, 0, 3, 1, 1)
self.label_67 = QtWidgets.QLabel(self.jointAxisGroup_0)
self.label_67.setTextFormat(QtCore.Qt.AutoText)
self.label_67.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_67.setWordWrap(True)
self.label_67.setObjectName("label_67")
self.gridLayout_4.addWidget(self.label_67, 0, 4, 1, 1)
self.label_72 = QtWidgets.QLabel(self.jointAxisGroup_0)
self.label_72.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_72.setWordWrap(True)
self.label_72.setObjectName("label_72")
self.gridLayout_4.addWidget(self.label_72, 0, 5, 1, 1)
self.label_73 = QtWidgets.QLabel(self.jointAxisGroup_0)
self.label_73.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_73.setWordWrap(True)
self.label_73.setObjectName("label_73")
self.gridLayout_4.addWidget(self.label_73, 0, 6, 1, 1)
self.gridLayout_2.addWidget(self.jointAxisGroup_0, 0, 0, 1, 2)
self.groupBox_3 = QtWidgets.QGroupBox(self.joint0tab)
self.groupBox_3.setStyleSheet("")
self.groupBox_3.setObjectName("groupBox_3")
self.gridLayout_3 = QtWidgets.QGridLayout(self.groupBox_3)
self.gridLayout_3.setContentsMargins(10, 10, 10, 10)
self.gridLayout_3.setSpacing(5)
self.gridLayout_3.setObjectName("gridLayout_3")
self.label_83 = QtWidgets.QLabel(self.groupBox_3)
self.label_83.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_83.setObjectName("label_83")
self.gridLayout_3.addWidget(self.label_83, 1, 0, 1, 1)
self.label_38 = QtWidgets.QLabel(self.groupBox_3)
self.label_38.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_38.setObjectName("label_38")
self.gridLayout_3.addWidget(self.label_38, 5, 0, 1, 1)
self.label_84 = QtWidgets.QLabel(self.groupBox_3)
self.label_84.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_84.setObjectName("label_84")
self.gridLayout_3.addWidget(self.label_84, 2, 0, 1, 1)
self.homeOffset_0 = QtWidgets.QLineEdit(self.groupBox_3)
self.homeOffset_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeOffset_0.setObjectName("homeOffset_0")
self.gridLayout_3.addWidget(self.homeOffset_0, 1, 1, 1, 1)
self.homeIgnoreLimits_0 = QtWidgets.QCheckBox(self.groupBox_3)
self.homeIgnoreLimits_0.setObjectName("homeIgnoreLimits_0")
self.gridLayout_3.addWidget(self.homeIgnoreLimits_0, 7, 1, 1, 1)
self.label_85 = QtWidgets.QLabel(self.groupBox_3)
self.label_85.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_85.setObjectName("label_85")
self.gridLayout_3.addWidget(self.label_85, 3, 0, 1, 1)
self.homeSequence_0 = QtWidgets.QLineEdit(self.groupBox_3)
self.homeSequence_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeSequence_0.setObjectName("homeSequence_0")
self.gridLayout_3.addWidget(self.homeSequence_0, 5, 1, 1, 1)
self.homeSwitchShared_0 = QtWidgets.QCheckBox(self.groupBox_3)
self.homeSwitchShared_0.setObjectName("homeSwitchShared_0")
self.gridLayout_3.addWidget(self.homeSwitchShared_0, 9, 1, 1, 1)
self.homeLatchVel_0 = QtWidgets.QLineEdit(self.groupBox_3)
self.homeLatchVel_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeLatchVel_0.setObjectName("homeLatchVel_0")
self.gridLayout_3.addWidget(self.homeLatchVel_0, 3, 1, 1, 1)
self.homeUseIndex_0 = QtWidgets.QCheckBox(self.groupBox_3)
self.homeUseIndex_0.setObjectName("homeUseIndex_0")
self.gridLayout_3.addWidget(self.homeUseIndex_0, 8, 1, 1, 1)
self.label_82 = QtWidgets.QLabel(self.groupBox_3)
self.label_82.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_82.setObjectName("label_82")
self.gridLayout_3.addWidget(self.label_82, 0, 0, 1, 1)
self.home_0 = QtWidgets.QLineEdit(self.groupBox_3)
self.home_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.home_0.setObjectName("home_0")
self.gridLayout_3.addWidget(self.home_0, 0, 1, 1, 1)
self.homeSearchVel_0 = QtWidgets.QLineEdit(self.groupBox_3)
self.homeSearchVel_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeSearchVel_0.setObjectName("homeSearchVel_0")
self.gridLayout_3.addWidget(self.homeSearchVel_0, 2, 1, 1, 1)
self.label_11 = QtWidgets.QLabel(self.groupBox_3)
self.label_11.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_11.setObjectName("label_11")
self.gridLayout_3.addWidget(self.label_11, 4, 0, 1, 1)
self.homeFinalVelocity_0 = QtWidgets.QLineEdit(self.groupBox_3)
self.homeFinalVelocity_0.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeFinalVelocity_0.setObjectName("homeFinalVelocity_0")
self.gridLayout_3.addWidget(self.homeFinalVelocity_0, 4, 1, 1, 1)
self.gridLayout_2.addWidget(self.groupBox_3, 1, 1, 1, 1)
self.analogGB_0 = QtWidgets.QGroupBox(self.joint0tab)
self.analogGB_0.setObjectName("analogGB_0")
self.gridLayout_115 = QtWidgets.QGridLayout(self.analogGB_0)
self.gridLayout_115.setContentsMargins(8, 8, 8, 8)
self.gridLayout_115.setSpacing(5)
self.gridLayout_115.setObjectName("gridLayout_115")
self.analogScaleMax_0 = QtWidgets.QLineEdit(self.analogGB_0)
self.analogScaleMax_0.setObjectName("analogScaleMax_0")
self.gridLayout_115.addWidget(self.analogScaleMax_0, 2, 1, 1, 1)
self.label_18 = QtWidgets.QLabel(self.analogGB_0)
self.label_18.setObjectName("label_18")
self.gridLayout_115.addWidget(self.label_18, 1, 0, 1, 1)
self.analogMinLimit_0 = QtWidgets.QLineEdit(self.analogGB_0)
self.analogMinLimit_0.setObjectName("analogMinLimit_0")
self.gridLayout_115.addWidget(self.analogMinLimit_0, 0, 1, 1, 1)
self.label_19 = QtWidgets.QLabel(self.analogGB_0)
self.label_19.setObjectName("label_19")
self.gridLayout_115.addWidget(self.label_19, 2, 0, 1, 1)
self.analogMaxLimit_0 = QtWidgets.QLineEdit(self.analogGB_0)
self.analogMaxLimit_0.setObjectName("analogMaxLimit_0")
self.gridLayout_115.addWidget(self.analogMaxLimit_0, 1, 1, 1, 1)
self.analogDefault_0 = QtWidgets.QPushButton(self.analogGB_0)
self.analogDefault_0.setObjectName("analogDefault_0")
self.gridLayout_115.addWidget(self.analogDefault_0, 0, 2, 1, 1)
self.label_17 = QtWidgets.QLabel(self.analogGB_0)
self.label_17.setObjectName("label_17")
self.gridLayout_115.addWidget(self.label_17, 0, 0, 1, 1)
self.gridLayout_2.addWidget(self.analogGB_0, 2, 0, 1, 1)
self.gridGroupBox5 = QtWidgets.QGroupBox(self.joint0tab)
self.gridGroupBox5.setStyleSheet("")
self.gridGroupBox5.setObjectName("gridGroupBox5")
self.gridLayout_27 = QtWidgets.QGridLayout(self.gridGroupBox5)
self.gridLayout_27.setContentsMargins(8, 8, 8, 8)
self.gridLayout_27.setSpacing(5)
self.gridLayout_27.setObjectName("gridLayout_27")
self.timeJoint_0 = QtWidgets.QLabel(self.gridGroupBox5)
self.timeJoint_0.setFrameShape(QtWidgets.QFrame.Box)
self.timeJoint_0.setObjectName("timeJoint_0")
self.gridLayout_27.addWidget(self.timeJoint_0, 0, 1, 1, 1)
self.label_181 = QtWidgets.QLabel(self.gridGroupBox5)
self.label_181.setObjectName("label_181")
self.gridLayout_27.addWidget(self.label_181, 0, 0, 1, 1)
self.label_182 = QtWidgets.QLabel(self.gridGroupBox5)
self.label_182.setObjectName("label_182")
self.gridLayout_27.addWidget(self.label_182, 1, 0, 1, 1)
self.distanceJoint_0 = QtWidgets.QLabel(self.gridGroupBox5)
self.distanceJoint_0.setFrameShape(QtWidgets.QFrame.Box)
self.distanceJoint_0.setObjectName("distanceJoint_0")
self.gridLayout_27.addWidget(self.distanceJoint_0, 1, 1, 1, 1)
self.label_185 = QtWidgets.QLabel(self.gridGroupBox5)
self.label_185.setObjectName("label_185")
self.gridLayout_27.addWidget(self.label_185, 2, 0, 1, 1)
self.stepRateJoint_0 = QtWidgets.QLabel(self.gridGroupBox5)
self.stepRateJoint_0.setFrameShape(QtWidgets.QFrame.Box)
self.stepRateJoint_0.setObjectName("stepRateJoint_0")
self.gridLayout_27.addWidget(self.stepRateJoint_0, 2, 1, 1, 1)
self.gridLayout_2.addWidget(self.gridGroupBox5, 2, 1, 1, 1)
self.groupBox_4 = QtWidgets.QGroupBox(self.joint0tab)
self.groupBox_4.setObjectName("groupBox_4")
self.gridLayout_19 = QtWidgets.QGridLayout(self.groupBox_4)
self.gridLayout_19.setContentsMargins(8, 8, 8, 8)
self.gridLayout_19.setSpacing(5)
self.gridLayout_19.setObjectName("gridLayout_19")
self.label_8 = QtWidgets.QLabel(self.groupBox_4)
self.label_8.setObjectName("label_8")
self.gridLayout_19.addWidget(self.label_8, 0, 0, 1, 1)
self.encoderScale_0 = QtWidgets.QLineEdit(self.groupBox_4)
self.encoderScale_0.setObjectName("encoderScale_0")
self.gridLayout_19.addWidget(self.encoderScale_0, 0, 1, 1, 1)
self.gridLayout_2.addWidget(self.groupBox_4, 3, 0, 1, 1)
self.jointType_3.addTab(self.joint0tab, "")
self.joint1tab = QtWidgets.QWidget()
self.joint1tab.setObjectName("joint1tab")
self.gridLayout_5 = QtWidgets.QGridLayout(self.joint1tab)
self.gridLayout_5.setContentsMargins(8, 8, 8, 8)
self.gridLayout_5.setSpacing(5)
self.gridLayout_5.setObjectName("gridLayout_5")
self.groupBox_5 = QtWidgets.QGroupBox(self.joint1tab)
self.groupBox_5.setObjectName("groupBox_5")
self.gridLayout_6 = QtWidgets.QGridLayout(self.groupBox_5)
self.gridLayout_6.setContentsMargins(8, 8, 8, 8)
self.gridLayout_6.setSpacing(5)
self.gridLayout_6.setObjectName("gridLayout_6")
self.homeSwitchShared_1 = QtWidgets.QCheckBox(self.groupBox_5)
self.homeSwitchShared_1.setObjectName("homeSwitchShared_1")
self.gridLayout_6.addWidget(self.homeSwitchShared_1, 10, 1, 1, 1)
self.label_88 = QtWidgets.QLabel(self.groupBox_5)
self.label_88.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_88.setObjectName("label_88")
self.gridLayout_6.addWidget(self.label_88, 2, 0, 1, 1)
self.home_1 = QtWidgets.QLineEdit(self.groupBox_5)
self.home_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.home_1.setObjectName("home_1")
self.gridLayout_6.addWidget(self.home_1, 0, 1, 1, 2)
self.label_39 = QtWidgets.QLabel(self.groupBox_5)
self.label_39.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_39.setObjectName("label_39")
self.gridLayout_6.addWidget(self.label_39, 6, 0, 1, 1)
self.homeOffset_1 = QtWidgets.QLineEdit(self.groupBox_5)
self.homeOffset_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeOffset_1.setObjectName("homeOffset_1")
self.gridLayout_6.addWidget(self.homeOffset_1, 1, 1, 1, 2)
self.homeIgnoreLimits_1 = QtWidgets.QCheckBox(self.groupBox_5)
self.homeIgnoreLimits_1.setObjectName("homeIgnoreLimits_1")
self.gridLayout_6.addWidget(self.homeIgnoreLimits_1, 8, 1, 1, 2)
self.homeUseIndex_1 = QtWidgets.QCheckBox(self.groupBox_5)
self.homeUseIndex_1.setObjectName("homeUseIndex_1")
self.gridLayout_6.addWidget(self.homeUseIndex_1, 9, 1, 1, 1)
self.homeSearchVel_1 = QtWidgets.QLineEdit(self.groupBox_5)
self.homeSearchVel_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeSearchVel_1.setObjectName("homeSearchVel_1")
self.gridLayout_6.addWidget(self.homeSearchVel_1, 2, 1, 1, 2)
self.label_12 = QtWidgets.QLabel(self.groupBox_5)
self.label_12.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_12.setObjectName("label_12")
self.gridLayout_6.addWidget(self.label_12, 5, 0, 1, 1)
self.homeLatchVel_1 = QtWidgets.QLineEdit(self.groupBox_5)
self.homeLatchVel_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeLatchVel_1.setObjectName("homeLatchVel_1")
self.gridLayout_6.addWidget(self.homeLatchVel_1, 3, 1, 1, 2)
self.label_86 = QtWidgets.QLabel(self.groupBox_5)
self.label_86.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_86.setObjectName("label_86")
self.gridLayout_6.addWidget(self.label_86, 0, 0, 1, 1)
self.label_89 = QtWidgets.QLabel(self.groupBox_5)
self.label_89.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_89.setObjectName("label_89")
self.gridLayout_6.addWidget(self.label_89, 3, 0, 1, 1)
self.label_87 = QtWidgets.QLabel(self.groupBox_5)
self.label_87.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_87.setObjectName("label_87")
self.gridLayout_6.addWidget(self.label_87, 1, 0, 1, 1)
self.homeFinalVelocity_1 = QtWidgets.QLineEdit(self.groupBox_5)
self.homeFinalVelocity_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeFinalVelocity_1.setObjectName("homeFinalVelocity_1")
self.gridLayout_6.addWidget(self.homeFinalVelocity_1, 5, 1, 1, 2)
self.homeSequence_1 = QtWidgets.QLineEdit(self.groupBox_5)
self.homeSequence_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeSequence_1.setObjectName("homeSequence_1")
self.gridLayout_6.addWidget(self.homeSequence_1, 6, 1, 1, 1)
self.gridLayout_5.addWidget(self.groupBox_5, 1, 1, 1, 1)
self.gridGroupBox6 = QtWidgets.QGroupBox(self.joint1tab)
self.gridGroupBox6.setObjectName("gridGroupBox6")
self.gridLayout_33 = QtWidgets.QGridLayout(self.gridGroupBox6)
self.gridLayout_33.setContentsMargins(8, 8, 8, 8)
self.gridLayout_33.setSpacing(5)
self.gridLayout_33.setObjectName("gridLayout_33")
self.label_189 = QtWidgets.QLabel(self.gridGroupBox6)
self.label_189.setObjectName("label_189")
self.gridLayout_33.addWidget(self.label_189, 0, 0, 1, 1, QtCore.Qt.AlignRight)
self.label_191 = QtWidgets.QLabel(self.gridGroupBox6)
self.label_191.setObjectName("label_191")
self.gridLayout_33.addWidget(self.label_191, 2, 0, 1, 1, QtCore.Qt.AlignRight)
self.label_190 = QtWidgets.QLabel(self.gridGroupBox6)
self.label_190.setObjectName("label_190")
self.gridLayout_33.addWidget(self.label_190, 1, 0, 1, 1, QtCore.Qt.AlignRight)
self.timeJoint_1 = QtWidgets.QLabel(self.gridGroupBox6)
self.timeJoint_1.setFrameShape(QtWidgets.QFrame.Box)
self.timeJoint_1.setText("")
self.timeJoint_1.setObjectName("timeJoint_1")
self.gridLayout_33.addWidget(self.timeJoint_1, 0, 1, 1, 1)
self.distanceJoint_1 = QtWidgets.QLabel(self.gridGroupBox6)
self.distanceJoint_1.setFrameShape(QtWidgets.QFrame.Box)
self.distanceJoint_1.setText("")
self.distanceJoint_1.setObjectName("distanceJoint_1")
self.gridLayout_33.addWidget(self.distanceJoint_1, 1, 1, 1, 1)
self.stepRateJoint_1 = QtWidgets.QLabel(self.gridGroupBox6)
self.stepRateJoint_1.setFrameShape(QtWidgets.QFrame.Box)
self.stepRateJoint_1.setText("")
self.stepRateJoint_1.setObjectName("stepRateJoint_1")
self.gridLayout_33.addWidget(self.stepRateJoint_1, 2, 1, 1, 1)
self.gridLayout_5.addWidget(self.gridGroupBox6, 2, 1, 1, 1)
self.jointAxisGroup_1 = QtWidgets.QGroupBox(self.joint1tab)
self.jointAxisGroup_1.setObjectName("jointAxisGroup_1")
self.gridLayout_7 = QtWidgets.QGridLayout(self.jointAxisGroup_1)
self.gridLayout_7.setContentsMargins(10, 10, 10, 10)
self.gridLayout_7.setSpacing(5)
self.gridLayout_7.setObjectName("gridLayout_7")
self.axisCB_1 = QtWidgets.QComboBox(self.jointAxisGroup_1)
self.axisCB_1.setObjectName("axisCB_1")
self.gridLayout_7.addWidget(self.axisCB_1, 1, 0, 1, 1)
self.label_75 = QtWidgets.QLabel(self.jointAxisGroup_1)
self.label_75.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_75.setWordWrap(True)
self.label_75.setObjectName("label_75")
self.gridLayout_7.addWidget(self.label_75, 0, 6, 1, 1)
self.label_63 = QtWidgets.QLabel(self.jointAxisGroup_1)
self.label_63.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_63.setWordWrap(True)
self.label_63.setObjectName("label_63")
self.gridLayout_7.addWidget(self.label_63, 0, 3, 1, 1)
self.label_50 = QtWidgets.QLabel(self.jointAxisGroup_1)
self.label_50.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_50.setObjectName("label_50")
self.gridLayout_7.addWidget(self.label_50, 0, 0, 1, 1)
self.minLimit_1 = QtWidgets.QLineEdit(self.jointAxisGroup_1)
self.minLimit_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.minLimit_1.setObjectName("minLimit_1")
self.gridLayout_7.addWidget(self.minLimit_1, 1, 3, 1, 1)
self.maxLimit_1 = QtWidgets.QLineEdit(self.jointAxisGroup_1)
self.maxLimit_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxLimit_1.setObjectName("maxLimit_1")
self.gridLayout_7.addWidget(self.maxLimit_1, 1, 4, 1, 1)
self.label_68 = QtWidgets.QLabel(self.jointAxisGroup_1)
self.label_68.setTextFormat(QtCore.Qt.AutoText)
self.label_68.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_68.setWordWrap(True)
self.label_68.setObjectName("label_68")
self.gridLayout_7.addWidget(self.label_68, 0, 4, 1, 1)
self.label_74 = QtWidgets.QLabel(self.jointAxisGroup_1)
self.label_74.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_74.setWordWrap(True)
self.label_74.setObjectName("label_74")
self.gridLayout_7.addWidget(self.label_74, 0, 5, 1, 1)
self.maxVelocity_1 = QtWidgets.QLineEdit(self.jointAxisGroup_1)
self.maxVelocity_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxVelocity_1.setObjectName("maxVelocity_1")
self.gridLayout_7.addWidget(self.maxVelocity_1, 1, 5, 1, 1)
self.label_52 = QtWidgets.QLabel(self.jointAxisGroup_1)
self.label_52.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_52.setObjectName("label_52")
self.gridLayout_7.addWidget(self.label_52, 0, 2, 1, 1)
self.maxAccel_1 = QtWidgets.QLineEdit(self.jointAxisGroup_1)
self.maxAccel_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxAccel_1.setObjectName("maxAccel_1")
self.gridLayout_7.addWidget(self.maxAccel_1, 1, 6, 1, 1)
self.label_5 = QtWidgets.QLabel(self.jointAxisGroup_1)
self.label_5.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft)
self.label_5.setObjectName("label_5")
self.gridLayout_7.addWidget(self.label_5, 0, 1, 1, 1)
self.axisType_1 = QtWidgets.QLabel(self.jointAxisGroup_1)
self.axisType_1.setFrameShape(QtWidgets.QFrame.Box)
self.axisType_1.setText("")
self.axisType_1.setObjectName("axisType_1")
self.gridLayout_7.addWidget(self.axisType_1, 1, 1, 1, 1)
self.scale_1 = QtWidgets.QLineEdit(self.jointAxisGroup_1)
self.scale_1.setObjectName("scale_1")
self.gridLayout_7.addWidget(self.scale_1, 1, 2, 1, 1)
self.reverse_1 = QtWidgets.QCheckBox(self.jointAxisGroup_1)
self.reverse_1.setObjectName("reverse_1")
self.gridLayout_7.addWidget(self.reverse_1, 1, 7, 1, 1)
self.gridLayout_5.addWidget(self.jointAxisGroup_1, 0, 0, 1, 2)
self.analogGB_1 = QtWidgets.QGroupBox(self.joint1tab)
self.analogGB_1.setObjectName("analogGB_1")
self.gridLayout_116 = QtWidgets.QGridLayout(self.analogGB_1)
self.gridLayout_116.setContentsMargins(8, 8, 8, 8)
self.gridLayout_116.setSpacing(5)
self.gridLayout_116.setObjectName("gridLayout_116")
self.analogScaleMax_1 = QtWidgets.QLineEdit(self.analogGB_1)
self.analogScaleMax_1.setObjectName("analogScaleMax_1")
self.gridLayout_116.addWidget(self.analogScaleMax_1, 2, 1, 1, 1)
self.label_20 = QtWidgets.QLabel(self.analogGB_1)
self.label_20.setObjectName("label_20")
self.gridLayout_116.addWidget(self.label_20, 1, 0, 1, 1)
self.analogMinLimit_1 = QtWidgets.QLineEdit(self.analogGB_1)
self.analogMinLimit_1.setObjectName("analogMinLimit_1")
self.gridLayout_116.addWidget(self.analogMinLimit_1, 0, 1, 1, 1)
self.label_22 = QtWidgets.QLabel(self.analogGB_1)
self.label_22.setObjectName("label_22")
self.gridLayout_116.addWidget(self.label_22, 2, 0, 1, 1)
self.analogMaxLimit_1 = QtWidgets.QLineEdit(self.analogGB_1)
self.analogMaxLimit_1.setObjectName("analogMaxLimit_1")
self.gridLayout_116.addWidget(self.analogMaxLimit_1, 1, 1, 1, 1)
self.analogDefault_1 = QtWidgets.QPushButton(self.analogGB_1)
self.analogDefault_1.setObjectName("analogDefault_1")
self.gridLayout_116.addWidget(self.analogDefault_1, 0, 2, 1, 1)
self.label_23 = QtWidgets.QLabel(self.analogGB_1)
self.label_23.setObjectName("label_23")
self.gridLayout_116.addWidget(self.label_23, 0, 0, 1, 1)
self.gridLayout_5.addWidget(self.analogGB_1, 2, 0, 1, 1)
self.groupBox_7 = QtWidgets.QGroupBox(self.joint1tab)
self.groupBox_7.setObjectName("groupBox_7")
self.gridLayout_8 = QtWidgets.QGridLayout(self.groupBox_7)
self.gridLayout_8.setContentsMargins(10, 10, 10, 10)
self.gridLayout_8.setSpacing(5)
self.gridLayout_8.setObjectName("gridLayout_8")
self.label_224 = QtWidgets.QLabel(self.groupBox_7)
self.label_224.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_224.setObjectName("label_224")
self.gridLayout_8.addWidget(self.label_224, 0, 0, 1, 1)
self.p_1 = QtWidgets.QLineEdit(self.groupBox_7)
self.p_1.setText("")
self.p_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.p_1.setObjectName("p_1")
self.gridLayout_8.addWidget(self.p_1, 0, 1, 1, 1)
self.label_225 = QtWidgets.QLabel(self.groupBox_7)
self.label_225.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_225.setObjectName("label_225")
self.gridLayout_8.addWidget(self.label_225, 0, 2, 1, 1)
self.deadband_1 = QtWidgets.QLineEdit(self.groupBox_7)
self.deadband_1.setText("")
self.deadband_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.deadband_1.setObjectName("deadband_1")
self.gridLayout_8.addWidget(self.deadband_1, 0, 3, 1, 1)
self.label_226 = QtWidgets.QLabel(self.groupBox_7)
self.label_226.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_226.setObjectName("label_226")
self.gridLayout_8.addWidget(self.label_226, 1, 0, 1, 1)
self.i_1 = QtWidgets.QLineEdit(self.groupBox_7)
self.i_1.setText("")
self.i_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.i_1.setObjectName("i_1")
self.gridLayout_8.addWidget(self.i_1, 1, 1, 1, 1)
self.label_227 = QtWidgets.QLabel(self.groupBox_7)
self.label_227.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_227.setObjectName("label_227")
self.gridLayout_8.addWidget(self.label_227, 1, 2, 1, 1)
self.bias_1 = QtWidgets.QLineEdit(self.groupBox_7)
self.bias_1.setText("")
self.bias_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.bias_1.setObjectName("bias_1")
self.gridLayout_8.addWidget(self.bias_1, 1, 3, 1, 1)
self.label_228 = QtWidgets.QLabel(self.groupBox_7)
self.label_228.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_228.setObjectName("label_228")
self.gridLayout_8.addWidget(self.label_228, 2, 0, 1, 1)
self.d_1 = QtWidgets.QLineEdit(self.groupBox_7)
self.d_1.setText("")
self.d_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.d_1.setObjectName("d_1")
self.gridLayout_8.addWidget(self.d_1, 2, 1, 1, 1)
self.label_229 = QtWidgets.QLabel(self.groupBox_7)
self.label_229.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_229.setObjectName("label_229")
self.gridLayout_8.addWidget(self.label_229, 2, 2, 1, 1)
self.maxOutput_1 = QtWidgets.QLineEdit(self.groupBox_7)
self.maxOutput_1.setText("")
self.maxOutput_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxOutput_1.setObjectName("maxOutput_1")
self.gridLayout_8.addWidget(self.maxOutput_1, 2, 3, 1, 1)
self.label_230 = QtWidgets.QLabel(self.groupBox_7)
self.label_230.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_230.setObjectName("label_230")
self.gridLayout_8.addWidget(self.label_230, 3, 0, 1, 1)
self.ff0_1 = QtWidgets.QLineEdit(self.groupBox_7)
self.ff0_1.setText("")
self.ff0_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff0_1.setObjectName("ff0_1")
self.gridLayout_8.addWidget(self.ff0_1, 3, 1, 1, 1)
self.label_232 = QtWidgets.QLabel(self.groupBox_7)
self.label_232.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_232.setObjectName("label_232")
self.gridLayout_8.addWidget(self.label_232, 4, 0, 1, 1)
self.ff1_1 = QtWidgets.QLineEdit(self.groupBox_7)
self.ff1_1.setText("")
self.ff1_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff1_1.setObjectName("ff1_1")
self.gridLayout_8.addWidget(self.ff1_1, 4, 1, 1, 1)
self.label_233 = QtWidgets.QLabel(self.groupBox_7)
self.label_233.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_233.setObjectName("label_233")
self.gridLayout_8.addWidget(self.label_233, 5, 0, 1, 1)
self.ff2_1 = QtWidgets.QLineEdit(self.groupBox_7)
self.ff2_1.setText("")
self.ff2_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff2_1.setObjectName("ff2_1")
self.gridLayout_8.addWidget(self.ff2_1, 5, 1, 1, 1)
self.pidDefault_1 = QtWidgets.QPushButton(self.groupBox_7)
self.pidDefault_1.setObjectName("pidDefault_1")
self.gridLayout_8.addWidget(self.pidDefault_1, 5, 3, 1, 1)
self.label_184 = QtWidgets.QLabel(self.groupBox_7)
self.label_184.setObjectName("label_184")
self.gridLayout_8.addWidget(self.label_184, 3, 2, 1, 1)
self.maxError_1 = QtWidgets.QLineEdit(self.groupBox_7)
self.maxError_1.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxError_1.setObjectName("maxError_1")
self.gridLayout_8.addWidget(self.maxError_1, 3, 3, 1, 1)
self.gridLayout_5.addWidget(self.groupBox_7, 1, 0, 1, 1)
self.groupBox_8 = QtWidgets.QGroupBox(self.joint1tab)
self.groupBox_8.setObjectName("groupBox_8")
self.gridLayout_112 = QtWidgets.QGridLayout(self.groupBox_8)
self.gridLayout_112.setContentsMargins(8, 8, 8, 8)
self.gridLayout_112.setSpacing(5)
self.gridLayout_112.setObjectName("gridLayout_112")
self.label_32 = QtWidgets.QLabel(self.groupBox_8)
self.label_32.setObjectName("label_32")
self.gridLayout_112.addWidget(self.label_32, 0, 0, 1, 1)
self.encoderScale_1 = QtWidgets.QLineEdit(self.groupBox_8)
self.encoderScale_1.setObjectName("encoderScale_1")
self.gridLayout_112.addWidget(self.encoderScale_1, 0, 1, 1, 1)
self.gridLayout_5.addWidget(self.groupBox_8, 3, 0, 1, 1)
self.jointType_3.addTab(self.joint1tab, "")
self.joint2tab = QtWidgets.QWidget()
self.joint2tab.setObjectName("joint2tab")
self.gridLayout_9 = QtWidgets.QGridLayout(self.joint2tab)
self.gridLayout_9.setContentsMargins(8, 8, 8, 8)
self.gridLayout_9.setSpacing(5)
self.gridLayout_9.setObjectName("gridLayout_9")
self.gridGroupBox7 = QtWidgets.QGroupBox(self.joint2tab)
self.gridGroupBox7.setObjectName("gridGroupBox7")
self.gridLayout_34 = QtWidgets.QGridLayout(self.gridGroupBox7)
self.gridLayout_34.setContentsMargins(8, 8, 8, 8)
self.gridLayout_34.setSpacing(5)
self.gridLayout_34.setObjectName("gridLayout_34")
self.label_196 = QtWidgets.QLabel(self.gridGroupBox7)
self.label_196.setObjectName("label_196")
self.gridLayout_34.addWidget(self.label_196, 1, 0, 1, 1, QtCore.Qt.AlignRight)
self.label_195 = QtWidgets.QLabel(self.gridGroupBox7)
self.label_195.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_195.setObjectName("label_195")
self.gridLayout_34.addWidget(self.label_195, 0, 0, 1, 1)
self.label_197 = QtWidgets.QLabel(self.gridGroupBox7)
self.label_197.setObjectName("label_197")
self.gridLayout_34.addWidget(self.label_197, 2, 0, 1, 1, QtCore.Qt.AlignRight)
self.timeJoint_2 = QtWidgets.QLabel(self.gridGroupBox7)
self.timeJoint_2.setFrameShape(QtWidgets.QFrame.Box)
self.timeJoint_2.setText("")
self.timeJoint_2.setObjectName("timeJoint_2")
self.gridLayout_34.addWidget(self.timeJoint_2, 0, 1, 1, 1)
self.distanceJoint_2 = QtWidgets.QLabel(self.gridGroupBox7)
self.distanceJoint_2.setFrameShape(QtWidgets.QFrame.Box)
self.distanceJoint_2.setText("")
self.distanceJoint_2.setObjectName("distanceJoint_2")
self.gridLayout_34.addWidget(self.distanceJoint_2, 1, 1, 1, 1)
self.stepRateJoint_2 = QtWidgets.QLabel(self.gridGroupBox7)
self.stepRateJoint_2.setFrameShape(QtWidgets.QFrame.Box)
self.stepRateJoint_2.setText("")
self.stepRateJoint_2.setObjectName("stepRateJoint_2")
self.gridLayout_34.addWidget(self.stepRateJoint_2, 2, 1, 1, 1)
self.gridLayout_9.addWidget(self.gridGroupBox7, 2, 1, 1, 1)
self.groupBox_9 = QtWidgets.QGroupBox(self.joint2tab)
self.groupBox_9.setObjectName("groupBox_9")
self.gridLayout_11 = QtWidgets.QGridLayout(self.groupBox_9)
self.gridLayout_11.setContentsMargins(10, 10, 10, 10)
self.gridLayout_11.setSpacing(5)
self.gridLayout_11.setObjectName("gridLayout_11")
self.homeIgnoreLimits_2 = QtWidgets.QCheckBox(self.groupBox_9)
self.homeIgnoreLimits_2.setObjectName("homeIgnoreLimits_2")
self.gridLayout_11.addWidget(self.homeIgnoreLimits_2, 7, 1, 1, 1)
self.homeSearchVel_2 = QtWidgets.QLineEdit(self.groupBox_9)
self.homeSearchVel_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeSearchVel_2.setObjectName("homeSearchVel_2")
self.gridLayout_11.addWidget(self.homeSearchVel_2, 2, 1, 1, 1)
self.label_92 = QtWidgets.QLabel(self.groupBox_9)
self.label_92.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_92.setObjectName("label_92")
self.gridLayout_11.addWidget(self.label_92, 2, 0, 1, 1)
self.homeOffset_2 = QtWidgets.QLineEdit(self.groupBox_9)
self.homeOffset_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeOffset_2.setObjectName("homeOffset_2")
self.gridLayout_11.addWidget(self.homeOffset_2, 1, 1, 1, 1)
self.label_13 = QtWidgets.QLabel(self.groupBox_9)
self.label_13.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_13.setObjectName("label_13")
self.gridLayout_11.addWidget(self.label_13, 4, 0, 1, 1)
self.label_90 = QtWidgets.QLabel(self.groupBox_9)
self.label_90.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_90.setObjectName("label_90")
self.gridLayout_11.addWidget(self.label_90, 0, 0, 1, 1)
self.homeFinalVelocity_2 = QtWidgets.QLineEdit(self.groupBox_9)
self.homeFinalVelocity_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeFinalVelocity_2.setObjectName("homeFinalVelocity_2")
self.gridLayout_11.addWidget(self.homeFinalVelocity_2, 4, 1, 1, 1)
self.home_2 = QtWidgets.QLineEdit(self.groupBox_9)
self.home_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.home_2.setObjectName("home_2")
self.gridLayout_11.addWidget(self.home_2, 0, 1, 1, 1)
self.label_139 = QtWidgets.QLabel(self.groupBox_9)
self.label_139.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_139.setObjectName("label_139")
self.gridLayout_11.addWidget(self.label_139, 5, 0, 1, 1)
self.label_93 = QtWidgets.QLabel(self.groupBox_9)
self.label_93.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_93.setObjectName("label_93")
self.gridLayout_11.addWidget(self.label_93, 3, 0, 1, 1)
self.homeLatchVel_2 = QtWidgets.QLineEdit(self.groupBox_9)
self.homeLatchVel_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeLatchVel_2.setObjectName("homeLatchVel_2")
self.gridLayout_11.addWidget(self.homeLatchVel_2, 3, 1, 1, 1)
self.homeUseIndex_2 = QtWidgets.QCheckBox(self.groupBox_9)
self.homeUseIndex_2.setObjectName("homeUseIndex_2")
self.gridLayout_11.addWidget(self.homeUseIndex_2, 8, 1, 1, 1)
self.label_91 = QtWidgets.QLabel(self.groupBox_9)
self.label_91.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_91.setObjectName("label_91")
self.gridLayout_11.addWidget(self.label_91, 1, 0, 1, 1)
self.homeSwitchShared_2 = QtWidgets.QCheckBox(self.groupBox_9)
self.homeSwitchShared_2.setObjectName("homeSwitchShared_2")
self.gridLayout_11.addWidget(self.homeSwitchShared_2, 9, 1, 1, 1)
self.homeSequence_2 = QtWidgets.QLineEdit(self.groupBox_9)
self.homeSequence_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeSequence_2.setObjectName("homeSequence_2")
self.gridLayout_11.addWidget(self.homeSequence_2, 5, 1, 1, 1)
self.gridLayout_9.addWidget(self.groupBox_9, 1, 1, 1, 1)
self.groupBox_11 = QtWidgets.QGroupBox(self.joint2tab)
self.groupBox_11.setObjectName("groupBox_11")
self.gridLayout_13 = QtWidgets.QGridLayout(self.groupBox_11)
self.gridLayout_13.setContentsMargins(10, 10, 10, 10)
self.gridLayout_13.setSpacing(5)
self.gridLayout_13.setObjectName("gridLayout_13")
self.label_234 = QtWidgets.QLabel(self.groupBox_11)
self.label_234.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_234.setObjectName("label_234")
self.gridLayout_13.addWidget(self.label_234, 0, 0, 1, 1)
self.p_2 = QtWidgets.QLineEdit(self.groupBox_11)
self.p_2.setText("")
self.p_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.p_2.setObjectName("p_2")
self.gridLayout_13.addWidget(self.p_2, 0, 1, 1, 1)
self.label_235 = QtWidgets.QLabel(self.groupBox_11)
self.label_235.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_235.setObjectName("label_235")
self.gridLayout_13.addWidget(self.label_235, 0, 2, 1, 1)
self.deadband_2 = QtWidgets.QLineEdit(self.groupBox_11)
self.deadband_2.setText("")
self.deadband_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.deadband_2.setObjectName("deadband_2")
self.gridLayout_13.addWidget(self.deadband_2, 0, 3, 1, 1)
self.label_236 = QtWidgets.QLabel(self.groupBox_11)
self.label_236.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_236.setObjectName("label_236")
self.gridLayout_13.addWidget(self.label_236, 1, 0, 1, 1)
self.i_2 = QtWidgets.QLineEdit(self.groupBox_11)
self.i_2.setText("")
self.i_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.i_2.setObjectName("i_2")
self.gridLayout_13.addWidget(self.i_2, 1, 1, 1, 1)
self.label_237 = QtWidgets.QLabel(self.groupBox_11)
self.label_237.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_237.setObjectName("label_237")
self.gridLayout_13.addWidget(self.label_237, 1, 2, 1, 1)
self.bias_2 = QtWidgets.QLineEdit(self.groupBox_11)
self.bias_2.setText("")
self.bias_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.bias_2.setObjectName("bias_2")
self.gridLayout_13.addWidget(self.bias_2, 1, 3, 1, 1)
self.label_238 = QtWidgets.QLabel(self.groupBox_11)
self.label_238.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_238.setObjectName("label_238")
self.gridLayout_13.addWidget(self.label_238, 2, 0, 1, 1)
self.d_2 = QtWidgets.QLineEdit(self.groupBox_11)
self.d_2.setText("")
self.d_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.d_2.setObjectName("d_2")
self.gridLayout_13.addWidget(self.d_2, 2, 1, 1, 1)
self.label_239 = QtWidgets.QLabel(self.groupBox_11)
self.label_239.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_239.setObjectName("label_239")
self.gridLayout_13.addWidget(self.label_239, 2, 2, 1, 1)
self.maxOutput_2 = QtWidgets.QLineEdit(self.groupBox_11)
self.maxOutput_2.setText("")
self.maxOutput_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxOutput_2.setObjectName("maxOutput_2")
self.gridLayout_13.addWidget(self.maxOutput_2, 2, 3, 1, 1)
self.label_240 = QtWidgets.QLabel(self.groupBox_11)
self.label_240.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_240.setObjectName("label_240")
self.gridLayout_13.addWidget(self.label_240, 3, 0, 1, 1)
self.ff0_2 = QtWidgets.QLineEdit(self.groupBox_11)
self.ff0_2.setText("")
self.ff0_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff0_2.setObjectName("ff0_2")
self.gridLayout_13.addWidget(self.ff0_2, 3, 1, 1, 1)
self.label_242 = QtWidgets.QLabel(self.groupBox_11)
self.label_242.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_242.setObjectName("label_242")
self.gridLayout_13.addWidget(self.label_242, 4, 0, 1, 1)
self.ff1_2 = QtWidgets.QLineEdit(self.groupBox_11)
self.ff1_2.setText("")
self.ff1_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff1_2.setObjectName("ff1_2")
self.gridLayout_13.addWidget(self.ff1_2, 4, 1, 1, 1)
self.label_243 = QtWidgets.QLabel(self.groupBox_11)
self.label_243.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_243.setObjectName("label_243")
self.gridLayout_13.addWidget(self.label_243, 5, 0, 1, 1)
self.ff2_2 = QtWidgets.QLineEdit(self.groupBox_11)
self.ff2_2.setText("")
self.ff2_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff2_2.setObjectName("ff2_2")
self.gridLayout_13.addWidget(self.ff2_2, 5, 1, 1, 1)
self.pidDefault_2 = QtWidgets.QPushButton(self.groupBox_11)
self.pidDefault_2.setObjectName("pidDefault_2")
self.gridLayout_13.addWidget(self.pidDefault_2, 5, 3, 1, 1)
self.label_186 = QtWidgets.QLabel(self.groupBox_11)
self.label_186.setObjectName("label_186")
self.gridLayout_13.addWidget(self.label_186, 3, 2, 1, 1)
self.maxError_2 = QtWidgets.QLineEdit(self.groupBox_11)
self.maxError_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxError_2.setObjectName("maxError_2")
self.gridLayout_13.addWidget(self.maxError_2, 3, 3, 1, 1)
self.gridLayout_9.addWidget(self.groupBox_11, 1, 0, 1, 1)
self.jointAxisGroup_2 = QtWidgets.QGroupBox(self.joint2tab)
self.jointAxisGroup_2.setObjectName("jointAxisGroup_2")
self.gridLayout_12 = QtWidgets.QGridLayout(self.jointAxisGroup_2)
self.gridLayout_12.setContentsMargins(10, 10, 10, 10)
self.gridLayout_12.setSpacing(5)
self.gridLayout_12.setObjectName("gridLayout_12")
self.maxVelocity_2 = QtWidgets.QLineEdit(self.jointAxisGroup_2)
self.maxVelocity_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxVelocity_2.setObjectName("maxVelocity_2")
self.gridLayout_12.addWidget(self.maxVelocity_2, 1, 5, 1, 1)
self.axisCB_2 = QtWidgets.QComboBox(self.jointAxisGroup_2)
self.axisCB_2.setObjectName("axisCB_2")
self.gridLayout_12.addWidget(self.axisCB_2, 1, 0, 1, 1)
self.label_64 = QtWidgets.QLabel(self.jointAxisGroup_2)
self.label_64.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_64.setWordWrap(True)
self.label_64.setObjectName("label_64")
self.gridLayout_12.addWidget(self.label_64, 0, 3, 1, 1)
self.label_53 = QtWidgets.QLabel(self.jointAxisGroup_2)
self.label_53.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_53.setObjectName("label_53")
self.gridLayout_12.addWidget(self.label_53, 0, 0, 1, 1)
self.minLimit_2 = QtWidgets.QLineEdit(self.jointAxisGroup_2)
self.minLimit_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.minLimit_2.setObjectName("minLimit_2")
self.gridLayout_12.addWidget(self.minLimit_2, 1, 3, 1, 1)
self.maxLimit_2 = QtWidgets.QLineEdit(self.jointAxisGroup_2)
self.maxLimit_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxLimit_2.setObjectName("maxLimit_2")
self.gridLayout_12.addWidget(self.maxLimit_2, 1, 4, 1, 1)
self.label_69 = QtWidgets.QLabel(self.jointAxisGroup_2)
self.label_69.setTextFormat(QtCore.Qt.AutoText)
self.label_69.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_69.setWordWrap(True)
self.label_69.setObjectName("label_69")
self.gridLayout_12.addWidget(self.label_69, 0, 4, 1, 1)
self.label_76 = QtWidgets.QLabel(self.jointAxisGroup_2)
self.label_76.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_76.setWordWrap(True)
self.label_76.setObjectName("label_76")
self.gridLayout_12.addWidget(self.label_76, 0, 5, 1, 1)
self.label_55 = QtWidgets.QLabel(self.jointAxisGroup_2)
self.label_55.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_55.setObjectName("label_55")
self.gridLayout_12.addWidget(self.label_55, 0, 2, 1, 1)
self.label_77 = QtWidgets.QLabel(self.jointAxisGroup_2)
self.label_77.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_77.setWordWrap(True)
self.label_77.setObjectName("label_77")
self.gridLayout_12.addWidget(self.label_77, 0, 6, 1, 1)
self.maxAccel_2 = QtWidgets.QLineEdit(self.jointAxisGroup_2)
self.maxAccel_2.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxAccel_2.setObjectName("maxAccel_2")
self.gridLayout_12.addWidget(self.maxAccel_2, 1, 6, 1, 1)
self.label_6 = QtWidgets.QLabel(self.jointAxisGroup_2)
self.label_6.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft)
self.label_6.setObjectName("label_6")
self.gridLayout_12.addWidget(self.label_6, 0, 1, 1, 1)
self.axisType_2 = QtWidgets.QLabel(self.jointAxisGroup_2)
self.axisType_2.setFrameShape(QtWidgets.QFrame.Box)
self.axisType_2.setText("")
self.axisType_2.setObjectName("axisType_2")
self.gridLayout_12.addWidget(self.axisType_2, 1, 1, 1, 1)
self.scale_2 = QtWidgets.QLineEdit(self.jointAxisGroup_2)
self.scale_2.setObjectName("scale_2")
self.gridLayout_12.addWidget(self.scale_2, 1, 2, 1, 1)
self.reverse_2 = QtWidgets.QCheckBox(self.jointAxisGroup_2)
self.reverse_2.setObjectName("reverse_2")
self.gridLayout_12.addWidget(self.reverse_2, 1, 7, 1, 1)
self.gridLayout_9.addWidget(self.jointAxisGroup_2, 0, 0, 1, 2)
self.analogGB_2 = QtWidgets.QGroupBox(self.joint2tab)
self.analogGB_2.setObjectName("analogGB_2")
self.gridLayout_117 = QtWidgets.QGridLayout(self.analogGB_2)
self.gridLayout_117.setContentsMargins(8, 8, 8, 8)
self.gridLayout_117.setSpacing(5)
self.gridLayout_117.setObjectName("gridLayout_117")
self.analogScaleMax_2 = QtWidgets.QLineEdit(self.analogGB_2)
self.analogScaleMax_2.setObjectName("analogScaleMax_2")
self.gridLayout_117.addWidget(self.analogScaleMax_2, 2, 1, 1, 1)
self.label_24 = QtWidgets.QLabel(self.analogGB_2)
self.label_24.setObjectName("label_24")
self.gridLayout_117.addWidget(self.label_24, 1, 0, 1, 1)
self.analogMinLimit_2 = QtWidgets.QLineEdit(self.analogGB_2)
self.analogMinLimit_2.setObjectName("analogMinLimit_2")
self.gridLayout_117.addWidget(self.analogMinLimit_2, 0, 1, 1, 1)
self.label_25 = QtWidgets.QLabel(self.analogGB_2)
self.label_25.setObjectName("label_25")
self.gridLayout_117.addWidget(self.label_25, 2, 0, 1, 1)
self.analogMaxLimit_2 = QtWidgets.QLineEdit(self.analogGB_2)
self.analogMaxLimit_2.setObjectName("analogMaxLimit_2")
self.gridLayout_117.addWidget(self.analogMaxLimit_2, 1, 1, 1, 1)
self.analogDefault_2 = QtWidgets.QPushButton(self.analogGB_2)
self.analogDefault_2.setObjectName("analogDefault_2")
self.gridLayout_117.addWidget(self.analogDefault_2, 0, 2, 1, 1)
self.label_26 = QtWidgets.QLabel(self.analogGB_2)
self.label_26.setObjectName("label_26")
self.gridLayout_117.addWidget(self.label_26, 0, 0, 1, 1)
self.gridLayout_9.addWidget(self.analogGB_2, 2, 0, 1, 1)
self.groupBox_12 = QtWidgets.QGroupBox(self.joint2tab)
self.groupBox_12.setObjectName("groupBox_12")
self.gridLayout_111 = QtWidgets.QGridLayout(self.groupBox_12)
self.gridLayout_111.setContentsMargins(8, 8, 8, 8)
self.gridLayout_111.setSpacing(5)
self.gridLayout_111.setObjectName("gridLayout_111")
self.label_34 = QtWidgets.QLabel(self.groupBox_12)
self.label_34.setObjectName("label_34")
self.gridLayout_111.addWidget(self.label_34, 0, 0, 1, 1)
self.encoderScale_2 = QtWidgets.QLineEdit(self.groupBox_12)
self.encoderScale_2.setObjectName("encoderScale_2")
self.gridLayout_111.addWidget(self.encoderScale_2, 0, 1, 1, 1)
self.gridLayout_9.addWidget(self.groupBox_12, 3, 0, 1, 1)
self.jointType_3.addTab(self.joint2tab, "")
self.joint3tab = QtWidgets.QWidget()
self.joint3tab.setObjectName("joint3tab")
self.gridLayout_10 = QtWidgets.QGridLayout(self.joint3tab)
self.gridLayout_10.setContentsMargins(8, 8, 8, 8)
self.gridLayout_10.setSpacing(5)
self.gridLayout_10.setObjectName("gridLayout_10")
self.gridGroupBox8 = QtWidgets.QGroupBox(self.joint3tab)
self.gridGroupBox8.setObjectName("gridGroupBox8")
self.gridLayout_35 = QtWidgets.QGridLayout(self.gridGroupBox8)
self.gridLayout_35.setContentsMargins(8, 8, 8, 8)
self.gridLayout_35.setSpacing(5)
self.gridLayout_35.setObjectName("gridLayout_35")
self.label_201 = QtWidgets.QLabel(self.gridGroupBox8)
self.label_201.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_201.setObjectName("label_201")
self.gridLayout_35.addWidget(self.label_201, 0, 0, 1, 1)
self.timeJoint_3 = QtWidgets.QLabel(self.gridGroupBox8)
self.timeJoint_3.setFrameShape(QtWidgets.QFrame.Box)
self.timeJoint_3.setText("")
self.timeJoint_3.setObjectName("timeJoint_3")
self.gridLayout_35.addWidget(self.timeJoint_3, 0, 1, 1, 1)
self.distanceJoint_3 = QtWidgets.QLabel(self.gridGroupBox8)
self.distanceJoint_3.setFrameShape(QtWidgets.QFrame.Box)
self.distanceJoint_3.setText("")
self.distanceJoint_3.setObjectName("distanceJoint_3")
self.gridLayout_35.addWidget(self.distanceJoint_3, 1, 1, 1, 1)
self.label_202 = QtWidgets.QLabel(self.gridGroupBox8)
self.label_202.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_202.setObjectName("label_202")
self.gridLayout_35.addWidget(self.label_202, 1, 0, 1, 1)
self.label_205 = QtWidgets.QLabel(self.gridGroupBox8)
self.label_205.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_205.setObjectName("label_205")
self.gridLayout_35.addWidget(self.label_205, 2, 0, 1, 1)
self.stepRateJoint_3 = QtWidgets.QLabel(self.gridGroupBox8)
self.stepRateJoint_3.setFrameShape(QtWidgets.QFrame.Box)
self.stepRateJoint_3.setText("")
self.stepRateJoint_3.setObjectName("stepRateJoint_3")
self.gridLayout_35.addWidget(self.stepRateJoint_3, 2, 1, 1, 1)
self.gridLayout_10.addWidget(self.gridGroupBox8, 2, 1, 1, 1)
self.groupBox_13 = QtWidgets.QGroupBox(self.joint3tab)
self.groupBox_13.setObjectName("groupBox_13")
self.gridLayout_16 = QtWidgets.QGridLayout(self.groupBox_13)
self.gridLayout_16.setContentsMargins(10, 10, 10, 10)
self.gridLayout_16.setSpacing(5)
self.gridLayout_16.setObjectName("gridLayout_16")
self.label_96 = QtWidgets.QLabel(self.groupBox_13)
self.label_96.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_96.setObjectName("label_96")
self.gridLayout_16.addWidget(self.label_96, 2, 0, 1, 1)
self.label_94 = QtWidgets.QLabel(self.groupBox_13)
self.label_94.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_94.setObjectName("label_94")
self.gridLayout_16.addWidget(self.label_94, 0, 0, 1, 1)
self.homeSequence_3 = QtWidgets.QLineEdit(self.groupBox_13)
self.homeSequence_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeSequence_3.setObjectName("homeSequence_3")
self.gridLayout_16.addWidget(self.homeSequence_3, 5, 1, 1, 1)
self.label_97 = QtWidgets.QLabel(self.groupBox_13)
self.label_97.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_97.setObjectName("label_97")
self.gridLayout_16.addWidget(self.label_97, 3, 0, 1, 1)
self.homeUseIndex_3 = QtWidgets.QCheckBox(self.groupBox_13)
self.homeUseIndex_3.setObjectName("homeUseIndex_3")
self.gridLayout_16.addWidget(self.homeUseIndex_3, 7, 1, 1, 1)
self.homeIgnoreLimits_3 = QtWidgets.QCheckBox(self.groupBox_13)
self.homeIgnoreLimits_3.setObjectName("homeIgnoreLimits_3")
self.gridLayout_16.addWidget(self.homeIgnoreLimits_3, 6, 1, 1, 1)
self.label_140 = QtWidgets.QLabel(self.groupBox_13)
self.label_140.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_140.setObjectName("label_140")
self.gridLayout_16.addWidget(self.label_140, 5, 0, 1, 1)
self.homeOffset_3 = QtWidgets.QLineEdit(self.groupBox_13)
self.homeOffset_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeOffset_3.setObjectName("homeOffset_3")
self.gridLayout_16.addWidget(self.homeOffset_3, 1, 1, 1, 1)
self.homeSearchVel_3 = QtWidgets.QLineEdit(self.groupBox_13)
self.homeSearchVel_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeSearchVel_3.setObjectName("homeSearchVel_3")
self.gridLayout_16.addWidget(self.homeSearchVel_3, 2, 1, 1, 1)
self.homeLatchVel_3 = QtWidgets.QLineEdit(self.groupBox_13)
self.homeLatchVel_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeLatchVel_3.setObjectName("homeLatchVel_3")
self.gridLayout_16.addWidget(self.homeLatchVel_3, 3, 1, 1, 1)
self.label_14 = QtWidgets.QLabel(self.groupBox_13)
self.label_14.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_14.setObjectName("label_14")
self.gridLayout_16.addWidget(self.label_14, 4, 0, 1, 1)
self.homeFinalVelocity_3 = QtWidgets.QLineEdit(self.groupBox_13)
self.homeFinalVelocity_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeFinalVelocity_3.setObjectName("homeFinalVelocity_3")
self.gridLayout_16.addWidget(self.homeFinalVelocity_3, 4, 1, 1, 1)
self.home_3 = QtWidgets.QLineEdit(self.groupBox_13)
self.home_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.home_3.setObjectName("home_3")
self.gridLayout_16.addWidget(self.home_3, 0, 1, 1, 1)
self.label_95 = QtWidgets.QLabel(self.groupBox_13)
self.label_95.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_95.setObjectName("label_95")
self.gridLayout_16.addWidget(self.label_95, 1, 0, 1, 1)
self.homeSwitchShared_3 = QtWidgets.QCheckBox(self.groupBox_13)
self.homeSwitchShared_3.setObjectName("homeSwitchShared_3")
self.gridLayout_16.addWidget(self.homeSwitchShared_3, 8, 1, 1, 1)
self.gridLayout_10.addWidget(self.groupBox_13, 1, 1, 1, 1)
self.groupBox_15 = QtWidgets.QGroupBox(self.joint3tab)
self.groupBox_15.setObjectName("groupBox_15")
self.gridLayout_18 = QtWidgets.QGridLayout(self.groupBox_15)
self.gridLayout_18.setContentsMargins(10, 10, 10, 10)
self.gridLayout_18.setSpacing(5)
self.gridLayout_18.setObjectName("gridLayout_18")
self.label_244 = QtWidgets.QLabel(self.groupBox_15)
self.label_244.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_244.setObjectName("label_244")
self.gridLayout_18.addWidget(self.label_244, 0, 0, 1, 1)
self.p_3 = QtWidgets.QLineEdit(self.groupBox_15)
self.p_3.setText("")
self.p_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.p_3.setObjectName("p_3")
self.gridLayout_18.addWidget(self.p_3, 0, 1, 1, 1)
self.label_245 = QtWidgets.QLabel(self.groupBox_15)
self.label_245.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_245.setObjectName("label_245")
self.gridLayout_18.addWidget(self.label_245, 0, 2, 1, 1)
self.deadband_3 = QtWidgets.QLineEdit(self.groupBox_15)
self.deadband_3.setText("")
self.deadband_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.deadband_3.setObjectName("deadband_3")
self.gridLayout_18.addWidget(self.deadband_3, 0, 3, 1, 1)
self.label_246 = QtWidgets.QLabel(self.groupBox_15)
self.label_246.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_246.setObjectName("label_246")
self.gridLayout_18.addWidget(self.label_246, 1, 0, 1, 1)
self.i_3 = QtWidgets.QLineEdit(self.groupBox_15)
self.i_3.setText("")
self.i_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.i_3.setObjectName("i_3")
self.gridLayout_18.addWidget(self.i_3, 1, 1, 1, 1)
self.label_247 = QtWidgets.QLabel(self.groupBox_15)
self.label_247.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_247.setObjectName("label_247")
self.gridLayout_18.addWidget(self.label_247, 1, 2, 1, 1)
self.bias_3 = QtWidgets.QLineEdit(self.groupBox_15)
self.bias_3.setText("")
self.bias_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.bias_3.setObjectName("bias_3")
self.gridLayout_18.addWidget(self.bias_3, 1, 3, 1, 1)
self.label_248 = QtWidgets.QLabel(self.groupBox_15)
self.label_248.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_248.setObjectName("label_248")
self.gridLayout_18.addWidget(self.label_248, 2, 0, 1, 1)
self.d_3 = QtWidgets.QLineEdit(self.groupBox_15)
self.d_3.setText("")
self.d_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.d_3.setObjectName("d_3")
self.gridLayout_18.addWidget(self.d_3, 2, 1, 1, 1)
self.label_249 = QtWidgets.QLabel(self.groupBox_15)
self.label_249.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_249.setObjectName("label_249")
self.gridLayout_18.addWidget(self.label_249, 2, 2, 1, 1)
self.maxOutput_3 = QtWidgets.QLineEdit(self.groupBox_15)
self.maxOutput_3.setText("")
self.maxOutput_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxOutput_3.setObjectName("maxOutput_3")
self.gridLayout_18.addWidget(self.maxOutput_3, 2, 3, 1, 1)
self.label_250 = QtWidgets.QLabel(self.groupBox_15)
self.label_250.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_250.setObjectName("label_250")
self.gridLayout_18.addWidget(self.label_250, 3, 0, 1, 1)
self.ff0_3 = QtWidgets.QLineEdit(self.groupBox_15)
self.ff0_3.setText("")
self.ff0_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff0_3.setObjectName("ff0_3")
self.gridLayout_18.addWidget(self.ff0_3, 3, 1, 1, 1)
self.label_252 = QtWidgets.QLabel(self.groupBox_15)
self.label_252.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_252.setObjectName("label_252")
self.gridLayout_18.addWidget(self.label_252, 4, 0, 1, 1)
self.ff1_3 = QtWidgets.QLineEdit(self.groupBox_15)
self.ff1_3.setText("")
self.ff1_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff1_3.setObjectName("ff1_3")
self.gridLayout_18.addWidget(self.ff1_3, 4, 1, 1, 1)
self.label_253 = QtWidgets.QLabel(self.groupBox_15)
self.label_253.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_253.setObjectName("label_253")
self.gridLayout_18.addWidget(self.label_253, 5, 0, 1, 1)
self.ff2_3 = QtWidgets.QLineEdit(self.groupBox_15)
self.ff2_3.setText("")
self.ff2_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff2_3.setObjectName("ff2_3")
self.gridLayout_18.addWidget(self.ff2_3, 5, 1, 1, 1)
self.pidDefault_3 = QtWidgets.QPushButton(self.groupBox_15)
self.pidDefault_3.setObjectName("pidDefault_3")
self.gridLayout_18.addWidget(self.pidDefault_3, 5, 3, 1, 1)
self.label_187 = QtWidgets.QLabel(self.groupBox_15)
self.label_187.setObjectName("label_187")
self.gridLayout_18.addWidget(self.label_187, 3, 2, 1, 1)
self.maxError_3 = QtWidgets.QLineEdit(self.groupBox_15)
self.maxError_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxError_3.setObjectName("maxError_3")
self.gridLayout_18.addWidget(self.maxError_3, 3, 3, 1, 1)
self.gridLayout_10.addWidget(self.groupBox_15, 1, 0, 1, 1)
self.jointAxisGroup_3 = QtWidgets.QGroupBox(self.joint3tab)
self.jointAxisGroup_3.setObjectName("jointAxisGroup_3")
self.gridLayout_17 = QtWidgets.QGridLayout(self.jointAxisGroup_3)
self.gridLayout_17.setContentsMargins(10, 10, 10, 10)
self.gridLayout_17.setSpacing(5)
self.gridLayout_17.setObjectName("gridLayout_17")
self.label_65 = QtWidgets.QLabel(self.jointAxisGroup_3)
self.label_65.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_65.setWordWrap(True)
self.label_65.setObjectName("label_65")
self.gridLayout_17.addWidget(self.label_65, 0, 3, 1, 1)
self.axisCB_3 = QtWidgets.QComboBox(self.jointAxisGroup_3)
self.axisCB_3.setObjectName("axisCB_3")
self.gridLayout_17.addWidget(self.axisCB_3, 1, 0, 1, 1)
self.label_56 = QtWidgets.QLabel(self.jointAxisGroup_3)
self.label_56.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_56.setObjectName("label_56")
self.gridLayout_17.addWidget(self.label_56, 0, 0, 1, 1)
self.minLimit_3 = QtWidgets.QLineEdit(self.jointAxisGroup_3)
self.minLimit_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.minLimit_3.setObjectName("minLimit_3")
self.gridLayout_17.addWidget(self.minLimit_3, 1, 3, 1, 1)
self.maxLimit_3 = QtWidgets.QLineEdit(self.jointAxisGroup_3)
self.maxLimit_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxLimit_3.setObjectName("maxLimit_3")
self.gridLayout_17.addWidget(self.maxLimit_3, 1, 4, 1, 1)
self.label_70 = QtWidgets.QLabel(self.jointAxisGroup_3)
self.label_70.setTextFormat(QtCore.Qt.AutoText)
self.label_70.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_70.setWordWrap(True)
self.label_70.setObjectName("label_70")
self.gridLayout_17.addWidget(self.label_70, 0, 4, 1, 1)
self.label_78 = QtWidgets.QLabel(self.jointAxisGroup_3)
self.label_78.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_78.setWordWrap(True)
self.label_78.setObjectName("label_78")
self.gridLayout_17.addWidget(self.label_78, 0, 5, 1, 1)
self.maxVelocity_3 = QtWidgets.QLineEdit(self.jointAxisGroup_3)
self.maxVelocity_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxVelocity_3.setObjectName("maxVelocity_3")
self.gridLayout_17.addWidget(self.maxVelocity_3, 1, 5, 1, 1)
self.maxAccel_3 = QtWidgets.QLineEdit(self.jointAxisGroup_3)
self.maxAccel_3.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxAccel_3.setObjectName("maxAccel_3")
self.gridLayout_17.addWidget(self.maxAccel_3, 1, 6, 1, 1)
self.label_58 = QtWidgets.QLabel(self.jointAxisGroup_3)
self.label_58.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_58.setObjectName("label_58")
self.gridLayout_17.addWidget(self.label_58, 0, 2, 1, 1)
self.label_79 = QtWidgets.QLabel(self.jointAxisGroup_3)
self.label_79.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_79.setWordWrap(True)
self.label_79.setObjectName("label_79")
self.gridLayout_17.addWidget(self.label_79, 0, 6, 1, 1)
self.label_7 = QtWidgets.QLabel(self.jointAxisGroup_3)
self.label_7.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft)
self.label_7.setObjectName("label_7")
self.gridLayout_17.addWidget(self.label_7, 0, 1, 1, 1)
self.axisType_3 = QtWidgets.QLabel(self.jointAxisGroup_3)
self.axisType_3.setFrameShape(QtWidgets.QFrame.Box)
self.axisType_3.setText("")
self.axisType_3.setObjectName("axisType_3")
self.gridLayout_17.addWidget(self.axisType_3, 1, 1, 1, 1)
self.scale_3 = QtWidgets.QLineEdit(self.jointAxisGroup_3)
self.scale_3.setObjectName("scale_3")
self.gridLayout_17.addWidget(self.scale_3, 1, 2, 1, 1)
self.reverse_3 = QtWidgets.QCheckBox(self.jointAxisGroup_3)
self.reverse_3.setObjectName("reverse_3")
self.gridLayout_17.addWidget(self.reverse_3, 1, 7, 1, 1)
self.gridLayout_10.addWidget(self.jointAxisGroup_3, 0, 0, 1, 2)
self.analogGB_3 = QtWidgets.QGroupBox(self.joint3tab)
self.analogGB_3.setObjectName("analogGB_3")
self.gridLayout_118 = QtWidgets.QGridLayout(self.analogGB_3)
self.gridLayout_118.setContentsMargins(8, 8, 8, 8)
self.gridLayout_118.setSpacing(5)
self.gridLayout_118.setObjectName("gridLayout_118")
self.analogScaleMax_3 = QtWidgets.QLineEdit(self.analogGB_3)
self.analogScaleMax_3.setObjectName("analogScaleMax_3")
self.gridLayout_118.addWidget(self.analogScaleMax_3, 2, 1, 1, 1)
self.label_28 = QtWidgets.QLabel(self.analogGB_3)
self.label_28.setObjectName("label_28")
self.gridLayout_118.addWidget(self.label_28, 1, 0, 1, 1)
self.analogMinLimit_3 = QtWidgets.QLineEdit(self.analogGB_3)
self.analogMinLimit_3.setObjectName("analogMinLimit_3")
self.gridLayout_118.addWidget(self.analogMinLimit_3, 0, 1, 1, 1)
self.label_29 = QtWidgets.QLabel(self.analogGB_3)
self.label_29.setObjectName("label_29")
self.gridLayout_118.addWidget(self.label_29, 2, 0, 1, 1)
self.analogMaxLimit_3 = QtWidgets.QLineEdit(self.analogGB_3)
self.analogMaxLimit_3.setObjectName("analogMaxLimit_3")
self.gridLayout_118.addWidget(self.analogMaxLimit_3, 1, 1, 1, 1)
self.analogDefault_3 = QtWidgets.QPushButton(self.analogGB_3)
self.analogDefault_3.setObjectName("analogDefault_3")
self.gridLayout_118.addWidget(self.analogDefault_3, 0, 2, 1, 1)
self.label_30 = QtWidgets.QLabel(self.analogGB_3)
self.label_30.setObjectName("label_30")
self.gridLayout_118.addWidget(self.label_30, 0, 0, 1, 1)
self.gridLayout_10.addWidget(self.analogGB_3, 2, 0, 1, 1)
self.groupBox_16 = QtWidgets.QGroupBox(self.joint3tab)
self.groupBox_16.setObjectName("groupBox_16")
self.gridLayout_25 = QtWidgets.QGridLayout(self.groupBox_16)
self.gridLayout_25.setContentsMargins(8, 8, 8, 8)
self.gridLayout_25.setSpacing(5)
self.gridLayout_25.setObjectName("gridLayout_25")
self.label_49 = QtWidgets.QLabel(self.groupBox_16)
self.label_49.setObjectName("label_49")
self.gridLayout_25.addWidget(self.label_49, 0, 0, 1, 1)
self.encoderScale_3 = QtWidgets.QLineEdit(self.groupBox_16)
self.encoderScale_3.setObjectName("encoderScale_3")
self.gridLayout_25.addWidget(self.encoderScale_3, 0, 1, 1, 1)
self.gridLayout_10.addWidget(self.groupBox_16, 3, 0, 1, 1)
self.jointType_3.addTab(self.joint3tab, "")
self.joint4tab = QtWidgets.QWidget()
self.joint4tab.setObjectName("joint4tab")
self.gridLayout_14 = QtWidgets.QGridLayout(self.joint4tab)
self.gridLayout_14.setContentsMargins(8, 8, 8, 8)
self.gridLayout_14.setSpacing(5)
self.gridLayout_14.setObjectName("gridLayout_14")
self.groupBox_17 = QtWidgets.QGroupBox(self.joint4tab)
self.groupBox_17.setObjectName("groupBox_17")
self.gridLayout_21 = QtWidgets.QGridLayout(self.groupBox_17)
self.gridLayout_21.setContentsMargins(10, 10, 10, 10)
self.gridLayout_21.setSpacing(5)
self.gridLayout_21.setObjectName("gridLayout_21")
self.label_98 = QtWidgets.QLabel(self.groupBox_17)
self.label_98.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_98.setObjectName("label_98")
self.gridLayout_21.addWidget(self.label_98, 0, 0, 1, 1)
self.homeSearchVel_4 = QtWidgets.QLineEdit(self.groupBox_17)
self.homeSearchVel_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeSearchVel_4.setObjectName("homeSearchVel_4")
self.gridLayout_21.addWidget(self.homeSearchVel_4, 2, 1, 1, 1)
self.label_15 = QtWidgets.QLabel(self.groupBox_17)
self.label_15.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_15.setObjectName("label_15")
self.gridLayout_21.addWidget(self.label_15, 4, 0, 1, 1)
self.label_141 = QtWidgets.QLabel(self.groupBox_17)
self.label_141.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_141.setObjectName("label_141")
self.gridLayout_21.addWidget(self.label_141, 5, 0, 1, 1)
self.homeIgnoreLimits_4 = QtWidgets.QCheckBox(self.groupBox_17)
self.homeIgnoreLimits_4.setObjectName("homeIgnoreLimits_4")
self.gridLayout_21.addWidget(self.homeIgnoreLimits_4, 6, 1, 1, 1)
self.homeSequence_4 = QtWidgets.QLineEdit(self.groupBox_17)
self.homeSequence_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeSequence_4.setObjectName("homeSequence_4")
self.gridLayout_21.addWidget(self.homeSequence_4, 5, 1, 1, 1)
self.homeLatchVel_4 = QtWidgets.QLineEdit(self.groupBox_17)
self.homeLatchVel_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeLatchVel_4.setObjectName("homeLatchVel_4")
self.gridLayout_21.addWidget(self.homeLatchVel_4, 3, 1, 1, 1)
self.label_100 = QtWidgets.QLabel(self.groupBox_17)
self.label_100.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_100.setObjectName("label_100")
self.gridLayout_21.addWidget(self.label_100, 2, 0, 1, 1)
self.home_4 = QtWidgets.QLineEdit(self.groupBox_17)
self.home_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.home_4.setObjectName("home_4")
self.gridLayout_21.addWidget(self.home_4, 0, 1, 1, 1)
self.homeUseIndex_4 = QtWidgets.QCheckBox(self.groupBox_17)
self.homeUseIndex_4.setObjectName("homeUseIndex_4")
self.gridLayout_21.addWidget(self.homeUseIndex_4, 7, 1, 1, 1)
self.label_99 = QtWidgets.QLabel(self.groupBox_17)
self.label_99.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_99.setObjectName("label_99")
self.gridLayout_21.addWidget(self.label_99, 1, 0, 1, 1)
self.homeOffset_4 = QtWidgets.QLineEdit(self.groupBox_17)
self.homeOffset_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeOffset_4.setObjectName("homeOffset_4")
self.gridLayout_21.addWidget(self.homeOffset_4, 1, 1, 1, 1)
self.homeFinalVelocity_4 = QtWidgets.QLineEdit(self.groupBox_17)
self.homeFinalVelocity_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeFinalVelocity_4.setObjectName("homeFinalVelocity_4")
self.gridLayout_21.addWidget(self.homeFinalVelocity_4, 4, 1, 1, 1)
self.label_101 = QtWidgets.QLabel(self.groupBox_17)
self.label_101.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_101.setObjectName("label_101")
self.gridLayout_21.addWidget(self.label_101, 3, 0, 1, 1)
self.homeSwitchShared_4 = QtWidgets.QCheckBox(self.groupBox_17)
self.homeSwitchShared_4.setObjectName("homeSwitchShared_4")
self.gridLayout_21.addWidget(self.homeSwitchShared_4, 8, 1, 1, 1)
self.gridLayout_14.addWidget(self.groupBox_17, 1, 1, 1, 1)
self.groupBox_19 = QtWidgets.QGroupBox(self.joint4tab)
self.groupBox_19.setObjectName("groupBox_19")
self.gridLayout_23 = QtWidgets.QGridLayout(self.groupBox_19)
self.gridLayout_23.setContentsMargins(10, 10, 10, 10)
self.gridLayout_23.setSpacing(5)
self.gridLayout_23.setObjectName("gridLayout_23")
self.label_254 = QtWidgets.QLabel(self.groupBox_19)
self.label_254.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_254.setObjectName("label_254")
self.gridLayout_23.addWidget(self.label_254, 0, 0, 1, 1)
self.p_4 = QtWidgets.QLineEdit(self.groupBox_19)
self.p_4.setText("")
self.p_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.p_4.setObjectName("p_4")
self.gridLayout_23.addWidget(self.p_4, 0, 1, 1, 1)
self.label_255 = QtWidgets.QLabel(self.groupBox_19)
self.label_255.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_255.setObjectName("label_255")
self.gridLayout_23.addWidget(self.label_255, 0, 2, 1, 1)
self.deadband_4 = QtWidgets.QLineEdit(self.groupBox_19)
self.deadband_4.setText("")
self.deadband_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.deadband_4.setObjectName("deadband_4")
self.gridLayout_23.addWidget(self.deadband_4, 0, 3, 1, 1)
self.label_256 = QtWidgets.QLabel(self.groupBox_19)
self.label_256.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_256.setObjectName("label_256")
self.gridLayout_23.addWidget(self.label_256, 1, 0, 1, 1)
self.i_4 = QtWidgets.QLineEdit(self.groupBox_19)
self.i_4.setText("")
self.i_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.i_4.setObjectName("i_4")
self.gridLayout_23.addWidget(self.i_4, 1, 1, 1, 1)
self.label_257 = QtWidgets.QLabel(self.groupBox_19)
self.label_257.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_257.setObjectName("label_257")
self.gridLayout_23.addWidget(self.label_257, 1, 2, 1, 1)
self.bias_4 = QtWidgets.QLineEdit(self.groupBox_19)
self.bias_4.setText("")
self.bias_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.bias_4.setObjectName("bias_4")
self.gridLayout_23.addWidget(self.bias_4, 1, 3, 1, 1)
self.label_258 = QtWidgets.QLabel(self.groupBox_19)
self.label_258.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_258.setObjectName("label_258")
self.gridLayout_23.addWidget(self.label_258, 2, 0, 1, 1)
self.d_4 = QtWidgets.QLineEdit(self.groupBox_19)
self.d_4.setText("")
self.d_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.d_4.setObjectName("d_4")
self.gridLayout_23.addWidget(self.d_4, 2, 1, 1, 1)
self.label_259 = QtWidgets.QLabel(self.groupBox_19)
self.label_259.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_259.setObjectName("label_259")
self.gridLayout_23.addWidget(self.label_259, 2, 2, 1, 1)
self.maxOutput_4 = QtWidgets.QLineEdit(self.groupBox_19)
self.maxOutput_4.setText("")
self.maxOutput_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxOutput_4.setObjectName("maxOutput_4")
self.gridLayout_23.addWidget(self.maxOutput_4, 2, 3, 1, 1)
self.label_260 = QtWidgets.QLabel(self.groupBox_19)
self.label_260.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_260.setObjectName("label_260")
self.gridLayout_23.addWidget(self.label_260, 3, 0, 1, 1)
self.ff0_4 = QtWidgets.QLineEdit(self.groupBox_19)
self.ff0_4.setText("")
self.ff0_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff0_4.setObjectName("ff0_4")
self.gridLayout_23.addWidget(self.ff0_4, 3, 1, 1, 1)
self.label_262 = QtWidgets.QLabel(self.groupBox_19)
self.label_262.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_262.setObjectName("label_262")
self.gridLayout_23.addWidget(self.label_262, 4, 0, 1, 1)
self.ff1_4 = QtWidgets.QLineEdit(self.groupBox_19)
self.ff1_4.setText("")
self.ff1_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff1_4.setObjectName("ff1_4")
self.gridLayout_23.addWidget(self.ff1_4, 4, 1, 1, 1)
self.label_263 = QtWidgets.QLabel(self.groupBox_19)
self.label_263.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_263.setObjectName("label_263")
self.gridLayout_23.addWidget(self.label_263, 5, 0, 1, 1)
self.ff2_4 = QtWidgets.QLineEdit(self.groupBox_19)
self.ff2_4.setText("")
self.ff2_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff2_4.setObjectName("ff2_4")
self.gridLayout_23.addWidget(self.ff2_4, 5, 1, 1, 1)
self.pidDefault_4 = QtWidgets.QPushButton(self.groupBox_19)
self.pidDefault_4.setObjectName("pidDefault_4")
self.gridLayout_23.addWidget(self.pidDefault_4, 5, 3, 1, 1)
self.maxError_4 = QtWidgets.QLineEdit(self.groupBox_19)
self.maxError_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxError_4.setObjectName("maxError_4")
self.gridLayout_23.addWidget(self.maxError_4, 3, 3, 1, 1)
self.label_188 = QtWidgets.QLabel(self.groupBox_19)
self.label_188.setObjectName("label_188")
self.gridLayout_23.addWidget(self.label_188, 3, 2, 1, 1)
self.gridLayout_14.addWidget(self.groupBox_19, 1, 0, 1, 1)
self.analogGB_4 = QtWidgets.QGroupBox(self.joint4tab)
self.analogGB_4.setObjectName("analogGB_4")
self.gridLayout_119 = QtWidgets.QGridLayout(self.analogGB_4)
self.gridLayout_119.setContentsMargins(8, 8, 8, 8)
self.gridLayout_119.setSpacing(5)
self.gridLayout_119.setObjectName("gridLayout_119")
self.analogScaleMax_4 = QtWidgets.QLineEdit(self.analogGB_4)
self.analogScaleMax_4.setObjectName("analogScaleMax_4")
self.gridLayout_119.addWidget(self.analogScaleMax_4, 2, 1, 1, 1)
self.label_35 = QtWidgets.QLabel(self.analogGB_4)
self.label_35.setObjectName("label_35")
self.gridLayout_119.addWidget(self.label_35, 1, 0, 1, 1)
self.analogMinLimit_4 = QtWidgets.QLineEdit(self.analogGB_4)
self.analogMinLimit_4.setObjectName("analogMinLimit_4")
self.gridLayout_119.addWidget(self.analogMinLimit_4, 0, 1, 1, 1)
self.label_36 = QtWidgets.QLabel(self.analogGB_4)
self.label_36.setObjectName("label_36")
self.gridLayout_119.addWidget(self.label_36, 2, 0, 1, 1)
self.analogMaxLimit_4 = QtWidgets.QLineEdit(self.analogGB_4)
self.analogMaxLimit_4.setObjectName("analogMaxLimit_4")
self.gridLayout_119.addWidget(self.analogMaxLimit_4, 1, 1, 1, 1)
self.analogDefault_4 = QtWidgets.QPushButton(self.analogGB_4)
self.analogDefault_4.setObjectName("analogDefault_4")
self.gridLayout_119.addWidget(self.analogDefault_4, 0, 2, 1, 1)
self.label_44 = QtWidgets.QLabel(self.analogGB_4)
self.label_44.setObjectName("label_44")
self.gridLayout_119.addWidget(self.label_44, 0, 0, 1, 1)
self.gridLayout_14.addWidget(self.analogGB_4, 2, 0, 1, 1)
self.gridGroupBox9 = QtWidgets.QGroupBox(self.joint4tab)
self.gridGroupBox9.setObjectName("gridGroupBox9")
self.gridLayout_36 = QtWidgets.QGridLayout(self.gridGroupBox9)
self.gridLayout_36.setContentsMargins(8, 8, 8, 8)
self.gridLayout_36.setSpacing(5)
self.gridLayout_36.setObjectName("gridLayout_36")
self.label_207 = QtWidgets.QLabel(self.gridGroupBox9)
self.label_207.setObjectName("label_207")
self.gridLayout_36.addWidget(self.label_207, 0, 0, 1, 1)
self.label_208 = QtWidgets.QLabel(self.gridGroupBox9)
self.label_208.setObjectName("label_208")
self.gridLayout_36.addWidget(self.label_208, 1, 0, 1, 1)
self.label_209 = QtWidgets.QLabel(self.gridGroupBox9)
self.label_209.setObjectName("label_209")
self.gridLayout_36.addWidget(self.label_209, 2, 0, 1, 1)
self.distanceJoint_4 = QtWidgets.QLabel(self.gridGroupBox9)
self.distanceJoint_4.setFrameShape(QtWidgets.QFrame.Box)
self.distanceJoint_4.setText("")
self.distanceJoint_4.setObjectName("distanceJoint_4")
self.gridLayout_36.addWidget(self.distanceJoint_4, 1, 1, 1, 1)
self.timeJoint_4 = QtWidgets.QLabel(self.gridGroupBox9)
self.timeJoint_4.setFrameShape(QtWidgets.QFrame.Box)
self.timeJoint_4.setText("")
self.timeJoint_4.setObjectName("timeJoint_4")
self.gridLayout_36.addWidget(self.timeJoint_4, 0, 1, 1, 1)
self.stepRateJoint_4 = QtWidgets.QLabel(self.gridGroupBox9)
self.stepRateJoint_4.setFrameShape(QtWidgets.QFrame.Box)
self.stepRateJoint_4.setText("")
self.stepRateJoint_4.setObjectName("stepRateJoint_4")
self.gridLayout_36.addWidget(self.stepRateJoint_4, 2, 1, 1, 1)
self.gridLayout_14.addWidget(self.gridGroupBox9, 2, 1, 1, 1)
self.jointAxisGroup_4 = QtWidgets.QGroupBox(self.joint4tab)
self.jointAxisGroup_4.setObjectName("jointAxisGroup_4")
self.gridLayout_22 = QtWidgets.QGridLayout(self.jointAxisGroup_4)
self.gridLayout_22.setContentsMargins(10, 10, 10, 10)
self.gridLayout_22.setSpacing(5)
self.gridLayout_22.setObjectName("gridLayout_22")
self.axisCB_4 = QtWidgets.QComboBox(self.jointAxisGroup_4)
self.axisCB_4.setObjectName("axisCB_4")
self.gridLayout_22.addWidget(self.axisCB_4, 1, 0, 1, 1)
self.label_66 = QtWidgets.QLabel(self.jointAxisGroup_4)
self.label_66.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_66.setWordWrap(True)
self.label_66.setObjectName("label_66")
self.gridLayout_22.addWidget(self.label_66, 0, 3, 1, 1)
self.label_59 = QtWidgets.QLabel(self.jointAxisGroup_4)
self.label_59.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_59.setObjectName("label_59")
self.gridLayout_22.addWidget(self.label_59, 0, 0, 1, 1)
self.minLimit_4 = QtWidgets.QLineEdit(self.jointAxisGroup_4)
self.minLimit_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.minLimit_4.setObjectName("minLimit_4")
self.gridLayout_22.addWidget(self.minLimit_4, 1, 3, 1, 1)
self.maxLimit_4 = QtWidgets.QLineEdit(self.jointAxisGroup_4)
self.maxLimit_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxLimit_4.setObjectName("maxLimit_4")
self.gridLayout_22.addWidget(self.maxLimit_4, 1, 4, 1, 1)
self.label_71 = QtWidgets.QLabel(self.jointAxisGroup_4)
self.label_71.setTextFormat(QtCore.Qt.AutoText)
self.label_71.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_71.setWordWrap(True)
self.label_71.setObjectName("label_71")
self.gridLayout_22.addWidget(self.label_71, 0, 4, 1, 1)
self.label_80 = QtWidgets.QLabel(self.jointAxisGroup_4)
self.label_80.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_80.setWordWrap(True)
self.label_80.setObjectName("label_80")
self.gridLayout_22.addWidget(self.label_80, 0, 5, 1, 1)
self.maxVelocity_4 = QtWidgets.QLineEdit(self.jointAxisGroup_4)
self.maxVelocity_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxVelocity_4.setObjectName("maxVelocity_4")
self.gridLayout_22.addWidget(self.maxVelocity_4, 1, 5, 1, 1)
self.label_61 = QtWidgets.QLabel(self.jointAxisGroup_4)
self.label_61.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_61.setObjectName("label_61")
self.gridLayout_22.addWidget(self.label_61, 0, 2, 1, 1)
self.label_81 = QtWidgets.QLabel(self.jointAxisGroup_4)
self.label_81.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_81.setWordWrap(True)
self.label_81.setObjectName("label_81")
self.gridLayout_22.addWidget(self.label_81, 0, 6, 1, 1)
self.maxAccel_4 = QtWidgets.QLineEdit(self.jointAxisGroup_4)
self.maxAccel_4.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxAccel_4.setObjectName("maxAccel_4")
self.gridLayout_22.addWidget(self.maxAccel_4, 1, 6, 1, 1)
self.label_31 = QtWidgets.QLabel(self.jointAxisGroup_4)
self.label_31.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft)
self.label_31.setObjectName("label_31")
self.gridLayout_22.addWidget(self.label_31, 0, 1, 1, 1)
self.axisType_4 = QtWidgets.QLabel(self.jointAxisGroup_4)
self.axisType_4.setFrameShape(QtWidgets.QFrame.Box)
self.axisType_4.setText("")
self.axisType_4.setObjectName("axisType_4")
self.gridLayout_22.addWidget(self.axisType_4, 1, 1, 1, 1)
self.scale_4 = QtWidgets.QLineEdit(self.jointAxisGroup_4)
self.scale_4.setObjectName("scale_4")
self.gridLayout_22.addWidget(self.scale_4, 1, 2, 1, 1)
self.reverse_4 = QtWidgets.QCheckBox(self.jointAxisGroup_4)
self.reverse_4.setObjectName("reverse_4")
self.gridLayout_22.addWidget(self.reverse_4, 1, 7, 1, 1)
self.gridLayout_14.addWidget(self.jointAxisGroup_4, 0, 0, 1, 2)
self.groupBox_20 = QtWidgets.QGroupBox(self.joint4tab)
self.groupBox_20.setObjectName("groupBox_20")
self.gridLayout_24 = QtWidgets.QGridLayout(self.groupBox_20)
self.gridLayout_24.setContentsMargins(8, 8, 8, 8)
self.gridLayout_24.setSpacing(5)
self.gridLayout_24.setObjectName("gridLayout_24")
self.label_57 = QtWidgets.QLabel(self.groupBox_20)
self.label_57.setObjectName("label_57")
self.gridLayout_24.addWidget(self.label_57, 0, 0, 1, 1)
self.encoderScale_4 = QtWidgets.QLineEdit(self.groupBox_20)
self.encoderScale_4.setObjectName("encoderScale_4")
self.gridLayout_24.addWidget(self.encoderScale_4, 0, 1, 1, 1)
self.gridLayout_14.addWidget(self.groupBox_20, 3, 0, 1, 1)
self.jointType_3.addTab(self.joint4tab, "")
self.tab_3 = QtWidgets.QWidget()
self.tab_3.setObjectName("tab_3")
self.gridLayout_15 = QtWidgets.QGridLayout(self.tab_3)
self.gridLayout_15.setContentsMargins(8, 8, 8, 8)
self.gridLayout_15.setSpacing(5)
self.gridLayout_15.setObjectName("gridLayout_15")
self.groupBox_63 = QtWidgets.QGroupBox(self.tab_3)
self.groupBox_63.setObjectName("groupBox_63")
self.gridLayout_110 = QtWidgets.QGridLayout(self.groupBox_63)
self.gridLayout_110.setContentsMargins(10, 10, 10, 10)
self.gridLayout_110.setSpacing(5)
self.gridLayout_110.setObjectName("gridLayout_110")
self.label_759 = QtWidgets.QLabel(self.groupBox_63)
self.label_759.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_759.setObjectName("label_759")
self.gridLayout_110.addWidget(self.label_759, 0, 0, 1, 1)
self.p_5 = QtWidgets.QLineEdit(self.groupBox_63)
self.p_5.setText("")
self.p_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.p_5.setObjectName("p_5")
self.gridLayout_110.addWidget(self.p_5, 0, 1, 1, 1)
self.label_760 = QtWidgets.QLabel(self.groupBox_63)
self.label_760.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_760.setObjectName("label_760")
self.gridLayout_110.addWidget(self.label_760, 0, 2, 1, 1)
self.deadband_5 = QtWidgets.QLineEdit(self.groupBox_63)
self.deadband_5.setText("")
self.deadband_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.deadband_5.setObjectName("deadband_5")
self.gridLayout_110.addWidget(self.deadband_5, 0, 3, 1, 1)
self.label_761 = QtWidgets.QLabel(self.groupBox_63)
self.label_761.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_761.setObjectName("label_761")
self.gridLayout_110.addWidget(self.label_761, 1, 0, 1, 1)
self.i_5 = QtWidgets.QLineEdit(self.groupBox_63)
self.i_5.setText("")
self.i_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.i_5.setObjectName("i_5")
self.gridLayout_110.addWidget(self.i_5, 1, 1, 1, 1)
self.label_762 = QtWidgets.QLabel(self.groupBox_63)
self.label_762.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_762.setObjectName("label_762")
self.gridLayout_110.addWidget(self.label_762, 1, 2, 1, 1)
self.bias_5 = QtWidgets.QLineEdit(self.groupBox_63)
self.bias_5.setText("")
self.bias_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.bias_5.setObjectName("bias_5")
self.gridLayout_110.addWidget(self.bias_5, 1, 3, 1, 1)
self.label_763 = QtWidgets.QLabel(self.groupBox_63)
self.label_763.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_763.setObjectName("label_763")
self.gridLayout_110.addWidget(self.label_763, 2, 0, 1, 1)
self.d_5 = QtWidgets.QLineEdit(self.groupBox_63)
self.d_5.setText("")
self.d_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.d_5.setObjectName("d_5")
self.gridLayout_110.addWidget(self.d_5, 2, 1, 1, 1)
self.label_764 = QtWidgets.QLabel(self.groupBox_63)
self.label_764.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_764.setObjectName("label_764")
self.gridLayout_110.addWidget(self.label_764, 2, 2, 1, 1)
self.maxOutput_5 = QtWidgets.QLineEdit(self.groupBox_63)
self.maxOutput_5.setText("")
self.maxOutput_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxOutput_5.setObjectName("maxOutput_5")
self.gridLayout_110.addWidget(self.maxOutput_5, 2, 3, 1, 1)
self.label_765 = QtWidgets.QLabel(self.groupBox_63)
self.label_765.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_765.setObjectName("label_765")
self.gridLayout_110.addWidget(self.label_765, 3, 0, 1, 1)
self.ff0_5 = QtWidgets.QLineEdit(self.groupBox_63)
self.ff0_5.setText("")
self.ff0_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff0_5.setObjectName("ff0_5")
self.gridLayout_110.addWidget(self.ff0_5, 3, 1, 1, 1)
self.label_766 = QtWidgets.QLabel(self.groupBox_63)
self.label_766.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_766.setObjectName("label_766")
self.gridLayout_110.addWidget(self.label_766, 4, 0, 1, 1)
self.ff1_5 = QtWidgets.QLineEdit(self.groupBox_63)
self.ff1_5.setText("")
self.ff1_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff1_5.setObjectName("ff1_5")
self.gridLayout_110.addWidget(self.ff1_5, 4, 1, 1, 1)
self.label_767 = QtWidgets.QLabel(self.groupBox_63)
self.label_767.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_767.setObjectName("label_767")
self.gridLayout_110.addWidget(self.label_767, 5, 0, 1, 1)
self.ff2_5 = QtWidgets.QLineEdit(self.groupBox_63)
self.ff2_5.setText("")
self.ff2_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff2_5.setObjectName("ff2_5")
self.gridLayout_110.addWidget(self.ff2_5, 5, 1, 1, 1)
self.pidDefault_5 = QtWidgets.QPushButton(self.groupBox_63)
self.pidDefault_5.setObjectName("pidDefault_5")
self.gridLayout_110.addWidget(self.pidDefault_5, 5, 3, 1, 1)
self.maxError_5 = QtWidgets.QLineEdit(self.groupBox_63)
self.maxError_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxError_5.setObjectName("maxError_5")
self.gridLayout_110.addWidget(self.maxError_5, 3, 3, 1, 1)
self.label_768 = QtWidgets.QLabel(self.groupBox_63)
self.label_768.setObjectName("label_768")
self.gridLayout_110.addWidget(self.label_768, 3, 2, 1, 1)
self.gridLayout_15.addWidget(self.groupBox_63, 1, 0, 1, 1)
self.gridGroupBox_4 = QtWidgets.QGroupBox(self.tab_3)
self.gridGroupBox_4.setObjectName("gridGroupBox_4")
self.gridLayout_109 = QtWidgets.QGridLayout(self.gridGroupBox_4)
self.gridLayout_109.setContentsMargins(8, 8, 8, 8)
self.gridLayout_109.setSpacing(5)
self.gridLayout_109.setObjectName("gridLayout_109")
self.stepRateJoint_5 = QtWidgets.QLabel(self.gridGroupBox_4)
self.stepRateJoint_5.setFrameShape(QtWidgets.QFrame.Box)
self.stepRateJoint_5.setText("")
self.stepRateJoint_5.setObjectName("stepRateJoint_5")
self.gridLayout_109.addWidget(self.stepRateJoint_5, 2, 1, 1, 1)
self.label_758 = QtWidgets.QLabel(self.gridGroupBox_4)
self.label_758.setObjectName("label_758")
self.gridLayout_109.addWidget(self.label_758, 2, 0, 1, 1)
self.timeJoint_5 = QtWidgets.QLabel(self.gridGroupBox_4)
self.timeJoint_5.setFrameShape(QtWidgets.QFrame.Box)
self.timeJoint_5.setText("")
self.timeJoint_5.setObjectName("timeJoint_5")
self.gridLayout_109.addWidget(self.timeJoint_5, 0, 1, 1, 1)
self.label_756 = QtWidgets.QLabel(self.gridGroupBox_4)
self.label_756.setObjectName("label_756")
self.gridLayout_109.addWidget(self.label_756, 0, 0, 1, 1)
self.label_757 = QtWidgets.QLabel(self.gridGroupBox_4)
self.label_757.setObjectName("label_757")
self.gridLayout_109.addWidget(self.label_757, 1, 0, 1, 1)
self.distanceJoint_5 = QtWidgets.QLabel(self.gridGroupBox_4)
self.distanceJoint_5.setFrameShape(QtWidgets.QFrame.Box)
self.distanceJoint_5.setText("")
self.distanceJoint_5.setObjectName("distanceJoint_5")
self.gridLayout_109.addWidget(self.distanceJoint_5, 1, 1, 1, 1)
self.gridLayout_15.addWidget(self.gridGroupBox_4, 2, 1, 1, 1)
self.groupBox_62 = QtWidgets.QGroupBox(self.tab_3)
self.groupBox_62.setObjectName("groupBox_62")
self.gridLayout_108 = QtWidgets.QGridLayout(self.groupBox_62)
self.gridLayout_108.setContentsMargins(10, 10, 10, 10)
self.gridLayout_108.setSpacing(5)
self.gridLayout_108.setObjectName("gridLayout_108")
self.label_751 = QtWidgets.QLabel(self.groupBox_62)
self.label_751.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_751.setObjectName("label_751")
self.gridLayout_108.addWidget(self.label_751, 0, 0, 1, 1)
self.homeSearchVel_5 = QtWidgets.QLineEdit(self.groupBox_62)
self.homeSearchVel_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeSearchVel_5.setObjectName("homeSearchVel_5")
self.gridLayout_108.addWidget(self.homeSearchVel_5, 2, 1, 1, 1)
self.label_16 = QtWidgets.QLabel(self.groupBox_62)
self.label_16.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_16.setObjectName("label_16")
self.gridLayout_108.addWidget(self.label_16, 4, 0, 1, 1)
self.label_752 = QtWidgets.QLabel(self.groupBox_62)
self.label_752.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_752.setObjectName("label_752")
self.gridLayout_108.addWidget(self.label_752, 5, 0, 1, 1)
self.homeIgnoreLimits_5 = QtWidgets.QCheckBox(self.groupBox_62)
self.homeIgnoreLimits_5.setObjectName("homeIgnoreLimits_5")
self.gridLayout_108.addWidget(self.homeIgnoreLimits_5, 6, 1, 1, 1)
self.homeSequence_5 = QtWidgets.QLineEdit(self.groupBox_62)
self.homeSequence_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeSequence_5.setObjectName("homeSequence_5")
self.gridLayout_108.addWidget(self.homeSequence_5, 5, 1, 1, 1)
self.homeLatchVel_5 = QtWidgets.QLineEdit(self.groupBox_62)
self.homeLatchVel_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeLatchVel_5.setObjectName("homeLatchVel_5")
self.gridLayout_108.addWidget(self.homeLatchVel_5, 3, 1, 1, 1)
self.label_753 = QtWidgets.QLabel(self.groupBox_62)
self.label_753.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_753.setObjectName("label_753")
self.gridLayout_108.addWidget(self.label_753, 2, 0, 1, 1)
self.home_5 = QtWidgets.QLineEdit(self.groupBox_62)
self.home_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.home_5.setObjectName("home_5")
self.gridLayout_108.addWidget(self.home_5, 0, 1, 1, 1)
self.homeUseIndex_5 = QtWidgets.QCheckBox(self.groupBox_62)
self.homeUseIndex_5.setObjectName("homeUseIndex_5")
self.gridLayout_108.addWidget(self.homeUseIndex_5, 7, 1, 1, 1)
self.label_754 = QtWidgets.QLabel(self.groupBox_62)
self.label_754.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_754.setObjectName("label_754")
self.gridLayout_108.addWidget(self.label_754, 1, 0, 1, 1)
self.homeOffset_5 = QtWidgets.QLineEdit(self.groupBox_62)
self.homeOffset_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeOffset_5.setObjectName("homeOffset_5")
self.gridLayout_108.addWidget(self.homeOffset_5, 1, 1, 1, 1)
self.homeFinalVelocity_5 = QtWidgets.QLineEdit(self.groupBox_62)
self.homeFinalVelocity_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.homeFinalVelocity_5.setObjectName("homeFinalVelocity_5")
self.gridLayout_108.addWidget(self.homeFinalVelocity_5, 4, 1, 1, 1)
self.label_755 = QtWidgets.QLabel(self.groupBox_62)
self.label_755.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_755.setObjectName("label_755")
self.gridLayout_108.addWidget(self.label_755, 3, 0, 1, 1)
self.homeSwitchShared_5 = QtWidgets.QCheckBox(self.groupBox_62)
self.homeSwitchShared_5.setObjectName("homeSwitchShared_5")
self.gridLayout_108.addWidget(self.homeSwitchShared_5, 8, 1, 1, 1)
self.gridLayout_15.addWidget(self.groupBox_62, 1, 1, 1, 1)
self.jointAxisGroup_5 = QtWidgets.QGroupBox(self.tab_3)
self.jointAxisGroup_5.setObjectName("jointAxisGroup_5")
self.gridLayout_55 = QtWidgets.QGridLayout(self.jointAxisGroup_5)
self.gridLayout_55.setContentsMargins(10, 10, 10, 10)
self.gridLayout_55.setSpacing(5)
self.gridLayout_55.setObjectName("gridLayout_55")
self.axisCB_5 = QtWidgets.QComboBox(self.jointAxisGroup_5)
self.axisCB_5.setObjectName("axisCB_5")
self.gridLayout_55.addWidget(self.axisCB_5, 1, 0, 1, 1)
self.label_293 = QtWidgets.QLabel(self.jointAxisGroup_5)
self.label_293.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_293.setWordWrap(True)
self.label_293.setObjectName("label_293")
self.gridLayout_55.addWidget(self.label_293, 0, 3, 1, 1)
self.label_419 = QtWidgets.QLabel(self.jointAxisGroup_5)
self.label_419.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_419.setObjectName("label_419")
self.gridLayout_55.addWidget(self.label_419, 0, 0, 1, 1)
self.minLimit_5 = QtWidgets.QLineEdit(self.jointAxisGroup_5)
self.minLimit_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.minLimit_5.setObjectName("minLimit_5")
self.gridLayout_55.addWidget(self.minLimit_5, 1, 3, 1, 1)
self.maxLimit_5 = QtWidgets.QLineEdit(self.jointAxisGroup_5)
self.maxLimit_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxLimit_5.setObjectName("maxLimit_5")
self.gridLayout_55.addWidget(self.maxLimit_5, 1, 4, 1, 1)
self.label_747 = QtWidgets.QLabel(self.jointAxisGroup_5)
self.label_747.setTextFormat(QtCore.Qt.AutoText)
self.label_747.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_747.setWordWrap(True)
self.label_747.setObjectName("label_747")
self.gridLayout_55.addWidget(self.label_747, 0, 4, 1, 1)
self.label_748 = QtWidgets.QLabel(self.jointAxisGroup_5)
self.label_748.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_748.setWordWrap(True)
self.label_748.setObjectName("label_748")
self.gridLayout_55.addWidget(self.label_748, 0, 5, 1, 1)
self.maxVelocity_5 = QtWidgets.QLineEdit(self.jointAxisGroup_5)
self.maxVelocity_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxVelocity_5.setObjectName("maxVelocity_5")
self.gridLayout_55.addWidget(self.maxVelocity_5, 1, 5, 1, 1)
self.label_749 = QtWidgets.QLabel(self.jointAxisGroup_5)
self.label_749.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_749.setObjectName("label_749")
self.gridLayout_55.addWidget(self.label_749, 0, 2, 1, 1)
self.label_750 = QtWidgets.QLabel(self.jointAxisGroup_5)
self.label_750.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignHCenter)
self.label_750.setWordWrap(True)
self.label_750.setObjectName("label_750")
self.gridLayout_55.addWidget(self.label_750, 0, 6, 1, 1)
self.maxAccel_5 = QtWidgets.QLineEdit(self.jointAxisGroup_5)
self.maxAccel_5.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxAccel_5.setObjectName("maxAccel_5")
self.gridLayout_55.addWidget(self.maxAccel_5, 1, 6, 1, 1)
self.label_33 = QtWidgets.QLabel(self.jointAxisGroup_5)
self.label_33.setAlignment(QtCore.Qt.AlignBottom|QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft)
self.label_33.setObjectName("label_33")
self.gridLayout_55.addWidget(self.label_33, 0, 1, 1, 1)
self.axisType_5 = QtWidgets.QLabel(self.jointAxisGroup_5)
self.axisType_5.setFrameShape(QtWidgets.QFrame.Box)
self.axisType_5.setText("")
self.axisType_5.setObjectName("axisType_5")
self.gridLayout_55.addWidget(self.axisType_5, 1, 1, 1, 1)
self.scale_5 = QtWidgets.QLineEdit(self.jointAxisGroup_5)
self.scale_5.setObjectName("scale_5")
self.gridLayout_55.addWidget(self.scale_5, 1, 2, 1, 1)
self.reverse_5 = QtWidgets.QCheckBox(self.jointAxisGroup_5)
self.reverse_5.setObjectName("reverse_5")
self.gridLayout_55.addWidget(self.reverse_5, 1, 7, 1, 1)
self.gridLayout_15.addWidget(self.jointAxisGroup_5, 0, 0, 1, 2)
self.analogGB_5 = QtWidgets.QGroupBox(self.tab_3)
self.analogGB_5.setObjectName("analogGB_5")
self.gridLayout_120 = QtWidgets.QGridLayout(self.analogGB_5)
self.gridLayout_120.setContentsMargins(8, 8, 8, 8)
self.gridLayout_120.setSpacing(5)
self.gridLayout_120.setObjectName("gridLayout_120")
self.analogScaleMax_5 = QtWidgets.QLineEdit(self.analogGB_5)
self.analogScaleMax_5.setObjectName("analogScaleMax_5")
self.gridLayout_120.addWidget(self.analogScaleMax_5, 2, 1, 1, 1)
self.label_46 = QtWidgets.QLabel(self.analogGB_5)
self.label_46.setObjectName("label_46")
self.gridLayout_120.addWidget(self.label_46, 1, 0, 1, 1)
self.analogMinLimit_5 = QtWidgets.QLineEdit(self.analogGB_5)
self.analogMinLimit_5.setObjectName("analogMinLimit_5")
self.gridLayout_120.addWidget(self.analogMinLimit_5, 0, 1, 1, 1)
self.label_47 = QtWidgets.QLabel(self.analogGB_5)
self.label_47.setObjectName("label_47")
self.gridLayout_120.addWidget(self.label_47, 2, 0, 1, 1)
self.analogMaxLimit_5 = QtWidgets.QLineEdit(self.analogGB_5)
self.analogMaxLimit_5.setObjectName("analogMaxLimit_5")
self.gridLayout_120.addWidget(self.analogMaxLimit_5, 1, 1, 1, 1)
self.analogDefault_5 = QtWidgets.QPushButton(self.analogGB_5)
self.analogDefault_5.setObjectName("analogDefault_5")
self.gridLayout_120.addWidget(self.analogDefault_5, 0, 2, 1, 1)
self.label_48 = QtWidgets.QLabel(self.analogGB_5)
self.label_48.setObjectName("label_48")
self.gridLayout_120.addWidget(self.label_48, 0, 0, 1, 1)
self.gridLayout_15.addWidget(self.analogGB_5, 2, 0, 1, 1)
self.groupBox_64 = QtWidgets.QGroupBox(self.tab_3)
self.groupBox_64.setObjectName("groupBox_64")
self.gridLayout_20 = QtWidgets.QGridLayout(self.groupBox_64)
self.gridLayout_20.setContentsMargins(8, 8, 8, 8)
self.gridLayout_20.setSpacing(5)
self.gridLayout_20.setObjectName("gridLayout_20")
self.label_60 = QtWidgets.QLabel(self.groupBox_64)
self.label_60.setObjectName("label_60")
self.gridLayout_20.addWidget(self.label_60, 0, 0, 1, 1)
self.encoderScale_5 = QtWidgets.QLineEdit(self.groupBox_64)
self.encoderScale_5.setObjectName("encoderScale_5")
self.gridLayout_20.addWidget(self.encoderScale_5, 0, 1, 1, 1)
self.gridLayout_15.addWidget(self.groupBox_64, 3, 0, 1, 1)
self.jointType_3.addTab(self.tab_3, "")
self.verticalLayout_2.addWidget(self.jointType_3)
self.tabWidget.addTab(self.axisTab, "")
self.spindle = QtWidgets.QWidget()
self.spindle.setObjectName("spindle")
self.label_142 = QtWidgets.QLabel(self.spindle)
self.label_142.setGeometry(QtCore.QRect(10, 20, 431, 51))
self.label_142.setObjectName("label_142")
self.spindlepidGB = QtWidgets.QGroupBox(self.spindle)
self.spindlepidGB.setEnabled(False)
self.spindlepidGB.setGeometry(QtCore.QRect(380, 80, 353, 197))
self.spindlepidGB.setCheckable(False)
self.spindlepidGB.setObjectName("spindlepidGB")
self.gridLayout_30 = QtWidgets.QGridLayout(self.spindlepidGB)
self.gridLayout_30.setContentsMargins(10, 15, 10, 10)
self.gridLayout_30.setSpacing(5)
self.gridLayout_30.setObjectName("gridLayout_30")
self.label_264 = QtWidgets.QLabel(self.spindlepidGB)
self.label_264.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_264.setObjectName("label_264")
self.gridLayout_30.addWidget(self.label_264, 0, 0, 1, 1)
self.p_s = QtWidgets.QLineEdit(self.spindlepidGB)
self.p_s.setText("")
self.p_s.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.p_s.setObjectName("p_s")
self.gridLayout_30.addWidget(self.p_s, 0, 1, 1, 1)
self.label_265 = QtWidgets.QLabel(self.spindlepidGB)
self.label_265.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_265.setObjectName("label_265")
self.gridLayout_30.addWidget(self.label_265, 0, 2, 1, 1)
self.deadband_s = QtWidgets.QLineEdit(self.spindlepidGB)
self.deadband_s.setText("")
self.deadband_s.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.deadband_s.setObjectName("deadband_s")
self.gridLayout_30.addWidget(self.deadband_s, 0, 3, 1, 1)
self.label_266 = QtWidgets.QLabel(self.spindlepidGB)
self.label_266.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_266.setObjectName("label_266")
self.gridLayout_30.addWidget(self.label_266, 1, 0, 1, 1)
self.i_s = QtWidgets.QLineEdit(self.spindlepidGB)
self.i_s.setText("")
self.i_s.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.i_s.setObjectName("i_s")
self.gridLayout_30.addWidget(self.i_s, 1, 1, 1, 1)
self.label_267 = QtWidgets.QLabel(self.spindlepidGB)
self.label_267.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_267.setObjectName("label_267")
self.gridLayout_30.addWidget(self.label_267, 1, 2, 1, 1)
self.bias_s = QtWidgets.QLineEdit(self.spindlepidGB)
self.bias_s.setText("")
self.bias_s.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.bias_s.setObjectName("bias_s")
self.gridLayout_30.addWidget(self.bias_s, 1, 3, 1, 1)
self.label_268 = QtWidgets.QLabel(self.spindlepidGB)
self.label_268.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_268.setObjectName("label_268")
self.gridLayout_30.addWidget(self.label_268, 2, 0, 1, 1)
self.d_s = QtWidgets.QLineEdit(self.spindlepidGB)
self.d_s.setText("")
self.d_s.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.d_s.setObjectName("d_s")
self.gridLayout_30.addWidget(self.d_s, 2, 1, 1, 1)
self.label_269 = QtWidgets.QLabel(self.spindlepidGB)
self.label_269.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_269.setObjectName("label_269")
self.gridLayout_30.addWidget(self.label_269, 2, 2, 1, 1)
self.maxOutput_s = QtWidgets.QLineEdit(self.spindlepidGB)
self.maxOutput_s.setText("")
self.maxOutput_s.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxOutput_s.setObjectName("maxOutput_s")
self.gridLayout_30.addWidget(self.maxOutput_s, 2, 3, 1, 1)
self.label_270 = QtWidgets.QLabel(self.spindlepidGB)
self.label_270.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_270.setObjectName("label_270")
self.gridLayout_30.addWidget(self.label_270, 3, 0, 1, 1)
self.ff0_s = QtWidgets.QLineEdit(self.spindlepidGB)
self.ff0_s.setText("")
self.ff0_s.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff0_s.setObjectName("ff0_s")
self.gridLayout_30.addWidget(self.ff0_s, 3, 1, 1, 1)
self.label_271 = QtWidgets.QLabel(self.spindlepidGB)
self.label_271.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_271.setObjectName("label_271")
self.gridLayout_30.addWidget(self.label_271, 3, 2, 1, 1)
self.maxError_s = QtWidgets.QLineEdit(self.spindlepidGB)
self.maxError_s.setText("")
self.maxError_s.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.maxError_s.setObjectName("maxError_s")
self.gridLayout_30.addWidget(self.maxError_s, 3, 3, 1, 1)
self.label_272 = QtWidgets.QLabel(self.spindlepidGB)
self.label_272.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_272.setObjectName("label_272")
self.gridLayout_30.addWidget(self.label_272, 4, 0, 1, 1)
self.ff1_s = QtWidgets.QLineEdit(self.spindlepidGB)
self.ff1_s.setText("")
self.ff1_s.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff1_s.setObjectName("ff1_s")
self.gridLayout_30.addWidget(self.ff1_s, 4, 1, 1, 1)
self.label_273 = QtWidgets.QLabel(self.spindlepidGB)
self.label_273.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_273.setObjectName("label_273")
self.gridLayout_30.addWidget(self.label_273, 5, 0, 1, 1)
self.ff2_s = QtWidgets.QLineEdit(self.spindlepidGB)
self.ff2_s.setText("")
self.ff2_s.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.ff2_s.setObjectName("ff2_s")
self.gridLayout_30.addWidget(self.ff2_s, 5, 1, 1, 1)
self.pidDefault_s = QtWidgets.QPushButton(self.spindlepidGB)
self.pidDefault_s.setObjectName("pidDefault_s")
self.gridLayout_30.addWidget(self.pidDefault_s, 5, 3, 1, 1)
self.encoderGB = QtWidgets.QGroupBox(self.spindle)
self.encoderGB.setEnabled(False)
self.encoderGB.setGeometry(QtCore.QRect(30, 80, 331, 111))
self.encoderGB.setCheckable(False)
self.encoderGB.setChecked(False)
self.encoderGB.setObjectName("encoderGB")
self.gridLayout_31 = QtWidgets.QGridLayout(self.encoderGB)
self.gridLayout_31.setContentsMargins(8, 8, 8, 8)
self.gridLayout_31.setSpacing(5)
self.gridLayout_31.setObjectName("gridLayout_31")
self.spindleScale = QtWidgets.QLineEdit(self.encoderGB)
self.spindleScale.setObjectName("spindleScale")
self.gridLayout_31.addWidget(self.spindleScale, 0, 1, 1, 1)
self.label_178 = QtWidgets.QLabel(self.encoderGB)
self.label_178.setObjectName("label_178")
self.gridLayout_31.addWidget(self.label_178, 0, 0, 1, 1)
self.spindleTypeCB = QtWidgets.QComboBox(self.spindle)
self.spindleTypeCB.setGeometry(QtCore.QRect(562, 30, 151, 23))
self.spindleTypeCB.setObjectName("spindleTypeCB")
self.label_193 = QtWidgets.QLabel(self.spindle)
self.label_193.setGeometry(QtCore.QRect(440, 30, 91, 20))
self.label_193.setObjectName("label_193")
self.spindleGB = QtWidgets.QGroupBox(self.spindle)
self.spindleGB.setEnabled(False)
self.spindleGB.setGeometry(QtCore.QRect(29, 220, 331, 111))
self.spindleGB.setObjectName("spindleGB")
self.gridLayout_37 = QtWidgets.QGridLayout(self.spindleGB)
self.gridLayout_37.setContentsMargins(8, 15, 8, 8)
self.gridLayout_37.setSpacing(5)
self.gridLayout_37.setObjectName("gridLayout_37")
self.label_180 = QtWidgets.QLabel(self.spindleGB)
self.label_180.setObjectName("label_180")
self.gridLayout_37.addWidget(self.label_180, 1, 0, 1, 1)
self.spindleMaxRpm = QtWidgets.QLineEdit(self.spindleGB)
self.spindleMaxRpm.setObjectName("spindleMaxRpm")
self.gridLayout_37.addWidget(self.spindleMaxRpm, 1, 1, 1, 1)
self.label_192 = QtWidgets.QLabel(self.spindleGB)
self.label_192.setObjectName("label_192")
self.gridLayout_37.addWidget(self.label_192, 0, 0, 1, 1)
self.spindleMinRpm = QtWidgets.QLineEdit(self.spindleGB)
self.spindleMinRpm.setObjectName("spindleMinRpm")
self.gridLayout_37.addWidget(self.spindleMinRpm, 0, 1, 1, 1)
self.label_194 = QtWidgets.QLabel(self.spindleGB)
self.label_194.setObjectName("label_194")
self.gridLayout_37.addWidget(self.label_194, 2, 0, 1, 1)
self.pwmFrequencySB = QtWidgets.QSpinBox(self.spindleGB)
self.pwmFrequencySB.setMaximum(193000)
self.pwmFrequencySB.setProperty("value", 5000)
self.pwmFrequencySB.setObjectName("pwmFrequencySB")
self.gridLayout_37.addWidget(self.pwmFrequencySB, 2, 1, 1, 1)
self.label_198 = QtWidgets.QLabel(self.spindleGB)
self.label_198.setObjectName("label_198")
self.gridLayout_37.addWidget(self.label_198, 2, 2, 1, 1)
self.spindleInfoGB = QtWidgets.QGroupBox(self.spindle)
self.spindleInfoGB.setEnabled(False)
self.spindleInfoGB.setGeometry(QtCore.QRect(400, 300, 291, 171))
self.spindleInfoGB.setObjectName("spindleInfoGB")
self.gridLayout_38 = QtWidgets.QGridLayout(self.spindleInfoGB)
self.gridLayout_38.setContentsMargins(8, 15, 8, 8)
self.gridLayout_38.setSpacing(5)
self.gridLayout_38.setObjectName("gridLayout_38")
self.spindleInfo3Lbl = QtWidgets.QLabel(self.spindleInfoGB)
self.spindleInfo3Lbl.setFrameShape(QtWidgets.QFrame.Box)
self.spindleInfo3Lbl.setText("")
self.spindleInfo3Lbl.setObjectName("spindleInfo3Lbl")
self.gridLayout_38.addWidget(self.spindleInfo3Lbl, 2, 0, 1, 1)
self.spindleInfo2Lbl = QtWidgets.QLabel(self.spindleInfoGB)
self.spindleInfo2Lbl.setFrameShape(QtWidgets.QFrame.Box)
self.spindleInfo2Lbl.setText("")
self.spindleInfo2Lbl.setObjectName("spindleInfo2Lbl")
self.gridLayout_38.addWidget(self.spindleInfo2Lbl, 1, 0, 1, 1)
self.spindleInfo1Lbl = QtWidgets.QLabel(self.spindleInfoGB)
self.spindleInfo1Lbl.setFrameShape(QtWidgets.QFrame.Box)
self.spindleInfo1Lbl.setObjectName("spindleInfo1Lbl")
self.gridLayout_38.addWidget(self.spindleInfo1Lbl, 0, 0, 1, 1)
self.spindleInfo4Lbl = QtWidgets.QLabel(self.spindleInfoGB)
self.spindleInfo4Lbl.setFrameShape(QtWidgets.QFrame.Box)
self.spindleInfo4Lbl.setText("")
self.spindleInfo4Lbl.setObjectName("spindleInfo4Lbl")
self.gridLayout_38.addWidget(self.spindleInfo4Lbl, 3, 0, 1, 1)
self.tabWidget.addTab(self.spindle, "")
self.inputs = QtWidgets.QWidget()
self.inputs.setObjectName("inputs")
self.gridLayout_125 = QtWidgets.QGridLayout(self.inputs)
self.gridLayout_125.setContentsMargins(8, 8, 8, 8)
self.gridLayout_125.setSpacing(5)
self.gridLayout_125.setObjectName("gridLayout_125")
self.groupBox_59 = QtWidgets.QGroupBox(self.inputs)
self.groupBox_59.setMinimumSize(QtCore.QSize(250, 0))
self.groupBox_59.setObjectName("groupBox_59")
self.gridLayout_106 = QtWidgets.QGridLayout(self.groupBox_59)
self.gridLayout_106.setContentsMargins(8, 8, 8, 8)
self.gridLayout_106.setSpacing(5)
self.gridLayout_106.setObjectName("gridLayout_106")
self.label_481 = QtWidgets.QLabel(self.groupBox_59)
self.label_481.setObjectName("label_481")
self.gridLayout_106.addWidget(self.label_481, 1, 0, 1, 1)
self.label_746 = QtWidgets.QLabel(self.groupBox_59)
self.label_746.setObjectName("label_746")
self.gridLayout_106.addWidget(self.label_746, 3, 0, 1, 1)
self.label_482 = QtWidgets.QLabel(self.groupBox_59)
self.label_482.setObjectName("label_482")
self.gridLayout_106.addWidget(self.label_482, 4, 0, 1, 1)
self.label_541 = QtWidgets.QLabel(self.groupBox_59)
self.label_541.setObjectName("label_541")
self.gridLayout_106.addWidget(self.label_541, 5, 0, 1, 1)
self.label_483 = QtWidgets.QLabel(self.groupBox_59)
self.label_483.setObjectName("label_483")
self.gridLayout_106.addWidget(self.label_483, 2, 0, 1, 1)
self.label_521 = QtWidgets.QLabel(self.groupBox_59)
self.label_521.setObjectName("label_521")
self.gridLayout_106.addWidget(self.label_521, 0, 0, 1, 1)
self.outputPB_0 = QtWidgets.QPushButton(self.groupBox_59)
self.outputPB_0.setObjectName("outputPB_0")
self.gridLayout_106.addWidget(self.outputPB_0, 0, 1, 1, 1)
self.outputPB_1 = QtWidgets.QPushButton(self.groupBox_59)
self.outputPB_1.setObjectName("outputPB_1")
self.gridLayout_106.addWidget(self.outputPB_1, 1, 1, 1, 1)
self.outputPB_2 = QtWidgets.QPushButton(self.groupBox_59)
self.outputPB_2.setObjectName("outputPB_2")
self.gridLayout_106.addWidget(self.outputPB_2, 2, 1, 1, 1)
self.outputPB_3 = QtWidgets.QPushButton(self.groupBox_59)
self.outputPB_3.setObjectName("outputPB_3")
self.gridLayout_106.addWidget(self.outputPB_3, 3, 1, 1, 1)
self.outputPB_4 = QtWidgets.QPushButton(self.groupBox_59)
self.outputPB_4.setObjectName("outputPB_4")
self.gridLayout_106.addWidget(self.outputPB_4, 4, 1, 1, 1)
self.outputPB_5 = QtWidgets.QPushButton(self.groupBox_59)
self.outputPB_5.setObjectName("outputPB_5")
self.gridLayout_106.addWidget(self.outputPB_5, 5, 1, 1, 1)
self.gridLayout_125.addWidget(self.groupBox_59, 0, 2, 1, 1)
self.groupBox = QtWidgets.QGroupBox(self.inputs)
self.groupBox.setMinimumSize(QtCore.QSize(350, 0))
self.groupBox.setObjectName("groupBox")
self.gridLayout_105 = QtWidgets.QGridLayout(self.groupBox)
self.gridLayout_105.setContentsMargins(8, 8, 8, 8)
self.gridLayout_105.setSpacing(5)
self.gridLayout_105.setObjectName("gridLayout_105")
self.inputInvertCB_7 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_7.setObjectName("inputInvertCB_7")
self.gridLayout_105.addWidget(self.inputInvertCB_7, 7, 3, 1, 1)
self.inputPB_6 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_6.setObjectName("inputPB_6")
self.gridLayout_105.addWidget(self.inputPB_6, 6, 1, 1, 1)
self.label_472 = QtWidgets.QLabel(self.groupBox)
self.label_472.setAlignment(QtCore.Qt.AlignCenter)
self.label_472.setObjectName("label_472")
self.gridLayout_105.addWidget(self.label_472, 3, 0, 1, 1)
self.label_478 = QtWidgets.QLabel(self.groupBox)
self.label_478.setAlignment(QtCore.Qt.AlignCenter)
self.label_478.setObjectName("label_478")
self.gridLayout_105.addWidget(self.label_478, 4, 0, 1, 1)
self.inputPB_4 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_4.setObjectName("inputPB_4")
self.gridLayout_105.addWidget(self.inputPB_4, 4, 1, 1, 1)
self.label_470 = QtWidgets.QLabel(self.groupBox)
self.label_470.setAlignment(QtCore.Qt.AlignCenter)
self.label_470.setObjectName("label_470")
self.gridLayout_105.addWidget(self.label_470, 1, 0, 1, 1)
self.inputInvertCB_9 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_9.setObjectName("inputInvertCB_9")
self.gridLayout_105.addWidget(self.inputInvertCB_9, 9, 3, 1, 1)
self.inputPB_14 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_14.setObjectName("inputPB_14")
self.gridLayout_105.addWidget(self.inputPB_14, 14, 1, 1, 1)
self.inputInvertCB_2 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_2.setObjectName("inputInvertCB_2")
self.gridLayout_105.addWidget(self.inputInvertCB_2, 2, 3, 1, 1)
self.label_770 = QtWidgets.QLabel(self.groupBox)
self.label_770.setAlignment(QtCore.Qt.AlignCenter)
self.label_770.setObjectName("label_770")
self.gridLayout_105.addWidget(self.label_770, 12, 0, 1, 1)
self.inputInvertCB_3 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_3.setObjectName("inputInvertCB_3")
self.gridLayout_105.addWidget(self.inputInvertCB_3, 3, 3, 1, 1)
self.label_480 = QtWidgets.QLabel(self.groupBox)
self.label_480.setAlignment(QtCore.Qt.AlignCenter)
self.label_480.setObjectName("label_480")
self.gridLayout_105.addWidget(self.label_480, 9, 0, 1, 1)
self.inputInvertCB_1 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_1.setObjectName("inputInvertCB_1")
self.gridLayout_105.addWidget(self.inputInvertCB_1, 1, 3, 1, 1)
self.inputPB_5 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_5.setObjectName("inputPB_5")
self.gridLayout_105.addWidget(self.inputPB_5, 5, 1, 1, 1)
self.label_475 = QtWidgets.QLabel(self.groupBox)
self.label_475.setAlignment(QtCore.Qt.AlignCenter)
self.label_475.setObjectName("label_475")
self.gridLayout_105.addWidget(self.label_475, 8, 0, 1, 1)
self.inputInvertCB_11 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_11.setObjectName("inputInvertCB_11")
self.gridLayout_105.addWidget(self.inputInvertCB_11, 11, 3, 1, 1)
self.inputPB_11 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_11.setObjectName("inputPB_11")
self.gridLayout_105.addWidget(self.inputPB_11, 11, 1, 1, 1)
self.inputPB_3 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_3.setObjectName("inputPB_3")
self.gridLayout_105.addWidget(self.inputPB_3, 3, 1, 1, 1)
self.inputPB_8 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_8.setObjectName("inputPB_8")
self.gridLayout_105.addWidget(self.inputPB_8, 8, 1, 1, 1)
self.inputInvertCB_0 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_0.setObjectName("inputInvertCB_0")
self.gridLayout_105.addWidget(self.inputInvertCB_0, 0, 3, 1, 1)
self.inputInvertCB_4 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_4.setObjectName("inputInvertCB_4")
self.gridLayout_105.addWidget(self.inputInvertCB_4, 4, 3, 1, 1)
self.inputInvertCB_14 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_14.setObjectName("inputInvertCB_14")
self.gridLayout_105.addWidget(self.inputInvertCB_14, 14, 3, 1, 1)
self.inputPB_15 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_15.setObjectName("inputPB_15")
self.gridLayout_105.addWidget(self.inputPB_15, 15, 1, 1, 1)
self.label_473 = QtWidgets.QLabel(self.groupBox)
self.label_473.setAlignment(QtCore.Qt.AlignCenter)
self.label_473.setObjectName("label_473")
self.gridLayout_105.addWidget(self.label_473, 0, 0, 1, 1)
self.label_773 = QtWidgets.QLabel(self.groupBox)
self.label_773.setAlignment(QtCore.Qt.AlignCenter)
self.label_773.setObjectName("label_773")
self.gridLayout_105.addWidget(self.label_773, 15, 0, 1, 1)
self.inputPB_10 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_10.setObjectName("inputPB_10")
self.gridLayout_105.addWidget(self.inputPB_10, 10, 1, 1, 1)
self.inputInvertCB_10 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_10.setObjectName("inputInvertCB_10")
self.gridLayout_105.addWidget(self.inputInvertCB_10, 10, 3, 1, 1)
self.label_476 = QtWidgets.QLabel(self.groupBox)
self.label_476.setAlignment(QtCore.Qt.AlignCenter)
self.label_476.setObjectName("label_476")
self.gridLayout_105.addWidget(self.label_476, 10, 0, 1, 1)
self.inputInvertCB_5 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_5.setObjectName("inputInvertCB_5")
self.gridLayout_105.addWidget(self.inputInvertCB_5, 5, 3, 1, 1)
self.inputInvertCB_15 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_15.setObjectName("inputInvertCB_15")
self.gridLayout_105.addWidget(self.inputInvertCB_15, 15, 3, 1, 1)
self.label_471 = QtWidgets.QLabel(self.groupBox)
self.label_471.setAlignment(QtCore.Qt.AlignCenter)
self.label_471.setObjectName("label_471")
self.gridLayout_105.addWidget(self.label_471, 7, 0, 1, 1)
self.inputPB_9 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_9.setObjectName("inputPB_9")
self.gridLayout_105.addWidget(self.inputPB_9, 9, 1, 1, 1)
self.inputPB_7 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_7.setObjectName("inputPB_7")
self.gridLayout_105.addWidget(self.inputPB_7, 7, 1, 1, 1)
self.inputPB_12 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_12.setObjectName("inputPB_12")
self.gridLayout_105.addWidget(self.inputPB_12, 12, 1, 1, 1)
self.inputInvertCB_6 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_6.setObjectName("inputInvertCB_6")
self.gridLayout_105.addWidget(self.inputInvertCB_6, 6, 3, 1, 1)
self.inputInvertCB_8 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_8.setObjectName("inputInvertCB_8")
self.gridLayout_105.addWidget(self.inputInvertCB_8, 8, 3, 1, 1)
self.inputPB_13 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_13.setObjectName("inputPB_13")
self.gridLayout_105.addWidget(self.inputPB_13, 13, 1, 1, 1)
self.label_477 = QtWidgets.QLabel(self.groupBox)
self.label_477.setAlignment(QtCore.Qt.AlignCenter)
self.label_477.setObjectName("label_477")
self.gridLayout_105.addWidget(self.label_477, 2, 0, 1, 1)
self.label_771 = QtWidgets.QLabel(self.groupBox)
self.label_771.setAlignment(QtCore.Qt.AlignCenter)
self.label_771.setObjectName("label_771")
self.gridLayout_105.addWidget(self.label_771, 13, 0, 1, 1)
self.label_772 = QtWidgets.QLabel(self.groupBox)
self.label_772.setAlignment(QtCore.Qt.AlignCenter)
self.label_772.setObjectName("label_772")
self.gridLayout_105.addWidget(self.label_772, 14, 0, 1, 1)
self.inputPB_1 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_1.setObjectName("inputPB_1")
self.gridLayout_105.addWidget(self.inputPB_1, 1, 1, 1, 1)
self.label_474 = QtWidgets.QLabel(self.groupBox)
self.label_474.setAlignment(QtCore.Qt.AlignCenter)
self.label_474.setObjectName("label_474")
self.gridLayout_105.addWidget(self.label_474, 5, 0, 1, 1)
self.label_479 = QtWidgets.QLabel(self.groupBox)
self.label_479.setAlignment(QtCore.Qt.AlignCenter)
self.label_479.setObjectName("label_479")
self.gridLayout_105.addWidget(self.label_479, 6, 0, 1, 1)
self.inputPB_2 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_2.setObjectName("inputPB_2")
self.gridLayout_105.addWidget(self.inputPB_2, 2, 1, 1, 1)
self.inputPB_0 = QtWidgets.QPushButton(self.groupBox)
self.inputPB_0.setObjectName("inputPB_0")
self.gridLayout_105.addWidget(self.inputPB_0, 0, 1, 1, 1)
self.inputInvertCB_13 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_13.setObjectName("inputInvertCB_13")
self.gridLayout_105.addWidget(self.inputInvertCB_13, 13, 3, 1, 1)
self.label_769 = QtWidgets.QLabel(self.groupBox)
self.label_769.setAlignment(QtCore.Qt.AlignCenter)
self.label_769.setObjectName("label_769")
self.gridLayout_105.addWidget(self.label_769, 11, 0, 1, 1)
self.inputInvertCB_12 = QtWidgets.QCheckBox(self.groupBox)
self.inputInvertCB_12.setObjectName("inputInvertCB_12")
self.gridLayout_105.addWidget(self.inputInvertCB_12, 12, 3, 1, 1)
self.inputDebounceCB_0 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_0.setObjectName("inputDebounceCB_0")
self.gridLayout_105.addWidget(self.inputDebounceCB_0, 0, 2, 1, 1)
self.inputDebounceCB_1 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_1.setObjectName("inputDebounceCB_1")
self.gridLayout_105.addWidget(self.inputDebounceCB_1, 1, 2, 1, 1)
self.inputDebounceCB_2 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_2.setObjectName("inputDebounceCB_2")
self.gridLayout_105.addWidget(self.inputDebounceCB_2, 2, 2, 1, 1)
self.inputDebounceCB_3 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_3.setObjectName("inputDebounceCB_3")
self.gridLayout_105.addWidget(self.inputDebounceCB_3, 3, 2, 1, 1)
self.inputDebounceCB_4 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_4.setObjectName("inputDebounceCB_4")
self.gridLayout_105.addWidget(self.inputDebounceCB_4, 4, 2, 1, 1)
self.inputDebounceCB_5 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_5.setObjectName("inputDebounceCB_5")
self.gridLayout_105.addWidget(self.inputDebounceCB_5, 5, 2, 1, 1)
self.inputDebounceCB_6 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_6.setObjectName("inputDebounceCB_6")
self.gridLayout_105.addWidget(self.inputDebounceCB_6, 6, 2, 1, 1)
self.inputDebounceCB_7 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_7.setObjectName("inputDebounceCB_7")
self.gridLayout_105.addWidget(self.inputDebounceCB_7, 7, 2, 1, 1)
self.inputDebounceCB_8 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_8.setObjectName("inputDebounceCB_8")
self.gridLayout_105.addWidget(self.inputDebounceCB_8, 8, 2, 1, 1)
self.inputDebounceCB_9 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_9.setObjectName("inputDebounceCB_9")
self.gridLayout_105.addWidget(self.inputDebounceCB_9, 9, 2, 1, 1)
self.inputDebounceCB_10 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_10.setObjectName("inputDebounceCB_10")
self.gridLayout_105.addWidget(self.inputDebounceCB_10, 10, 2, 1, 1)
self.inputDebounceCB_11 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_11.setObjectName("inputDebounceCB_11")
self.gridLayout_105.addWidget(self.inputDebounceCB_11, 11, 2, 1, 1)
self.inputDebounceCB_12 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_12.setObjectName("inputDebounceCB_12")
self.gridLayout_105.addWidget(self.inputDebounceCB_12, 12, 2, 1, 1)
self.inputDebounceCB_13 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_13.setObjectName("inputDebounceCB_13")
self.gridLayout_105.addWidget(self.inputDebounceCB_13, 13, 2, 1, 1)
self.inputDebounceCB_14 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_14.setObjectName("inputDebounceCB_14")
self.gridLayout_105.addWidget(self.inputDebounceCB_14, 14, 2, 1, 1)
self.inputDebounceCB_15 = QtWidgets.QCheckBox(self.groupBox)
self.inputDebounceCB_15.setObjectName("inputDebounceCB_15")
self.gridLayout_105.addWidget(self.inputDebounceCB_15, 15, 2, 1, 1)
self.gridLayout_125.addWidget(self.groupBox, 0, 0, 2, 1)
spacerItem = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)
self.gridLayout_125.addItem(spacerItem, 0, 1, 1, 1)
spacerItem1 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_125.addItem(spacerItem1, 1, 2, 2, 1)
self.groupBox_65 = QtWidgets.QGroupBox(self.inputs)
self.groupBox_65.setObjectName("groupBox_65")
self.gridLayout_124 = QtWidgets.QGridLayout(self.groupBox_65)
self.gridLayout_124.setContentsMargins(8, 8, 8, 8)
self.gridLayout_124.setSpacing(5)
self.gridLayout_124.setObjectName("gridLayout_124")
self.fastScanSB = QtWidgets.QSpinBox(self.groupBox_65)
self.fastScanSB.setProperty("value", 5)
self.fastScanSB.setObjectName("fastScanSB")
self.gridLayout_124.addWidget(self.fastScanSB, 2, 1, 1, 1)
self.label_102 = QtWidgets.QLabel(self.groupBox_65)
self.label_102.setObjectName("label_102")
self.gridLayout_124.addWidget(self.label_102, 2, 0, 1, 1)
self.slowScanSB = QtWidgets.QSpinBox(self.groupBox_65)
self.slowScanSB.setMinimum(1)
self.slowScanSB.setMaximum(1023)
self.slowScanSB.setProperty("value", 500)
self.slowScanSB.setObjectName("slowScanSB")
self.gridLayout_124.addWidget(self.slowScanSB, 1, 1, 1, 1)
self.label_54 = QtWidgets.QLabel(self.groupBox_65)
self.label_54.setObjectName("label_54")
self.gridLayout_124.addWidget(self.label_54, 1, 0, 1, 1)
self.label_104 = QtWidgets.QLabel(self.groupBox_65)
self.label_104.setObjectName("label_104")
self.gridLayout_124.addWidget(self.label_104, 0, 0, 1, 2)
self.gridLayout_125.addWidget(self.groupBox_65, 2, 0, 1, 1)
spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_125.addItem(spacerItem2, 3, 0, 1, 1)
self.tabWidget.addTab(self.inputs, "")
self.tab = QtWidgets.QWidget()
self.tab.setObjectName("tab")
self.groupBox_18 = QtWidgets.QGroupBox(self.tab)
self.groupBox_18.setGeometry(QtCore.QRect(30, 40, 301, 101))
self.groupBox_18.setObjectName("groupBox_18")
self.gridLayout_57 = QtWidgets.QGridLayout(self.groupBox_18)
self.gridLayout_57.setContentsMargins(8, 8, 8, 8)
self.gridLayout_57.setSpacing(5)
self.gridLayout_57.setObjectName("gridLayout_57")
self.label_411 = QtWidgets.QLabel(self.groupBox_18)
self.label_411.setObjectName("label_411")
self.gridLayout_57.addWidget(self.label_411, 0, 0, 1, 1)
self.toolChangerTypeCB = QtWidgets.QComboBox(self.groupBox_18)
self.toolChangerTypeCB.setObjectName("toolChangerTypeCB")
self.gridLayout_57.addWidget(self.toolChangerTypeCB, 0, 1, 1, 1)
self.tabWidget.addTab(self.tab, "")
self.tab_2 = QtWidgets.QWidget()
self.tab_2.setObjectName("tab_2")
self.gridLayout_59 = QtWidgets.QGridLayout(self.tab_2)
self.gridLayout_59.setContentsMargins(8, 8, 8, 8)
self.gridLayout_59.setSpacing(5)
self.gridLayout_59.setObjectName("gridLayout_59")
self.groupBox_21 = QtWidgets.QGroupBox(self.tab_2)
self.groupBox_21.setObjectName("groupBox_21")
self.gridLayout_58 = QtWidgets.QGridLayout(self.groupBox_21)
self.gridLayout_58.setContentsMargins(8, 15, 8, 8)
self.gridLayout_58.setSpacing(5)
self.gridLayout_58.setObjectName("gridLayout_58")
self.smartSerialInfoLbl = QtWidgets.QLabel(self.groupBox_21)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.smartSerialInfoLbl.sizePolicy().hasHeightForWidth())
self.smartSerialInfoLbl.setSizePolicy(sizePolicy)
self.smartSerialInfoLbl.setFrameShape(QtWidgets.QFrame.Box)
self.smartSerialInfoLbl.setText("")
self.smartSerialInfoLbl.setObjectName("smartSerialInfoLbl")
self.gridLayout_58.addWidget(self.smartSerialInfoLbl, 0, 1, 1, 1)
self.ssCardCB = QtWidgets.QComboBox(self.groupBox_21)
self.ssCardCB.setObjectName("ssCardCB")
self.gridLayout_58.addWidget(self.ssCardCB, 0, 0, 1, 1)
self.buildSserialCB = QtWidgets.QCheckBox(self.groupBox_21)
self.buildSserialCB.setChecked(True)
self.buildSserialCB.setObjectName("buildSserialCB")
self.gridLayout_58.addWidget(self.buildSserialCB, 0, 2, 1, 1)
self.gridLayout_59.addWidget(self.groupBox_21, 0, 0, 1, 1)
self.smartSerialSW = QtWidgets.QStackedWidget(self.tab_2)
self.smartSerialSW.setFrameShape(QtWidgets.QFrame.Box)
self.smartSerialSW.setObjectName("smartSerialSW")
self.noSS = QtWidgets.QWidget()
self.noSS.setObjectName("noSS")
self.label_420 = QtWidgets.QLabel(self.noSS)
self.label_420.setGeometry(QtCore.QRect(10, 10, 241, 20))
self.label_420.setObjectName("label_420")
self.plainTextEdit = QtWidgets.QPlainTextEdit(self.noSS)
self.plainTextEdit.setGeometry(QtCore.QRect(10, 40, 341, 311))
self.plainTextEdit.setObjectName("plainTextEdit")
self.plainTextEdit_2 = QtWidgets.QPlainTextEdit(self.noSS)
self.plainTextEdit_2.setGeometry(QtCore.QRect(360, 40, 581, 311))
self.plainTextEdit_2.setObjectName("plainTextEdit_2")
self.smartSerialSW.addWidget(self.noSS)
self.ss7i64 = QtWidgets.QWidget()
self.ss7i64.setObjectName("ss7i64")
self.gridLayout_69 = QtWidgets.QGridLayout(self.ss7i64)
self.gridLayout_69.setContentsMargins(8, 8, 8, 8)
self.gridLayout_69.setSpacing(5)
self.gridLayout_69.setObjectName("gridLayout_69")
self.groupBox_32 = QtWidgets.QGroupBox(self.ss7i64)
self.groupBox_32.setObjectName("groupBox_32")
self.gridLayout_68 = QtWidgets.QGridLayout(self.groupBox_32)
self.gridLayout_68.setContentsMargins(8, 8, 8, 8)
self.gridLayout_68.setSpacing(5)
self.gridLayout_68.setObjectName("gridLayout_68")
self.groupBox_31 = QtWidgets.QGroupBox(self.groupBox_32)
self.groupBox_31.setObjectName("groupBox_31")
self.gridLayout_73 = QtWidgets.QGridLayout(self.groupBox_31)
self.gridLayout_73.setContentsMargins(8, 8, 8, 8)
self.gridLayout_73.setSpacing(5)
self.gridLayout_73.setObjectName("gridLayout_73")
self.label_528 = QtWidgets.QLabel(self.groupBox_31)
self.label_528.setObjectName("label_528")
self.gridLayout_73.addWidget(self.label_528, 7, 0, 1, 1)
self.label_529 = QtWidgets.QLabel(self.groupBox_31)
self.label_529.setObjectName("label_529")
self.gridLayout_73.addWidget(self.label_529, 8, 0, 1, 1)
self.label_527 = QtWidgets.QLabel(self.groupBox_31)
self.label_527.setObjectName("label_527")
self.gridLayout_73.addWidget(self.label_527, 9, 0, 1, 1)
self.label_532 = QtWidgets.QLabel(self.groupBox_31)
self.label_532.setObjectName("label_532")
self.gridLayout_73.addWidget(self.label_532, 2, 0, 1, 1)
self.label_526 = QtWidgets.QLabel(self.groupBox_31)
self.label_526.setObjectName("label_526")
self.gridLayout_73.addWidget(self.label_526, 1, 0, 1, 1)
self.label_525 = QtWidgets.QLabel(self.groupBox_31)
self.label_525.setObjectName("label_525")
self.gridLayout_73.addWidget(self.label_525, 3, 0, 1, 1)
self.label_522 = QtWidgets.QLabel(self.groupBox_31)
self.label_522.setObjectName("label_522")
self.gridLayout_73.addWidget(self.label_522, 10, 0, 1, 1)
self.label_523 = QtWidgets.QLabel(self.groupBox_31)
self.label_523.setObjectName("label_523")
self.gridLayout_73.addWidget(self.label_523, 11, 0, 1, 1)
self.label_524 = QtWidgets.QLabel(self.groupBox_31)
self.label_524.setObjectName("label_524")
self.gridLayout_73.addWidget(self.label_524, 4, 0, 1, 1)
self.label_530 = QtWidgets.QLabel(self.groupBox_31)
self.label_530.setObjectName("label_530")
self.gridLayout_73.addWidget(self.label_530, 5, 0, 1, 1)
self.label_531 = QtWidgets.QLabel(self.groupBox_31)
self.label_531.setObjectName("label_531")
self.gridLayout_73.addWidget(self.label_531, 6, 0, 1, 1)
self.label_486 = QtWidgets.QLabel(self.groupBox_31)
self.label_486.setObjectName("label_486")
self.gridLayout_73.addWidget(self.label_486, 0, 0, 1, 1)
self.ss7i64out_12 = QtWidgets.QPushButton(self.groupBox_31)
self.ss7i64out_12.setObjectName("ss7i64out_12")
self.gridLayout_73.addWidget(self.ss7i64out_12, 0, 1, 1, 1)
self.ss7i64out_13 = QtWidgets.QPushButton(self.groupBox_31)
self.ss7i64out_13.setObjectName("ss7i64out_13")
self.gridLayout_73.addWidget(self.ss7i64out_13, 1, 1, 1, 1)
self.ss7i64out_14 = QtWidgets.QPushButton(self.groupBox_31)
self.ss7i64out_14.setObjectName("ss7i64out_14")
self.gridLayout_73.addWidget(self.ss7i64out_14, 2, 1, 1, 1)
self.ss7i64out_15 = QtWidgets.QPushButton(self.groupBox_31)
self.ss7i64out_15.setObjectName("ss7i64out_15")
self.gridLayout_73.addWidget(self.ss7i64out_15, 3, 1, 1, 1)
self.ss7i64out_16 = QtWidgets.QPushButton(self.groupBox_31)
self.ss7i64out_16.setObjectName("ss7i64out_16")
self.gridLayout_73.addWidget(self.ss7i64out_16, 4, 1, 1, 1)
self.ss7i64out_17 = QtWidgets.QPushButton(self.groupBox_31)
self.ss7i64out_17.setObjectName("ss7i64out_17")
self.gridLayout_73.addWidget(self.ss7i64out_17, 5, 1, 1, 1)
self.ss7i64out_18 = QtWidgets.QPushButton(self.groupBox_31)
self.ss7i64out_18.setObjectName("ss7i64out_18")
self.gridLayout_73.addWidget(self.ss7i64out_18, 6, 1, 1, 1)
self.ss7i64out_19 = QtWidgets.QPushButton(self.groupBox_31)
self.ss7i64out_19.setObjectName("ss7i64out_19")
self.gridLayout_73.addWidget(self.ss7i64out_19, 7, 1, 1, 1)
self.ss7i64out_20 = QtWidgets.QPushButton(self.groupBox_31)
self.ss7i64out_20.setObjectName("ss7i64out_20")
self.gridLayout_73.addWidget(self.ss7i64out_20, 8, 1, 1, 1)
self.ss7i64out_21 = QtWidgets.QPushButton(self.groupBox_31)
self.ss7i64out_21.setObjectName("ss7i64out_21")
self.gridLayout_73.addWidget(self.ss7i64out_21, 9, 1, 1, 1)
self.ss7i64out_22 = QtWidgets.QPushButton(self.groupBox_31)
self.ss7i64out_22.setObjectName("ss7i64out_22")
self.gridLayout_73.addWidget(self.ss7i64out_22, 10, 1, 1, 1)
self.ss7i64out_23 = QtWidgets.QPushButton(self.groupBox_31)
self.ss7i64out_23.setObjectName("ss7i64out_23")
self.gridLayout_73.addWidget(self.ss7i64out_23, 11, 1, 1, 1)
self.gridLayout_68.addWidget(self.groupBox_31, 0, 3, 1, 1)
self.groupBox_29 = QtWidgets.QGroupBox(self.groupBox_32)
self.groupBox_29.setObjectName("groupBox_29")
self.gridLayout_71 = QtWidgets.QGridLayout(self.groupBox_29)
self.gridLayout_71.setContentsMargins(8, 8, 8, 8)
self.gridLayout_71.setSpacing(5)
self.gridLayout_71.setObjectName("gridLayout_71")
self.label_499 = QtWidgets.QLabel(self.groupBox_29)
self.label_499.setObjectName("label_499")
self.gridLayout_71.addWidget(self.label_499, 2, 0, 1, 1)
self.label_508 = QtWidgets.QLabel(self.groupBox_29)
self.label_508.setObjectName("label_508")
self.gridLayout_71.addWidget(self.label_508, 11, 0, 1, 1)
self.label_506 = QtWidgets.QLabel(self.groupBox_29)
self.label_506.setObjectName("label_506")
self.gridLayout_71.addWidget(self.label_506, 9, 0, 1, 1)
self.label_500 = QtWidgets.QLabel(self.groupBox_29)
self.label_500.setObjectName("label_500")
self.gridLayout_71.addWidget(self.label_500, 3, 0, 1, 1)
self.label_505 = QtWidgets.QLabel(self.groupBox_29)
self.label_505.setObjectName("label_505")
self.gridLayout_71.addWidget(self.label_505, 8, 0, 1, 1)
self.label_507 = QtWidgets.QLabel(self.groupBox_29)
self.label_507.setObjectName("label_507")
self.gridLayout_71.addWidget(self.label_507, 10, 0, 1, 1)
self.label_502 = QtWidgets.QLabel(self.groupBox_29)
self.label_502.setObjectName("label_502")
self.gridLayout_71.addWidget(self.label_502, 5, 0, 1, 1)
self.label_501 = QtWidgets.QLabel(self.groupBox_29)
self.label_501.setObjectName("label_501")
self.gridLayout_71.addWidget(self.label_501, 4, 0, 1, 1)
self.label_504 = QtWidgets.QLabel(self.groupBox_29)
self.label_504.setObjectName("label_504")
self.gridLayout_71.addWidget(self.label_504, 7, 0, 1, 1)
self.label_484 = QtWidgets.QLabel(self.groupBox_29)
self.label_484.setObjectName("label_484")
self.gridLayout_71.addWidget(self.label_484, 0, 0, 1, 1)
self.label_498 = QtWidgets.QLabel(self.groupBox_29)
self.label_498.setObjectName("label_498")
self.gridLayout_71.addWidget(self.label_498, 1, 0, 1, 1)
self.label_503 = QtWidgets.QLabel(self.groupBox_29)
self.label_503.setObjectName("label_503")
self.gridLayout_71.addWidget(self.label_503, 6, 0, 1, 1)
self.ss7i64in_12 = QtWidgets.QPushButton(self.groupBox_29)
self.ss7i64in_12.setObjectName("ss7i64in_12")
self.gridLayout_71.addWidget(self.ss7i64in_12, 0, 1, 1, 1)
self.ss7i64in_13 = QtWidgets.QPushButton(self.groupBox_29)
self.ss7i64in_13.setObjectName("ss7i64in_13")
self.gridLayout_71.addWidget(self.ss7i64in_13, 1, 1, 1, 1)
self.ss7i64in_14 = QtWidgets.QPushButton(self.groupBox_29)
self.ss7i64in_14.setObjectName("ss7i64in_14")
self.gridLayout_71.addWidget(self.ss7i64in_14, 2, 1, 1, 1)
self.ss7i64in_15 = QtWidgets.QPushButton(self.groupBox_29)
self.ss7i64in_15.setObjectName("ss7i64in_15")
self.gridLayout_71.addWidget(self.ss7i64in_15, 3, 1, 1, 1)
self.ss7i64in_16 = QtWidgets.QPushButton(self.groupBox_29)
self.ss7i64in_16.setObjectName("ss7i64in_16")
self.gridLayout_71.addWidget(self.ss7i64in_16, 4, 1, 1, 1)
self.ss7i64in_17 = QtWidgets.QPushButton(self.groupBox_29)
self.ss7i64in_17.setObjectName("ss7i64in_17")
self.gridLayout_71.addWidget(self.ss7i64in_17, 5, 1, 1, 1)
self.ss7i64in_18 = QtWidgets.QPushButton(self.groupBox_29)
self.ss7i64in_18.setObjectName("ss7i64in_18")
self.gridLayout_71.addWidget(self.ss7i64in_18, 6, 1, 1, 1)
self.ss7i64in_19 = QtWidgets.QPushButton(self.groupBox_29)
self.ss7i64in_19.setObjectName("ss7i64in_19")
self.gridLayout_71.addWidget(self.ss7i64in_19, 7, 1, 1, 1)
self.ss7i64in_20 = QtWidgets.QPushButton(self.groupBox_29)
self.ss7i64in_20.setObjectName("ss7i64in_20")
self.gridLayout_71.addWidget(self.ss7i64in_20, 8, 1, 1, 1)
self.ss7i64in_21 = QtWidgets.QPushButton(self.groupBox_29)
self.ss7i64in_21.setObjectName("ss7i64in_21")
self.gridLayout_71.addWidget(self.ss7i64in_21, 9, 1, 1, 1)
self.ss7i64in_22 = QtWidgets.QPushButton(self.groupBox_29)
self.ss7i64in_22.setObjectName("ss7i64in_22")
self.gridLayout_71.addWidget(self.ss7i64in_22, 10, 1, 1, 1)
self.ss7i64in_23 = QtWidgets.QPushButton(self.groupBox_29)
self.ss7i64in_23.setObjectName("ss7i64in_23")
self.gridLayout_71.addWidget(self.ss7i64in_23, 11, 1, 1, 1)
self.gridLayout_68.addWidget(self.groupBox_29, 0, 1, 1, 1)
self.groupBox_28 = QtWidgets.QGroupBox(self.groupBox_32)
self.groupBox_28.setObjectName("groupBox_28")
self.gridLayout_70 = QtWidgets.QGridLayout(self.groupBox_28)
self.gridLayout_70.setContentsMargins(8, 8, 8, 8)
self.gridLayout_70.setSpacing(5)
self.gridLayout_70.setObjectName("gridLayout_70")
self.label_489 = QtWidgets.QLabel(self.groupBox_28)
self.label_489.setObjectName("label_489")
self.gridLayout_70.addWidget(self.label_489, 2, 0, 1, 1)
self.label_488 = QtWidgets.QLabel(self.groupBox_28)
self.label_488.setObjectName("label_488")
self.gridLayout_70.addWidget(self.label_488, 6, 0, 1, 1)
self.label_487 = QtWidgets.QLabel(self.groupBox_28)
self.label_487.setObjectName("label_487")
self.gridLayout_70.addWidget(self.label_487, 1, 0, 1, 1)
self.label_491 = QtWidgets.QLabel(self.groupBox_28)
self.label_491.setObjectName("label_491")
self.gridLayout_70.addWidget(self.label_491, 4, 0, 1, 1)
self.label_497 = QtWidgets.QLabel(self.groupBox_28)
self.label_497.setObjectName("label_497")
self.gridLayout_70.addWidget(self.label_497, 11, 0, 1, 1)
self.label_493 = QtWidgets.QLabel(self.groupBox_28)
self.label_493.setObjectName("label_493")
self.gridLayout_70.addWidget(self.label_493, 7, 0, 1, 1)
self.label_495 = QtWidgets.QLabel(self.groupBox_28)
self.label_495.setObjectName("label_495")
self.gridLayout_70.addWidget(self.label_495, 9, 0, 1, 1)
self.label_496 = QtWidgets.QLabel(self.groupBox_28)
self.label_496.setObjectName("label_496")
self.gridLayout_70.addWidget(self.label_496, 10, 0, 1, 1)
self.label_494 = QtWidgets.QLabel(self.groupBox_28)
self.label_494.setObjectName("label_494")
self.gridLayout_70.addWidget(self.label_494, 8, 0, 1, 1)
self.label_492 = QtWidgets.QLabel(self.groupBox_28)
self.label_492.setObjectName("label_492")
self.gridLayout_70.addWidget(self.label_492, 5, 0, 1, 1)
self.label_412 = QtWidgets.QLabel(self.groupBox_28)
self.label_412.setObjectName("label_412")
self.gridLayout_70.addWidget(self.label_412, 0, 0, 1, 1)
self.label_490 = QtWidgets.QLabel(self.groupBox_28)
self.label_490.setObjectName("label_490")
self.gridLayout_70.addWidget(self.label_490, 3, 0, 1, 1)
self.ss7i64in_0 = QtWidgets.QPushButton(self.groupBox_28)
self.ss7i64in_0.setObjectName("ss7i64in_0")
self.gridLayout_70.addWidget(self.ss7i64in_0, 0, 1, 1, 1)
self.ss7i64in_1 = QtWidgets.QPushButton(self.groupBox_28)
self.ss7i64in_1.setObjectName("ss7i64in_1")
self.gridLayout_70.addWidget(self.ss7i64in_1, 1, 1, 1, 1)
self.ss7i64in_2 = QtWidgets.QPushButton(self.groupBox_28)
self.ss7i64in_2.setObjectName("ss7i64in_2")
self.gridLayout_70.addWidget(self.ss7i64in_2, 2, 1, 1, 1)
self.ss7i64in_3 = QtWidgets.QPushButton(self.groupBox_28)
self.ss7i64in_3.setObjectName("ss7i64in_3")
self.gridLayout_70.addWidget(self.ss7i64in_3, 3, 1, 1, 1)
self.ss7i64in_4 = QtWidgets.QPushButton(self.groupBox_28)
self.ss7i64in_4.setObjectName("ss7i64in_4")
self.gridLayout_70.addWidget(self.ss7i64in_4, 4, 1, 1, 1)
self.ss7i64in_5 = QtWidgets.QPushButton(self.groupBox_28)
self.ss7i64in_5.setObjectName("ss7i64in_5")
self.gridLayout_70.addWidget(self.ss7i64in_5, 5, 1, 1, 1)
self.ss7i64in_6 = QtWidgets.QPushButton(self.groupBox_28)
self.ss7i64in_6.setObjectName("ss7i64in_6")
self.gridLayout_70.addWidget(self.ss7i64in_6, 6, 1, 1, 1)
self.ss7i64in_7 = QtWidgets.QPushButton(self.groupBox_28)
self.ss7i64in_7.setObjectName("ss7i64in_7")
self.gridLayout_70.addWidget(self.ss7i64in_7, 7, 1, 1, 1)
self.ss7i64in_8 = QtWidgets.QPushButton(self.groupBox_28)
self.ss7i64in_8.setObjectName("ss7i64in_8")
self.gridLayout_70.addWidget(self.ss7i64in_8, 8, 1, 1, 1)
self.ss7i64in_9 = QtWidgets.QPushButton(self.groupBox_28)
self.ss7i64in_9.setObjectName("ss7i64in_9")
self.gridLayout_70.addWidget(self.ss7i64in_9, 9, 1, 1, 1)
self.ss7i64in_10 = QtWidgets.QPushButton(self.groupBox_28)
self.ss7i64in_10.setObjectName("ss7i64in_10")
self.gridLayout_70.addWidget(self.ss7i64in_10, 10, 1, 1, 1)
self.ss7i64in_11 = QtWidgets.QPushButton(self.groupBox_28)
self.ss7i64in_11.setObjectName("ss7i64in_11")
self.gridLayout_70.addWidget(self.ss7i64in_11, 11, 1, 1, 1)
self.gridLayout_68.addWidget(self.groupBox_28, 0, 0, 1, 1)
self.groupBox_30 = QtWidgets.QGroupBox(self.groupBox_32)
self.groupBox_30.setObjectName("groupBox_30")
self.gridLayout_72 = QtWidgets.QGridLayout(self.groupBox_30)
self.gridLayout_72.setContentsMargins(8, 8, 8, 8)
self.gridLayout_72.setSpacing(5)
self.gridLayout_72.setObjectName("gridLayout_72")
self.label_485 = QtWidgets.QLabel(self.groupBox_30)
self.label_485.setObjectName("label_485")
self.gridLayout_72.addWidget(self.label_485, 0, 0, 1, 1)
self.label_513 = QtWidgets.QLabel(self.groupBox_30)
self.label_513.setObjectName("label_513")
self.gridLayout_72.addWidget(self.label_513, 1, 0, 1, 1)
self.label_514 = QtWidgets.QLabel(self.groupBox_30)
self.label_514.setObjectName("label_514")
self.gridLayout_72.addWidget(self.label_514, 2, 0, 1, 1)
self.label_519 = QtWidgets.QLabel(self.groupBox_30)
self.label_519.setObjectName("label_519")
self.gridLayout_72.addWidget(self.label_519, 3, 0, 1, 1)
self.label_517 = QtWidgets.QLabel(self.groupBox_30)
self.label_517.setObjectName("label_517")
self.gridLayout_72.addWidget(self.label_517, 4, 0, 1, 1)
self.label_515 = QtWidgets.QLabel(self.groupBox_30)
self.label_515.setObjectName("label_515")
self.gridLayout_72.addWidget(self.label_515, 5, 0, 1, 1)
self.label_516 = QtWidgets.QLabel(self.groupBox_30)
self.label_516.setObjectName("label_516")
self.gridLayout_72.addWidget(self.label_516, 6, 0, 1, 1)
self.label_511 = QtWidgets.QLabel(self.groupBox_30)
self.label_511.setObjectName("label_511")
self.gridLayout_72.addWidget(self.label_511, 7, 0, 1, 1)
self.label_520 = QtWidgets.QLabel(self.groupBox_30)
self.label_520.setObjectName("label_520")
self.gridLayout_72.addWidget(self.label_520, 8, 0, 1, 1)
self.label_512 = QtWidgets.QLabel(self.groupBox_30)
self.label_512.setObjectName("label_512")
self.gridLayout_72.addWidget(self.label_512, 9, 0, 1, 1)
self.label_518 = QtWidgets.QLabel(self.groupBox_30)
self.label_518.setObjectName("label_518")
self.gridLayout_72.addWidget(self.label_518, 10, 0, 1, 1)
self.label_510 = QtWidgets.QLabel(self.groupBox_30)
self.label_510.setObjectName("label_510")
self.gridLayout_72.addWidget(self.label_510, 11, 0, 1, 1)
self.ss7i64out_0 = QtWidgets.QPushButton(self.groupBox_30)
self.ss7i64out_0.setObjectName("ss7i64out_0")
self.gridLayout_72.addWidget(self.ss7i64out_0, 0, 1, 1, 1)
self.ss7i64out_1 = QtWidgets.QPushButton(self.groupBox_30)
self.ss7i64out_1.setObjectName("ss7i64out_1")
self.gridLayout_72.addWidget(self.ss7i64out_1, 1, 1, 1, 1)
self.ss7i64out_2 = QtWidgets.QPushButton(self.groupBox_30)
self.ss7i64out_2.setObjectName("ss7i64out_2")
self.gridLayout_72.addWidget(self.ss7i64out_2, 2, 1, 1, 1)
self.ss7i64out_3 = QtWidgets.QPushButton(self.groupBox_30)
self.ss7i64out_3.setObjectName("ss7i64out_3")
self.gridLayout_72.addWidget(self.ss7i64out_3, 3, 1, 1, 1)
self.ss7i64out_4 = QtWidgets.QPushButton(self.groupBox_30)
self.ss7i64out_4.setObjectName("ss7i64out_4")
self.gridLayout_72.addWidget(self.ss7i64out_4, 4, 1, 1, 1)
self.ss7i64out_5 = QtWidgets.QPushButton(self.groupBox_30)
self.ss7i64out_5.setObjectName("ss7i64out_5")
self.gridLayout_72.addWidget(self.ss7i64out_5, 5, 1, 1, 1)
self.ss7i64out_6 = QtWidgets.QPushButton(self.groupBox_30)
self.ss7i64out_6.setObjectName("ss7i64out_6")
self.gridLayout_72.addWidget(self.ss7i64out_6, 6, 1, 1, 1)
self.ss7i64out_7 = QtWidgets.QPushButton(self.groupBox_30)
self.ss7i64out_7.setObjectName("ss7i64out_7")
self.gridLayout_72.addWidget(self.ss7i64out_7, 7, 1, 1, 1)
self.ss7i64out_8 = QtWidgets.QPushButton(self.groupBox_30)
self.ss7i64out_8.setObjectName("ss7i64out_8")
self.gridLayout_72.addWidget(self.ss7i64out_8, 8, 1, 1, 1)
self.ss7i64out_9 = QtWidgets.QPushButton(self.groupBox_30)
self.ss7i64out_9.setObjectName("ss7i64out_9")
self.gridLayout_72.addWidget(self.ss7i64out_9, 9, 1, 1, 1)
self.ss7i64out_10 = QtWidgets.QPushButton(self.groupBox_30)
self.ss7i64out_10.setObjectName("ss7i64out_10")
self.gridLayout_72.addWidget(self.ss7i64out_10, 10, 1, 1, 1)
self.ss7i64out_11 = QtWidgets.QPushButton(self.groupBox_30)
self.ss7i64out_11.setObjectName("ss7i64out_11")
self.gridLayout_72.addWidget(self.ss7i64out_11, 11, 1, 1, 1)
self.gridLayout_68.addWidget(self.groupBox_30, 0, 2, 1, 1)
spacerItem3 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_68.addItem(spacerItem3, 1, 0, 1, 1)
self.gridLayout_69.addWidget(self.groupBox_32, 0, 0, 1, 1)
self.smartSerialSW.addWidget(self.ss7i64)
self.ss7i69 = QtWidgets.QWidget()
self.ss7i69.setObjectName("ss7i69")
self.gridLayout_74 = QtWidgets.QGridLayout(self.ss7i69)
self.gridLayout_74.setContentsMargins(8, 8, 8, 8)
self.gridLayout_74.setSpacing(5)
self.gridLayout_74.setObjectName("gridLayout_74")
self.groupBox_33 = QtWidgets.QGroupBox(self.ss7i69)
self.groupBox_33.setObjectName("groupBox_33")
self.gridLayout_84 = QtWidgets.QGridLayout(self.groupBox_33)
self.gridLayout_84.setContentsMargins(8, 8, 8, 8)
self.gridLayout_84.setSpacing(5)
self.gridLayout_84.setObjectName("gridLayout_84")
self.groupBox_40 = QtWidgets.QGroupBox(self.groupBox_33)
self.groupBox_40.setObjectName("groupBox_40")
self.gridLayout_81 = QtWidgets.QGridLayout(self.groupBox_40)
self.gridLayout_81.setContentsMargins(8, 8, 8, 8)
self.gridLayout_81.setSpacing(5)
self.gridLayout_81.setObjectName("gridLayout_81")
self.label_546 = QtWidgets.QLabel(self.groupBox_40)
self.label_546.setObjectName("label_546")
self.gridLayout_81.addWidget(self.label_546, 2, 0, 1, 1)
self.label_550 = QtWidgets.QLabel(self.groupBox_40)
self.label_550.setObjectName("label_550")
self.gridLayout_81.addWidget(self.label_550, 12, 0, 1, 1)
self.label_548 = QtWidgets.QLabel(self.groupBox_40)
self.label_548.setObjectName("label_548")
self.gridLayout_81.addWidget(self.label_548, 1, 0, 1, 1)
self.label_547 = QtWidgets.QLabel(self.groupBox_40)
self.label_547.setObjectName("label_547")
self.gridLayout_81.addWidget(self.label_547, 6, 0, 1, 1)
self.label_556 = QtWidgets.QLabel(self.groupBox_40)
self.label_556.setObjectName("label_556")
self.gridLayout_81.addWidget(self.label_556, 3, 0, 1, 1)
self.label_413 = QtWidgets.QLabel(self.groupBox_40)
self.label_413.setObjectName("label_413")
self.gridLayout_81.addWidget(self.label_413, 0, 0, 1, 1)
self.label_551 = QtWidgets.QLabel(self.groupBox_40)
self.label_551.setObjectName("label_551")
self.gridLayout_81.addWidget(self.label_551, 7, 0, 1, 1)
self.label_554 = QtWidgets.QLabel(self.groupBox_40)
self.label_554.setObjectName("label_554")
self.gridLayout_81.addWidget(self.label_554, 9, 0, 1, 1)
self.label_555 = QtWidgets.QLabel(self.groupBox_40)
self.label_555.setObjectName("label_555")
self.gridLayout_81.addWidget(self.label_555, 5, 0, 1, 1)
self.label_549 = QtWidgets.QLabel(self.groupBox_40)
self.label_549.setObjectName("label_549")
self.gridLayout_81.addWidget(self.label_549, 4, 0, 1, 1)
self.label_552 = QtWidgets.QLabel(self.groupBox_40)
self.label_552.setObjectName("label_552")
self.gridLayout_81.addWidget(self.label_552, 10, 0, 1, 1)
self.label_553 = QtWidgets.QLabel(self.groupBox_40)
self.label_553.setObjectName("label_553")
self.gridLayout_81.addWidget(self.label_553, 11, 0, 1, 1)
self.ss7i69in_0 = QtWidgets.QPushButton(self.groupBox_40)
self.ss7i69in_0.setObjectName("ss7i69in_0")
self.gridLayout_81.addWidget(self.ss7i69in_0, 0, 1, 1, 1)
self.ss7i69in_1 = QtWidgets.QPushButton(self.groupBox_40)
self.ss7i69in_1.setObjectName("ss7i69in_1")
self.gridLayout_81.addWidget(self.ss7i69in_1, 1, 1, 1, 1)
self.ss7i69in_2 = QtWidgets.QPushButton(self.groupBox_40)
self.ss7i69in_2.setObjectName("ss7i69in_2")
self.gridLayout_81.addWidget(self.ss7i69in_2, 2, 1, 1, 1)
self.ss7i69in_3 = QtWidgets.QPushButton(self.groupBox_40)
self.ss7i69in_3.setObjectName("ss7i69in_3")
self.gridLayout_81.addWidget(self.ss7i69in_3, 3, 1, 1, 1)
self.ss7i69in_4 = QtWidgets.QPushButton(self.groupBox_40)
self.ss7i69in_4.setObjectName("ss7i69in_4")
self.gridLayout_81.addWidget(self.ss7i69in_4, 4, 1, 1, 1)
self.ss7i69in_5 = QtWidgets.QPushButton(self.groupBox_40)
self.ss7i69in_5.setObjectName("ss7i69in_5")
self.gridLayout_81.addWidget(self.ss7i69in_5, 5, 1, 1, 1)
self.ss7i69in_6 = QtWidgets.QPushButton(self.groupBox_40)
self.ss7i69in_6.setObjectName("ss7i69in_6")
self.gridLayout_81.addWidget(self.ss7i69in_6, 6, 1, 1, 1)
self.ss7i69in_7 = QtWidgets.QPushButton(self.groupBox_40)
self.ss7i69in_7.setObjectName("ss7i69in_7")
self.gridLayout_81.addWidget(self.ss7i69in_7, 7, 1, 1, 1)
self.ss7i69in_8 = QtWidgets.QPushButton(self.groupBox_40)
self.ss7i69in_8.setObjectName("ss7i69in_8")
self.gridLayout_81.addWidget(self.ss7i69in_8, 9, 1, 1, 1)
self.ss7i69in_9 = QtWidgets.QPushButton(self.groupBox_40)
self.ss7i69in_9.setObjectName("ss7i69in_9")
self.gridLayout_81.addWidget(self.ss7i69in_9, 10, 1, 1, 1)
self.ss7i69in_10 = QtWidgets.QPushButton(self.groupBox_40)
self.ss7i69in_10.setObjectName("ss7i69in_10")
self.gridLayout_81.addWidget(self.ss7i69in_10, 11, 1, 1, 1)
self.ss7i69in_11 = QtWidgets.QPushButton(self.groupBox_40)
self.ss7i69in_11.setObjectName("ss7i69in_11")
self.gridLayout_81.addWidget(self.ss7i69in_11, 12, 1, 1, 1)
self.gridLayout_84.addWidget(self.groupBox_40, 0, 0, 1, 1)
self.groupBox_42 = QtWidgets.QGroupBox(self.groupBox_33)
self.groupBox_42.setObjectName("groupBox_42")
self.gridLayout_83 = QtWidgets.QGridLayout(self.groupBox_42)
self.gridLayout_83.setContentsMargins(8, 8, 8, 8)
self.gridLayout_83.setSpacing(5)
self.gridLayout_83.setObjectName("gridLayout_83")
self.label_571 = QtWidgets.QLabel(self.groupBox_42)
self.label_571.setObjectName("label_571")
self.gridLayout_83.addWidget(self.label_571, 9, 0, 1, 1)
self.label_572 = QtWidgets.QLabel(self.groupBox_42)
self.label_572.setObjectName("label_572")
self.gridLayout_83.addWidget(self.label_572, 3, 0, 1, 1)
self.label_570 = QtWidgets.QLabel(self.groupBox_42)
self.label_570.setObjectName("label_570")
self.gridLayout_83.addWidget(self.label_570, 11, 0, 1, 1)
self.label_569 = QtWidgets.QLabel(self.groupBox_42)
self.label_569.setObjectName("label_569")
self.gridLayout_83.addWidget(self.label_569, 2, 0, 1, 1)
self.label_576 = QtWidgets.QLabel(self.groupBox_42)
self.label_576.setObjectName("label_576")
self.gridLayout_83.addWidget(self.label_576, 5, 0, 1, 1)
self.label_575 = QtWidgets.QLabel(self.groupBox_42)
self.label_575.setObjectName("label_575")
self.gridLayout_83.addWidget(self.label_575, 10, 0, 1, 1)
self.label_574 = QtWidgets.QLabel(self.groupBox_42)
self.label_574.setObjectName("label_574")
self.gridLayout_83.addWidget(self.label_574, 8, 0, 1, 1)
self.label_577 = QtWidgets.QLabel(self.groupBox_42)
self.label_577.setObjectName("label_577")
self.gridLayout_83.addWidget(self.label_577, 4, 0, 1, 1)
self.label_578 = QtWidgets.QLabel(self.groupBox_42)
self.label_578.setObjectName("label_578")
self.gridLayout_83.addWidget(self.label_578, 7, 0, 1, 1)
self.label_579 = QtWidgets.QLabel(self.groupBox_42)
self.label_579.setObjectName("label_579")
self.gridLayout_83.addWidget(self.label_579, 0, 0, 1, 1)
self.label_581 = QtWidgets.QLabel(self.groupBox_42)
self.label_581.setObjectName("label_581")
self.gridLayout_83.addWidget(self.label_581, 6, 0, 1, 1)
self.label_580 = QtWidgets.QLabel(self.groupBox_42)
self.label_580.setObjectName("label_580")
self.gridLayout_83.addWidget(self.label_580, 1, 0, 1, 1)
self.ss7i69in_12 = QtWidgets.QPushButton(self.groupBox_42)
self.ss7i69in_12.setObjectName("ss7i69in_12")
self.gridLayout_83.addWidget(self.ss7i69in_12, 0, 1, 1, 1)
self.ss7i69in_13 = QtWidgets.QPushButton(self.groupBox_42)
self.ss7i69in_13.setObjectName("ss7i69in_13")
self.gridLayout_83.addWidget(self.ss7i69in_13, 1, 1, 1, 1)
self.ss7i69in_14 = QtWidgets.QPushButton(self.groupBox_42)
self.ss7i69in_14.setObjectName("ss7i69in_14")
self.gridLayout_83.addWidget(self.ss7i69in_14, 2, 1, 1, 1)
self.ss7i69in_15 = QtWidgets.QPushButton(self.groupBox_42)
self.ss7i69in_15.setObjectName("ss7i69in_15")
self.gridLayout_83.addWidget(self.ss7i69in_15, 3, 1, 1, 1)
self.ss7i69in_16 = QtWidgets.QPushButton(self.groupBox_42)
self.ss7i69in_16.setObjectName("ss7i69in_16")
self.gridLayout_83.addWidget(self.ss7i69in_16, 4, 1, 1, 1)
self.ss7i69in_17 = QtWidgets.QPushButton(self.groupBox_42)
self.ss7i69in_17.setObjectName("ss7i69in_17")
self.gridLayout_83.addWidget(self.ss7i69in_17, 5, 1, 1, 1)
self.ss7i69in_18 = QtWidgets.QPushButton(self.groupBox_42)
self.ss7i69in_18.setObjectName("ss7i69in_18")
self.gridLayout_83.addWidget(self.ss7i69in_18, 6, 1, 1, 1)
self.ss7i69in_19 = QtWidgets.QPushButton(self.groupBox_42)
self.ss7i69in_19.setObjectName("ss7i69in_19")
self.gridLayout_83.addWidget(self.ss7i69in_19, 7, 1, 1, 1)
self.ss7i69in_20 = QtWidgets.QPushButton(self.groupBox_42)
self.ss7i69in_20.setObjectName("ss7i69in_20")
self.gridLayout_83.addWidget(self.ss7i69in_20, 8, 1, 1, 1)
self.ss7i69in_21 = QtWidgets.QPushButton(self.groupBox_42)
self.ss7i69in_21.setObjectName("ss7i69in_21")
self.gridLayout_83.addWidget(self.ss7i69in_21, 9, 1, 1, 1)
self.ss7i69in_22 = QtWidgets.QPushButton(self.groupBox_42)
self.ss7i69in_22.setObjectName("ss7i69in_22")
self.gridLayout_83.addWidget(self.ss7i69in_22, 10, 1, 1, 1)
self.ss7i69in_23 = QtWidgets.QPushButton(self.groupBox_42)
self.ss7i69in_23.setObjectName("ss7i69in_23")
self.gridLayout_83.addWidget(self.ss7i69in_23, 11, 1, 1, 1)
self.gridLayout_84.addWidget(self.groupBox_42, 0, 1, 1, 1)
self.groupBox_39 = QtWidgets.QGroupBox(self.groupBox_33)
self.groupBox_39.setObjectName("groupBox_39")
self.gridLayout_80 = QtWidgets.QGridLayout(self.groupBox_39)
self.gridLayout_80.setContentsMargins(8, 8, 8, 8)
self.gridLayout_80.setSpacing(5)
self.gridLayout_80.setObjectName("gridLayout_80")
self.label_535 = QtWidgets.QLabel(self.groupBox_39)
self.label_535.setObjectName("label_535")
self.gridLayout_80.addWidget(self.label_535, 9, 0, 1, 1)
self.label_540 = QtWidgets.QLabel(self.groupBox_39)
self.label_540.setObjectName("label_540")
self.gridLayout_80.addWidget(self.label_540, 11, 0, 1, 1)
self.label_534 = QtWidgets.QLabel(self.groupBox_39)
self.label_534.setObjectName("label_534")
self.gridLayout_80.addWidget(self.label_534, 8, 0, 1, 1)
self.label_533 = QtWidgets.QLabel(self.groupBox_39)
self.label_533.setObjectName("label_533")
self.gridLayout_80.addWidget(self.label_533, 7, 0, 1, 1)
self.label_545 = QtWidgets.QLabel(self.groupBox_39)
self.label_545.setObjectName("label_545")
self.gridLayout_80.addWidget(self.label_545, 0, 0, 1, 1)
self.label_537 = QtWidgets.QLabel(self.groupBox_39)
self.label_537.setObjectName("label_537")
self.gridLayout_80.addWidget(self.label_537, 1, 0, 1, 1)
self.label_544 = QtWidgets.QLabel(self.groupBox_39)
self.label_544.setObjectName("label_544")
self.gridLayout_80.addWidget(self.label_544, 6, 0, 1, 1)
self.label_543 = QtWidgets.QLabel(self.groupBox_39)
self.label_543.setObjectName("label_543")
self.gridLayout_80.addWidget(self.label_543, 5, 0, 1, 1)
self.label_542 = QtWidgets.QLabel(self.groupBox_39)
self.label_542.setObjectName("label_542")
self.gridLayout_80.addWidget(self.label_542, 4, 0, 1, 1)
self.label_536 = QtWidgets.QLabel(self.groupBox_39)
self.label_536.setObjectName("label_536")
self.gridLayout_80.addWidget(self.label_536, 2, 0, 1, 1)
self.label_539 = QtWidgets.QLabel(self.groupBox_39)
self.label_539.setObjectName("label_539")
self.gridLayout_80.addWidget(self.label_539, 10, 0, 1, 1)
self.label_538 = QtWidgets.QLabel(self.groupBox_39)
self.label_538.setObjectName("label_538")
self.gridLayout_80.addWidget(self.label_538, 3, 0, 1, 1)
self.ss7i69out_12 = QtWidgets.QPushButton(self.groupBox_39)
self.ss7i69out_12.setObjectName("ss7i69out_12")
self.gridLayout_80.addWidget(self.ss7i69out_12, 0, 1, 1, 1)
self.ss7i69out_13 = QtWidgets.QPushButton(self.groupBox_39)
self.ss7i69out_13.setObjectName("ss7i69out_13")
self.gridLayout_80.addWidget(self.ss7i69out_13, 1, 1, 1, 1)
self.ss7i69out_14 = QtWidgets.QPushButton(self.groupBox_39)
self.ss7i69out_14.setObjectName("ss7i69out_14")
self.gridLayout_80.addWidget(self.ss7i69out_14, 2, 1, 1, 1)
self.ss7i69out_15 = QtWidgets.QPushButton(self.groupBox_39)
self.ss7i69out_15.setObjectName("ss7i69out_15")
self.gridLayout_80.addWidget(self.ss7i69out_15, 3, 1, 1, 1)
self.ss7i69out_16 = QtWidgets.QPushButton(self.groupBox_39)
self.ss7i69out_16.setObjectName("ss7i69out_16")
self.gridLayout_80.addWidget(self.ss7i69out_16, 4, 1, 1, 1)
self.ss7i69out_17 = QtWidgets.QPushButton(self.groupBox_39)
self.ss7i69out_17.setObjectName("ss7i69out_17")
self.gridLayout_80.addWidget(self.ss7i69out_17, 5, 1, 1, 1)
self.ss7i69out_18 = QtWidgets.QPushButton(self.groupBox_39)
self.ss7i69out_18.setObjectName("ss7i69out_18")
self.gridLayout_80.addWidget(self.ss7i69out_18, 6, 1, 1, 1)
self.ss7i69out_19 = QtWidgets.QPushButton(self.groupBox_39)
self.ss7i69out_19.setObjectName("ss7i69out_19")
self.gridLayout_80.addWidget(self.ss7i69out_19, 7, 1, 1, 1)
self.ss7i69out_20 = QtWidgets.QPushButton(self.groupBox_39)
self.ss7i69out_20.setObjectName("ss7i69out_20")
self.gridLayout_80.addWidget(self.ss7i69out_20, 8, 1, 1, 1)
self.ss7i69out_21 = QtWidgets.QPushButton(self.groupBox_39)
self.ss7i69out_21.setObjectName("ss7i69out_21")
self.gridLayout_80.addWidget(self.ss7i69out_21, 9, 1, 1, 1)
self.ss7i69out_22 = QtWidgets.QPushButton(self.groupBox_39)
self.ss7i69out_22.setObjectName("ss7i69out_22")
self.gridLayout_80.addWidget(self.ss7i69out_22, 10, 1, 1, 1)
self.ss7i69out_23 = QtWidgets.QPushButton(self.groupBox_39)
self.ss7i69out_23.setObjectName("ss7i69out_23")
self.gridLayout_80.addWidget(self.ss7i69out_23, 11, 1, 1, 1)
self.gridLayout_84.addWidget(self.groupBox_39, 0, 3, 1, 1)
self.groupBox_41 = QtWidgets.QGroupBox(self.groupBox_33)
self.groupBox_41.setObjectName("groupBox_41")
self.gridLayout_82 = QtWidgets.QGridLayout(self.groupBox_41)
self.gridLayout_82.setContentsMargins(8, 8, 8, 8)
self.gridLayout_82.setSpacing(5)
self.gridLayout_82.setObjectName("gridLayout_82")
self.label_557 = QtWidgets.QLabel(self.groupBox_41)
self.label_557.setObjectName("label_557")
self.gridLayout_82.addWidget(self.label_557, 0, 0, 1, 1)
self.label_558 = QtWidgets.QLabel(self.groupBox_41)
self.label_558.setObjectName("label_558")
self.gridLayout_82.addWidget(self.label_558, 1, 0, 1, 1)
self.label_559 = QtWidgets.QLabel(self.groupBox_41)
self.label_559.setObjectName("label_559")
self.gridLayout_82.addWidget(self.label_559, 2, 0, 1, 1)
self.label_560 = QtWidgets.QLabel(self.groupBox_41)
self.label_560.setObjectName("label_560")
self.gridLayout_82.addWidget(self.label_560, 3, 0, 1, 1)
self.label_561 = QtWidgets.QLabel(self.groupBox_41)
self.label_561.setObjectName("label_561")
self.gridLayout_82.addWidget(self.label_561, 4, 0, 1, 1)
self.label_562 = QtWidgets.QLabel(self.groupBox_41)
self.label_562.setObjectName("label_562")
self.gridLayout_82.addWidget(self.label_562, 5, 0, 1, 1)
self.label_563 = QtWidgets.QLabel(self.groupBox_41)
self.label_563.setObjectName("label_563")
self.gridLayout_82.addWidget(self.label_563, 6, 0, 1, 1)
self.label_564 = QtWidgets.QLabel(self.groupBox_41)
self.label_564.setObjectName("label_564")
self.gridLayout_82.addWidget(self.label_564, 7, 0, 1, 1)
self.label_565 = QtWidgets.QLabel(self.groupBox_41)
self.label_565.setObjectName("label_565")
self.gridLayout_82.addWidget(self.label_565, 8, 0, 1, 1)
self.label_566 = QtWidgets.QLabel(self.groupBox_41)
self.label_566.setObjectName("label_566")
self.gridLayout_82.addWidget(self.label_566, 9, 0, 1, 1)
self.label_567 = QtWidgets.QLabel(self.groupBox_41)
self.label_567.setObjectName("label_567")
self.gridLayout_82.addWidget(self.label_567, 10, 0, 1, 1)
self.label_568 = QtWidgets.QLabel(self.groupBox_41)
self.label_568.setObjectName("label_568")
self.gridLayout_82.addWidget(self.label_568, 11, 0, 1, 1)
self.ss7i69out_0 = QtWidgets.QPushButton(self.groupBox_41)
self.ss7i69out_0.setObjectName("ss7i69out_0")
self.gridLayout_82.addWidget(self.ss7i69out_0, 0, 1, 1, 1)
self.ss7i69out_1 = QtWidgets.QPushButton(self.groupBox_41)
self.ss7i69out_1.setObjectName("ss7i69out_1")
self.gridLayout_82.addWidget(self.ss7i69out_1, 1, 1, 1, 1)
self.ss7i69out_2 = QtWidgets.QPushButton(self.groupBox_41)
self.ss7i69out_2.setObjectName("ss7i69out_2")
self.gridLayout_82.addWidget(self.ss7i69out_2, 2, 1, 1, 1)
self.ss7i69out_3 = QtWidgets.QPushButton(self.groupBox_41)
self.ss7i69out_3.setObjectName("ss7i69out_3")
self.gridLayout_82.addWidget(self.ss7i69out_3, 3, 1, 1, 1)
self.ss7i69out_4 = QtWidgets.QPushButton(self.groupBox_41)
self.ss7i69out_4.setObjectName("ss7i69out_4")
self.gridLayout_82.addWidget(self.ss7i69out_4, 4, 1, 1, 1)
self.ss7i69out_5 = QtWidgets.QPushButton(self.groupBox_41)
self.ss7i69out_5.setObjectName("ss7i69out_5")
self.gridLayout_82.addWidget(self.ss7i69out_5, 5, 1, 1, 1)
self.ss7i69out_6 = QtWidgets.QPushButton(self.groupBox_41)
self.ss7i69out_6.setObjectName("ss7i69out_6")
self.gridLayout_82.addWidget(self.ss7i69out_6, 6, 1, 1, 1)
self.ss7i69out_7 = QtWidgets.QPushButton(self.groupBox_41)
self.ss7i69out_7.setObjectName("ss7i69out_7")
self.gridLayout_82.addWidget(self.ss7i69out_7, 7, 1, 1, 1)
self.ss7i69out_8 = QtWidgets.QPushButton(self.groupBox_41)
self.ss7i69out_8.setObjectName("ss7i69out_8")
self.gridLayout_82.addWidget(self.ss7i69out_8, 8, 1, 1, 1)
self.ss7i69out_9 = QtWidgets.QPushButton(self.groupBox_41)
self.ss7i69out_9.setObjectName("ss7i69out_9")
self.gridLayout_82.addWidget(self.ss7i69out_9, 9, 1, 1, 1)
self.ss7i69out_10 = QtWidgets.QPushButton(self.groupBox_41)
self.ss7i69out_10.setObjectName("ss7i69out_10")
self.gridLayout_82.addWidget(self.ss7i69out_10, 10, 1, 1, 1)
self.ss7i69out_11 = QtWidgets.QPushButton(self.groupBox_41)
self.ss7i69out_11.setObjectName("ss7i69out_11")
self.gridLayout_82.addWidget(self.ss7i69out_11, 11, 1, 1, 1)
self.gridLayout_84.addWidget(self.groupBox_41, 0, 2, 1, 1)
spacerItem4 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_84.addItem(spacerItem4, 1, 0, 1, 1)
self.gridLayout_74.addWidget(self.groupBox_33, 0, 0, 1, 1)
self.smartSerialSW.addWidget(self.ss7i69)
self.ss7i70 = QtWidgets.QWidget()
self.ss7i70.setObjectName("ss7i70")
self.gridLayout_75 = QtWidgets.QGridLayout(self.ss7i70)
self.gridLayout_75.setContentsMargins(8, 8, 8, 8)
self.gridLayout_75.setSpacing(5)
self.gridLayout_75.setObjectName("gridLayout_75")
self.groupBox_34 = QtWidgets.QGroupBox(self.ss7i70)
self.groupBox_34.setObjectName("groupBox_34")
self.gridLayout_89 = QtWidgets.QGridLayout(self.groupBox_34)
self.gridLayout_89.setContentsMargins(8, 8, 8, 8)
self.gridLayout_89.setSpacing(5)
self.gridLayout_89.setObjectName("gridLayout_89")
self.groupBox_44 = QtWidgets.QGroupBox(self.groupBox_34)
self.groupBox_44.setObjectName("groupBox_44")
self.gridLayout_86 = QtWidgets.QGridLayout(self.groupBox_44)
self.gridLayout_86.setContentsMargins(8, 8, 8, 8)
self.gridLayout_86.setSpacing(5)
self.gridLayout_86.setObjectName("gridLayout_86")
self.label_595 = QtWidgets.QLabel(self.groupBox_44)
self.label_595.setObjectName("label_595")
self.gridLayout_86.addWidget(self.label_595, 2, 0, 1, 1)
self.label_596 = QtWidgets.QLabel(self.groupBox_44)
self.label_596.setObjectName("label_596")
self.gridLayout_86.addWidget(self.label_596, 6, 0, 1, 1)
self.label_597 = QtWidgets.QLabel(self.groupBox_44)
self.label_597.setObjectName("label_597")
self.gridLayout_86.addWidget(self.label_597, 1, 0, 1, 1)
self.label_598 = QtWidgets.QLabel(self.groupBox_44)
self.label_598.setObjectName("label_598")
self.gridLayout_86.addWidget(self.label_598, 4, 0, 1, 1)
self.label_599 = QtWidgets.QLabel(self.groupBox_44)
self.label_599.setObjectName("label_599")
self.gridLayout_86.addWidget(self.label_599, 11, 0, 1, 1)
self.label_600 = QtWidgets.QLabel(self.groupBox_44)
self.label_600.setObjectName("label_600")
self.gridLayout_86.addWidget(self.label_600, 7, 0, 1, 1)
self.label_601 = QtWidgets.QLabel(self.groupBox_44)
self.label_601.setObjectName("label_601")
self.gridLayout_86.addWidget(self.label_601, 9, 0, 1, 1)
self.label_602 = QtWidgets.QLabel(self.groupBox_44)
self.label_602.setObjectName("label_602")
self.gridLayout_86.addWidget(self.label_602, 10, 0, 1, 1)
self.label_603 = QtWidgets.QLabel(self.groupBox_44)
self.label_603.setObjectName("label_603")
self.gridLayout_86.addWidget(self.label_603, 8, 0, 1, 1)
self.label_604 = QtWidgets.QLabel(self.groupBox_44)
self.label_604.setObjectName("label_604")
self.gridLayout_86.addWidget(self.label_604, 5, 0, 1, 1)
self.label_414 = QtWidgets.QLabel(self.groupBox_44)
self.label_414.setObjectName("label_414")
self.gridLayout_86.addWidget(self.label_414, 0, 0, 1, 1)
self.label_605 = QtWidgets.QLabel(self.groupBox_44)
self.label_605.setObjectName("label_605")
self.gridLayout_86.addWidget(self.label_605, 3, 0, 1, 1)
self.ss7i70in_0 = QtWidgets.QPushButton(self.groupBox_44)
self.ss7i70in_0.setObjectName("ss7i70in_0")
self.gridLayout_86.addWidget(self.ss7i70in_0, 0, 1, 1, 1)
self.ss7i70in_1 = QtWidgets.QPushButton(self.groupBox_44)
self.ss7i70in_1.setObjectName("ss7i70in_1")
self.gridLayout_86.addWidget(self.ss7i70in_1, 1, 1, 1, 1)
self.ss7i70in_2 = QtWidgets.QPushButton(self.groupBox_44)
self.ss7i70in_2.setObjectName("ss7i70in_2")
self.gridLayout_86.addWidget(self.ss7i70in_2, 2, 1, 1, 1)
self.ss7i70in_3 = QtWidgets.QPushButton(self.groupBox_44)
self.ss7i70in_3.setObjectName("ss7i70in_3")
self.gridLayout_86.addWidget(self.ss7i70in_3, 3, 1, 1, 1)
self.ss7i70in_4 = QtWidgets.QPushButton(self.groupBox_44)
self.ss7i70in_4.setObjectName("ss7i70in_4")
self.gridLayout_86.addWidget(self.ss7i70in_4, 4, 1, 1, 1)
self.ss7i70in_5 = QtWidgets.QPushButton(self.groupBox_44)
self.ss7i70in_5.setObjectName("ss7i70in_5")
self.gridLayout_86.addWidget(self.ss7i70in_5, 5, 1, 1, 1)
self.ss7i70in_6 = QtWidgets.QPushButton(self.groupBox_44)
self.ss7i70in_6.setObjectName("ss7i70in_6")
self.gridLayout_86.addWidget(self.ss7i70in_6, 6, 1, 1, 1)
self.ss7i70in_7 = QtWidgets.QPushButton(self.groupBox_44)
self.ss7i70in_7.setObjectName("ss7i70in_7")
self.gridLayout_86.addWidget(self.ss7i70in_7, 7, 1, 1, 1)
self.ss7i70in_8 = QtWidgets.QPushButton(self.groupBox_44)
self.ss7i70in_8.setObjectName("ss7i70in_8")
self.gridLayout_86.addWidget(self.ss7i70in_8, 8, 1, 1, 1)
self.ss7i70in_9 = QtWidgets.QPushButton(self.groupBox_44)
self.ss7i70in_9.setObjectName("ss7i70in_9")
self.gridLayout_86.addWidget(self.ss7i70in_9, 9, 1, 1, 1)
self.ss7i70in_10 = QtWidgets.QPushButton(self.groupBox_44)
self.ss7i70in_10.setObjectName("ss7i70in_10")
self.gridLayout_86.addWidget(self.ss7i70in_10, 10, 1, 1, 1)
self.ss7i70in_11 = QtWidgets.QPushButton(self.groupBox_44)
self.ss7i70in_11.setObjectName("ss7i70in_11")
self.gridLayout_86.addWidget(self.ss7i70in_11, 11, 1, 1, 1)
self.gridLayout_89.addWidget(self.groupBox_44, 0, 0, 1, 1)
self.groupBox_43 = QtWidgets.QGroupBox(self.groupBox_34)
self.groupBox_43.setObjectName("groupBox_43")
self.gridLayout_85 = QtWidgets.QGridLayout(self.groupBox_43)
self.gridLayout_85.setContentsMargins(8, 8, 8, 8)
self.gridLayout_85.setSpacing(5)
self.gridLayout_85.setObjectName("gridLayout_85")
self.label_585 = QtWidgets.QLabel(self.groupBox_43)
self.label_585.setObjectName("label_585")
self.gridLayout_85.addWidget(self.label_585, 2, 0, 1, 1)
self.label_584 = QtWidgets.QLabel(self.groupBox_43)
self.label_584.setObjectName("label_584")
self.gridLayout_85.addWidget(self.label_584, 11, 0, 1, 1)
self.label_582 = QtWidgets.QLabel(self.groupBox_43)
self.label_582.setObjectName("label_582")
self.gridLayout_85.addWidget(self.label_582, 9, 0, 1, 1)
self.label_583 = QtWidgets.QLabel(self.groupBox_43)
self.label_583.setObjectName("label_583")
self.gridLayout_85.addWidget(self.label_583, 3, 0, 1, 1)
self.label_589 = QtWidgets.QLabel(self.groupBox_43)
self.label_589.setObjectName("label_589")
self.gridLayout_85.addWidget(self.label_589, 8, 0, 1, 1)
self.label_592 = QtWidgets.QLabel(self.groupBox_43)
self.label_592.setObjectName("label_592")
self.gridLayout_85.addWidget(self.label_592, 0, 0, 1, 1)
self.label_590 = QtWidgets.QLabel(self.groupBox_43)
self.label_590.setObjectName("label_590")
self.gridLayout_85.addWidget(self.label_590, 4, 0, 1, 1)
self.label_588 = QtWidgets.QLabel(self.groupBox_43)
self.label_588.setObjectName("label_588")
self.gridLayout_85.addWidget(self.label_588, 10, 0, 1, 1)
self.label_587 = QtWidgets.QLabel(self.groupBox_43)
self.label_587.setObjectName("label_587")
self.gridLayout_85.addWidget(self.label_587, 5, 0, 1, 1)
self.label_591 = QtWidgets.QLabel(self.groupBox_43)
self.label_591.setObjectName("label_591")
self.gridLayout_85.addWidget(self.label_591, 7, 0, 1, 1)
self.label_593 = QtWidgets.QLabel(self.groupBox_43)
self.label_593.setObjectName("label_593")
self.gridLayout_85.addWidget(self.label_593, 6, 0, 1, 1)
self.label_594 = QtWidgets.QLabel(self.groupBox_43)
self.label_594.setObjectName("label_594")
self.gridLayout_85.addWidget(self.label_594, 1, 0, 1, 1)
self.ss7i70in_12 = QtWidgets.QPushButton(self.groupBox_43)
self.ss7i70in_12.setObjectName("ss7i70in_12")
self.gridLayout_85.addWidget(self.ss7i70in_12, 0, 1, 1, 1)
self.ss7i70in_13 = QtWidgets.QPushButton(self.groupBox_43)
self.ss7i70in_13.setObjectName("ss7i70in_13")
self.gridLayout_85.addWidget(self.ss7i70in_13, 1, 1, 1, 1)
self.ss7i70in_14 = QtWidgets.QPushButton(self.groupBox_43)
self.ss7i70in_14.setObjectName("ss7i70in_14")
self.gridLayout_85.addWidget(self.ss7i70in_14, 2, 1, 1, 1)
self.ss7i70in_15 = QtWidgets.QPushButton(self.groupBox_43)
self.ss7i70in_15.setObjectName("ss7i70in_15")
self.gridLayout_85.addWidget(self.ss7i70in_15, 3, 1, 1, 1)
self.ss7i70in_16 = QtWidgets.QPushButton(self.groupBox_43)
self.ss7i70in_16.setObjectName("ss7i70in_16")
self.gridLayout_85.addWidget(self.ss7i70in_16, 4, 1, 1, 1)
self.ss7i70in_17 = QtWidgets.QPushButton(self.groupBox_43)
self.ss7i70in_17.setObjectName("ss7i70in_17")
self.gridLayout_85.addWidget(self.ss7i70in_17, 5, 1, 1, 1)
self.ss7i70in_18 = QtWidgets.QPushButton(self.groupBox_43)
self.ss7i70in_18.setObjectName("ss7i70in_18")
self.gridLayout_85.addWidget(self.ss7i70in_18, 6, 1, 1, 1)
self.ss7i70in_19 = QtWidgets.QPushButton(self.groupBox_43)
self.ss7i70in_19.setObjectName("ss7i70in_19")
self.gridLayout_85.addWidget(self.ss7i70in_19, 7, 1, 1, 1)
self.ss7i70in_20 = QtWidgets.QPushButton(self.groupBox_43)
self.ss7i70in_20.setObjectName("ss7i70in_20")
self.gridLayout_85.addWidget(self.ss7i70in_20, 8, 1, 1, 1)
self.ss7i70in_21 = QtWidgets.QPushButton(self.groupBox_43)
self.ss7i70in_21.setObjectName("ss7i70in_21")
self.gridLayout_85.addWidget(self.ss7i70in_21, 9, 1, 1, 1)
self.ss7i70in_22 = QtWidgets.QPushButton(self.groupBox_43)
self.ss7i70in_22.setObjectName("ss7i70in_22")
self.gridLayout_85.addWidget(self.ss7i70in_22, 10, 1, 1, 1)
self.ss7i70in_23 = QtWidgets.QPushButton(self.groupBox_43)
self.ss7i70in_23.setObjectName("ss7i70in_23")
self.gridLayout_85.addWidget(self.ss7i70in_23, 11, 1, 1, 1)
self.gridLayout_89.addWidget(self.groupBox_43, 0, 1, 1, 1)
self.groupBox_45 = QtWidgets.QGroupBox(self.groupBox_34)
self.groupBox_45.setObjectName("groupBox_45")
self.gridLayout_87 = QtWidgets.QGridLayout(self.groupBox_45)
self.gridLayout_87.setContentsMargins(8, 8, 8, 8)
self.gridLayout_87.setSpacing(5)
self.gridLayout_87.setObjectName("gridLayout_87")
self.label_606 = QtWidgets.QLabel(self.groupBox_45)
self.label_606.setObjectName("label_606")
self.gridLayout_87.addWidget(self.label_606, 10, 0, 1, 1)
self.label_614 = QtWidgets.QLabel(self.groupBox_45)
self.label_614.setObjectName("label_614")
self.gridLayout_87.addWidget(self.label_614, 5, 0, 1, 1)
self.label_611 = QtWidgets.QLabel(self.groupBox_45)
self.label_611.setObjectName("label_611")
self.gridLayout_87.addWidget(self.label_611, 2, 0, 1, 1)
self.label_613 = QtWidgets.QLabel(self.groupBox_45)
self.label_613.setObjectName("label_613")
self.gridLayout_87.addWidget(self.label_613, 6, 0, 1, 1)
self.label_612 = QtWidgets.QLabel(self.groupBox_45)
self.label_612.setObjectName("label_612")
self.gridLayout_87.addWidget(self.label_612, 7, 0, 1, 1)
self.label_608 = QtWidgets.QLabel(self.groupBox_45)
self.label_608.setObjectName("label_608")
self.gridLayout_87.addWidget(self.label_608, 9, 0, 1, 1)
self.label_609 = QtWidgets.QLabel(self.groupBox_45)
self.label_609.setObjectName("label_609")
self.gridLayout_87.addWidget(self.label_609, 8, 0, 1, 1)
self.label_610 = QtWidgets.QLabel(self.groupBox_45)
self.label_610.setObjectName("label_610")
self.gridLayout_87.addWidget(self.label_610, 1, 0, 1, 1)
self.label_617 = QtWidgets.QLabel(self.groupBox_45)
self.label_617.setObjectName("label_617")
self.gridLayout_87.addWidget(self.label_617, 11, 0, 1, 1)
self.label_632 = QtWidgets.QLabel(self.groupBox_45)
self.label_632.setObjectName("label_632")
self.gridLayout_87.addWidget(self.label_632, 0, 0, 1, 1)
self.label_618 = QtWidgets.QLabel(self.groupBox_45)
self.label_618.setObjectName("label_618")
self.gridLayout_87.addWidget(self.label_618, 4, 0, 1, 1)
self.label_616 = QtWidgets.QLabel(self.groupBox_45)
self.label_616.setObjectName("label_616")
self.gridLayout_87.addWidget(self.label_616, 3, 0, 1, 1)
self.ss7i70in_36 = QtWidgets.QPushButton(self.groupBox_45)
self.ss7i70in_36.setObjectName("ss7i70in_36")
self.gridLayout_87.addWidget(self.ss7i70in_36, 0, 1, 1, 1)
self.ss7i70in_37 = QtWidgets.QPushButton(self.groupBox_45)
self.ss7i70in_37.setObjectName("ss7i70in_37")
self.gridLayout_87.addWidget(self.ss7i70in_37, 1, 1, 1, 1)
self.ss7i70in_38 = QtWidgets.QPushButton(self.groupBox_45)
self.ss7i70in_38.setObjectName("ss7i70in_38")
self.gridLayout_87.addWidget(self.ss7i70in_38, 2, 1, 1, 1)
self.ss7i70in_39 = QtWidgets.QPushButton(self.groupBox_45)
self.ss7i70in_39.setObjectName("ss7i70in_39")
self.gridLayout_87.addWidget(self.ss7i70in_39, 3, 1, 1, 1)
self.ss7i70in_40 = QtWidgets.QPushButton(self.groupBox_45)
self.ss7i70in_40.setObjectName("ss7i70in_40")
self.gridLayout_87.addWidget(self.ss7i70in_40, 4, 1, 1, 1)
self.ss7i70in_41 = QtWidgets.QPushButton(self.groupBox_45)
self.ss7i70in_41.setObjectName("ss7i70in_41")
self.gridLayout_87.addWidget(self.ss7i70in_41, 5, 1, 1, 1)
self.ss7i70in_42 = QtWidgets.QPushButton(self.groupBox_45)
self.ss7i70in_42.setObjectName("ss7i70in_42")
self.gridLayout_87.addWidget(self.ss7i70in_42, 6, 1, 1, 1)
self.ss7i70in_43 = QtWidgets.QPushButton(self.groupBox_45)
self.ss7i70in_43.setObjectName("ss7i70in_43")
self.gridLayout_87.addWidget(self.ss7i70in_43, 7, 1, 1, 1)
self.ss7i70in_44 = QtWidgets.QPushButton(self.groupBox_45)
self.ss7i70in_44.setObjectName("ss7i70in_44")
self.gridLayout_87.addWidget(self.ss7i70in_44, 8, 1, 1, 1)
self.ss7i70in_45 = QtWidgets.QPushButton(self.groupBox_45)
self.ss7i70in_45.setObjectName("ss7i70in_45")
self.gridLayout_87.addWidget(self.ss7i70in_45, 9, 1, 1, 1)
self.ss7i70in_46 = QtWidgets.QPushButton(self.groupBox_45)
self.ss7i70in_46.setObjectName("ss7i70in_46")
self.gridLayout_87.addWidget(self.ss7i70in_46, 10, 1, 1, 1)
self.ss7i70in_47 = QtWidgets.QPushButton(self.groupBox_45)
self.ss7i70in_47.setObjectName("ss7i70in_47")
self.gridLayout_87.addWidget(self.ss7i70in_47, 11, 1, 1, 1)
self.gridLayout_89.addWidget(self.groupBox_45, 0, 3, 1, 1)
self.groupBox_46 = QtWidgets.QGroupBox(self.groupBox_34)
self.groupBox_46.setObjectName("groupBox_46")
self.gridLayout_88 = QtWidgets.QGridLayout(self.groupBox_46)
self.gridLayout_88.setContentsMargins(8, 8, 8, 8)
self.gridLayout_88.setSpacing(5)
self.gridLayout_88.setObjectName("gridLayout_88")
self.label_619 = QtWidgets.QLabel(self.groupBox_46)
self.label_619.setObjectName("label_619")
self.gridLayout_88.addWidget(self.label_619, 0, 0, 1, 1)
self.label_627 = QtWidgets.QLabel(self.groupBox_46)
self.label_627.setObjectName("label_627")
self.gridLayout_88.addWidget(self.label_627, 9, 0, 1, 1)
self.label_626 = QtWidgets.QLabel(self.groupBox_46)
self.label_626.setObjectName("label_626")
self.gridLayout_88.addWidget(self.label_626, 8, 0, 1, 1)
self.label_629 = QtWidgets.QLabel(self.groupBox_46)
self.label_629.setObjectName("label_629")
self.gridLayout_88.addWidget(self.label_629, 11, 0, 1, 1)
self.label_628 = QtWidgets.QLabel(self.groupBox_46)
self.label_628.setObjectName("label_628")
self.gridLayout_88.addWidget(self.label_628, 10, 0, 1, 1)
self.label_631 = QtWidgets.QLabel(self.groupBox_46)
self.label_631.setObjectName("label_631")
self.gridLayout_88.addWidget(self.label_631, 1, 0, 1, 1)
self.label_621 = QtWidgets.QLabel(self.groupBox_46)
self.label_621.setObjectName("label_621")
self.gridLayout_88.addWidget(self.label_621, 3, 0, 1, 1)
self.label_620 = QtWidgets.QLabel(self.groupBox_46)
self.label_620.setObjectName("label_620")
self.gridLayout_88.addWidget(self.label_620, 2, 0, 1, 1)
self.label_624 = QtWidgets.QLabel(self.groupBox_46)
self.label_624.setObjectName("label_624")
self.gridLayout_88.addWidget(self.label_624, 6, 0, 1, 1)
self.label_625 = QtWidgets.QLabel(self.groupBox_46)
self.label_625.setObjectName("label_625")
self.gridLayout_88.addWidget(self.label_625, 7, 0, 1, 1)
self.label_623 = QtWidgets.QLabel(self.groupBox_46)
self.label_623.setObjectName("label_623")
self.gridLayout_88.addWidget(self.label_623, 5, 0, 1, 1)
self.label_622 = QtWidgets.QLabel(self.groupBox_46)
self.label_622.setObjectName("label_622")
self.gridLayout_88.addWidget(self.label_622, 4, 0, 1, 1)
self.ss7i70in_24 = QtWidgets.QPushButton(self.groupBox_46)
self.ss7i70in_24.setObjectName("ss7i70in_24")
self.gridLayout_88.addWidget(self.ss7i70in_24, 0, 1, 1, 1)
self.ss7i70in_25 = QtWidgets.QPushButton(self.groupBox_46)
self.ss7i70in_25.setObjectName("ss7i70in_25")
self.gridLayout_88.addWidget(self.ss7i70in_25, 1, 1, 1, 1)
self.ss7i70in_26 = QtWidgets.QPushButton(self.groupBox_46)
self.ss7i70in_26.setObjectName("ss7i70in_26")
self.gridLayout_88.addWidget(self.ss7i70in_26, 2, 1, 1, 1)
self.ss7i70in_27 = QtWidgets.QPushButton(self.groupBox_46)
self.ss7i70in_27.setObjectName("ss7i70in_27")
self.gridLayout_88.addWidget(self.ss7i70in_27, 3, 1, 1, 1)
self.ss7i70in_28 = QtWidgets.QPushButton(self.groupBox_46)
self.ss7i70in_28.setObjectName("ss7i70in_28")
self.gridLayout_88.addWidget(self.ss7i70in_28, 4, 1, 1, 1)
self.ss7i70in_29 = QtWidgets.QPushButton(self.groupBox_46)
self.ss7i70in_29.setObjectName("ss7i70in_29")
self.gridLayout_88.addWidget(self.ss7i70in_29, 5, 1, 1, 1)
self.ss7i70in_30 = QtWidgets.QPushButton(self.groupBox_46)
self.ss7i70in_30.setObjectName("ss7i70in_30")
self.gridLayout_88.addWidget(self.ss7i70in_30, 6, 1, 1, 1)
self.ss7i70in_31 = QtWidgets.QPushButton(self.groupBox_46)
self.ss7i70in_31.setObjectName("ss7i70in_31")
self.gridLayout_88.addWidget(self.ss7i70in_31, 7, 1, 1, 1)
self.ss7i70in_32 = QtWidgets.QPushButton(self.groupBox_46)
self.ss7i70in_32.setObjectName("ss7i70in_32")
self.gridLayout_88.addWidget(self.ss7i70in_32, 8, 1, 1, 1)
self.ss7i70in_33 = QtWidgets.QPushButton(self.groupBox_46)
self.ss7i70in_33.setObjectName("ss7i70in_33")
self.gridLayout_88.addWidget(self.ss7i70in_33, 9, 1, 1, 1)
self.ss7i70in_34 = QtWidgets.QPushButton(self.groupBox_46)
self.ss7i70in_34.setObjectName("ss7i70in_34")
self.gridLayout_88.addWidget(self.ss7i70in_34, 10, 1, 1, 1)
self.ss7i70in_35 = QtWidgets.QPushButton(self.groupBox_46)
self.ss7i70in_35.setObjectName("ss7i70in_35")
self.gridLayout_88.addWidget(self.ss7i70in_35, 11, 1, 1, 1)
self.gridLayout_89.addWidget(self.groupBox_46, 0, 2, 1, 1)
spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_89.addItem(spacerItem5, 1, 0, 1, 1)
self.gridLayout_75.addWidget(self.groupBox_34, 0, 0, 1, 1)
self.smartSerialSW.addWidget(self.ss7i70)
self.ss7i71 = QtWidgets.QWidget()
self.ss7i71.setObjectName("ss7i71")
self.gridLayout_76 = QtWidgets.QGridLayout(self.ss7i71)
self.gridLayout_76.setContentsMargins(8, 8, 8, 8)
self.gridLayout_76.setSpacing(5)
self.gridLayout_76.setObjectName("gridLayout_76")
self.groupBox_35 = QtWidgets.QGroupBox(self.ss7i71)
self.groupBox_35.setObjectName("groupBox_35")
self.gridLayout_94 = QtWidgets.QGridLayout(self.groupBox_35)
self.gridLayout_94.setContentsMargins(8, 8, 8, 8)
self.gridLayout_94.setSpacing(5)
self.gridLayout_94.setObjectName("gridLayout_94")
self.groupBox_47 = QtWidgets.QGroupBox(self.groupBox_35)
self.groupBox_47.setObjectName("groupBox_47")
self.gridLayout_90 = QtWidgets.QGridLayout(self.groupBox_47)
self.gridLayout_90.setContentsMargins(8, 8, 8, 8)
self.gridLayout_90.setSpacing(5)
self.gridLayout_90.setObjectName("gridLayout_90")
self.label_640 = QtWidgets.QLabel(self.groupBox_47)
self.label_640.setObjectName("label_640")
self.gridLayout_90.addWidget(self.label_640, 1, 0, 1, 1)
self.label_637 = QtWidgets.QLabel(self.groupBox_47)
self.label_637.setObjectName("label_637")
self.gridLayout_90.addWidget(self.label_637, 5, 0, 1, 1)
self.label_638 = QtWidgets.QLabel(self.groupBox_47)
self.label_638.setObjectName("label_638")
self.gridLayout_90.addWidget(self.label_638, 7, 0, 1, 1)
self.label_607 = QtWidgets.QLabel(self.groupBox_47)
self.label_607.setObjectName("label_607")
self.gridLayout_90.addWidget(self.label_607, 11, 0, 1, 1)
self.label_615 = QtWidgets.QLabel(self.groupBox_47)
self.label_615.setObjectName("label_615")
self.gridLayout_90.addWidget(self.label_615, 9, 0, 1, 1)
self.label_630 = QtWidgets.QLabel(self.groupBox_47)
self.label_630.setObjectName("label_630")
self.gridLayout_90.addWidget(self.label_630, 3, 0, 1, 1)
self.label_639 = QtWidgets.QLabel(self.groupBox_47)
self.label_639.setObjectName("label_639")
self.gridLayout_90.addWidget(self.label_639, 6, 0, 1, 1)
self.label_633 = QtWidgets.QLabel(self.groupBox_47)
self.label_633.setObjectName("label_633")
self.gridLayout_90.addWidget(self.label_633, 8, 0, 1, 1)
self.label_634 = QtWidgets.QLabel(self.groupBox_47)
self.label_634.setObjectName("label_634")
self.gridLayout_90.addWidget(self.label_634, 0, 0, 1, 1)
self.label_635 = QtWidgets.QLabel(self.groupBox_47)
self.label_635.setObjectName("label_635")
self.gridLayout_90.addWidget(self.label_635, 4, 0, 1, 1)
self.label_636 = QtWidgets.QLabel(self.groupBox_47)
self.label_636.setObjectName("label_636")
self.gridLayout_90.addWidget(self.label_636, 10, 0, 1, 1)
self.label_586 = QtWidgets.QLabel(self.groupBox_47)
self.label_586.setObjectName("label_586")
self.gridLayout_90.addWidget(self.label_586, 2, 0, 1, 1)
self.ss7i71out_12 = QtWidgets.QPushButton(self.groupBox_47)
self.ss7i71out_12.setObjectName("ss7i71out_12")
self.gridLayout_90.addWidget(self.ss7i71out_12, 0, 1, 1, 1)
self.ss7i71out_13 = QtWidgets.QPushButton(self.groupBox_47)
self.ss7i71out_13.setObjectName("ss7i71out_13")
self.gridLayout_90.addWidget(self.ss7i71out_13, 1, 1, 1, 1)
self.ss7i71out_14 = QtWidgets.QPushButton(self.groupBox_47)
self.ss7i71out_14.setObjectName("ss7i71out_14")
self.gridLayout_90.addWidget(self.ss7i71out_14, 2, 1, 1, 1)
self.ss7i71out_15 = QtWidgets.QPushButton(self.groupBox_47)
self.ss7i71out_15.setObjectName("ss7i71out_15")
self.gridLayout_90.addWidget(self.ss7i71out_15, 3, 1, 1, 1)
self.ss7i71out_16 = QtWidgets.QPushButton(self.groupBox_47)
self.ss7i71out_16.setObjectName("ss7i71out_16")
self.gridLayout_90.addWidget(self.ss7i71out_16, 4, 1, 1, 1)
self.ss7i71out_17 = QtWidgets.QPushButton(self.groupBox_47)
self.ss7i71out_17.setObjectName("ss7i71out_17")
self.gridLayout_90.addWidget(self.ss7i71out_17, 5, 1, 1, 1)
self.ss7i71out_18 = QtWidgets.QPushButton(self.groupBox_47)
self.ss7i71out_18.setObjectName("ss7i71out_18")
self.gridLayout_90.addWidget(self.ss7i71out_18, 6, 1, 1, 1)
self.ss7i71out_19 = QtWidgets.QPushButton(self.groupBox_47)
self.ss7i71out_19.setObjectName("ss7i71out_19")
self.gridLayout_90.addWidget(self.ss7i71out_19, 7, 1, 1, 1)
self.ss7i71out_20 = QtWidgets.QPushButton(self.groupBox_47)
self.ss7i71out_20.setObjectName("ss7i71out_20")
self.gridLayout_90.addWidget(self.ss7i71out_20, 8, 1, 1, 1)
self.ss7i71out_21 = QtWidgets.QPushButton(self.groupBox_47)
self.ss7i71out_21.setObjectName("ss7i71out_21")
self.gridLayout_90.addWidget(self.ss7i71out_21, 9, 1, 1, 1)
self.ss7i71out_22 = QtWidgets.QPushButton(self.groupBox_47)
self.ss7i71out_22.setObjectName("ss7i71out_22")
self.gridLayout_90.addWidget(self.ss7i71out_22, 10, 1, 1, 1)
self.ss7i71out_23 = QtWidgets.QPushButton(self.groupBox_47)
self.ss7i71out_23.setObjectName("ss7i71out_23")
self.gridLayout_90.addWidget(self.ss7i71out_23, 11, 1, 1, 1)
self.gridLayout_94.addWidget(self.groupBox_47, 0, 1, 1, 1)
self.groupBox_48 = QtWidgets.QGroupBox(self.groupBox_35)
self.groupBox_48.setObjectName("groupBox_48")
self.gridLayout_91 = QtWidgets.QGridLayout(self.groupBox_48)
self.gridLayout_91.setContentsMargins(8, 8, 8, 8)
self.gridLayout_91.setSpacing(5)
self.gridLayout_91.setObjectName("gridLayout_91")
self.label_643 = QtWidgets.QLabel(self.groupBox_48)
self.label_643.setObjectName("label_643")
self.gridLayout_91.addWidget(self.label_643, 2, 0, 1, 1)
self.label_641 = QtWidgets.QLabel(self.groupBox_48)
self.label_641.setObjectName("label_641")
self.gridLayout_91.addWidget(self.label_641, 10, 0, 1, 1)
self.label_652 = QtWidgets.QLabel(self.groupBox_48)
self.label_652.setObjectName("label_652")
self.gridLayout_91.addWidget(self.label_652, 3, 0, 1, 1)
self.label_644 = QtWidgets.QLabel(self.groupBox_48)
self.label_644.setObjectName("label_644")
self.gridLayout_91.addWidget(self.label_644, 6, 0, 1, 1)
self.label_649 = QtWidgets.QLabel(self.groupBox_48)
self.label_649.setObjectName("label_649")
self.gridLayout_91.addWidget(self.label_649, 11, 0, 1, 1)
self.label_647 = QtWidgets.QLabel(self.groupBox_48)
self.label_647.setObjectName("label_647")
self.gridLayout_91.addWidget(self.label_647, 8, 0, 1, 1)
self.label_646 = QtWidgets.QLabel(self.groupBox_48)
self.label_646.setObjectName("label_646")
self.gridLayout_91.addWidget(self.label_646, 9, 0, 1, 1)
self.label_650 = QtWidgets.QLabel(self.groupBox_48)
self.label_650.setObjectName("label_650")
self.gridLayout_91.addWidget(self.label_650, 0, 0, 1, 1)
self.label_648 = QtWidgets.QLabel(self.groupBox_48)
self.label_648.setObjectName("label_648")
self.gridLayout_91.addWidget(self.label_648, 1, 0, 1, 1)
self.label_645 = QtWidgets.QLabel(self.groupBox_48)
self.label_645.setObjectName("label_645")
self.gridLayout_91.addWidget(self.label_645, 7, 0, 1, 1)
self.label_651 = QtWidgets.QLabel(self.groupBox_48)
self.label_651.setObjectName("label_651")
self.gridLayout_91.addWidget(self.label_651, 4, 0, 1, 1)
self.label_642 = QtWidgets.QLabel(self.groupBox_48)
self.label_642.setObjectName("label_642")
self.gridLayout_91.addWidget(self.label_642, 5, 0, 1, 1)
self.ss7i71out_36 = QtWidgets.QPushButton(self.groupBox_48)
self.ss7i71out_36.setObjectName("ss7i71out_36")
self.gridLayout_91.addWidget(self.ss7i71out_36, 0, 1, 1, 1)
self.ss7i71out_37 = QtWidgets.QPushButton(self.groupBox_48)
self.ss7i71out_37.setObjectName("ss7i71out_37")
self.gridLayout_91.addWidget(self.ss7i71out_37, 1, 1, 1, 1)
self.ss7i71out_38 = QtWidgets.QPushButton(self.groupBox_48)
self.ss7i71out_38.setObjectName("ss7i71out_38")
self.gridLayout_91.addWidget(self.ss7i71out_38, 2, 1, 1, 1)
self.ss7i71out_39 = QtWidgets.QPushButton(self.groupBox_48)
self.ss7i71out_39.setObjectName("ss7i71out_39")
self.gridLayout_91.addWidget(self.ss7i71out_39, 3, 1, 1, 1)
self.ss7i71out_40 = QtWidgets.QPushButton(self.groupBox_48)
self.ss7i71out_40.setObjectName("ss7i71out_40")
self.gridLayout_91.addWidget(self.ss7i71out_40, 4, 1, 1, 1)
self.ss7i71out_41 = QtWidgets.QPushButton(self.groupBox_48)
self.ss7i71out_41.setObjectName("ss7i71out_41")
self.gridLayout_91.addWidget(self.ss7i71out_41, 5, 1, 1, 1)
self.ss7i71out_42 = QtWidgets.QPushButton(self.groupBox_48)
self.ss7i71out_42.setObjectName("ss7i71out_42")
self.gridLayout_91.addWidget(self.ss7i71out_42, 6, 1, 1, 1)
self.ss7i71out_43 = QtWidgets.QPushButton(self.groupBox_48)
self.ss7i71out_43.setObjectName("ss7i71out_43")
self.gridLayout_91.addWidget(self.ss7i71out_43, 7, 1, 1, 1)
self.ss7i71out_44 = QtWidgets.QPushButton(self.groupBox_48)
self.ss7i71out_44.setObjectName("ss7i71out_44")
self.gridLayout_91.addWidget(self.ss7i71out_44, 8, 1, 1, 1)
self.ss7i71out_45 = QtWidgets.QPushButton(self.groupBox_48)
self.ss7i71out_45.setObjectName("ss7i71out_45")
self.gridLayout_91.addWidget(self.ss7i71out_45, 9, 1, 1, 1)
self.ss7i71out_46 = QtWidgets.QPushButton(self.groupBox_48)
self.ss7i71out_46.setObjectName("ss7i71out_46")
self.gridLayout_91.addWidget(self.ss7i71out_46, 10, 1, 1, 1)
self.ss7i71out_47 = QtWidgets.QPushButton(self.groupBox_48)
self.ss7i71out_47.setObjectName("ss7i71out_47")
self.gridLayout_91.addWidget(self.ss7i71out_47, 11, 1, 1, 1)
self.gridLayout_94.addWidget(self.groupBox_48, 0, 3, 1, 1)
self.groupBox_49 = QtWidgets.QGroupBox(self.groupBox_35)
self.groupBox_49.setObjectName("groupBox_49")
self.gridLayout_92 = QtWidgets.QGridLayout(self.groupBox_49)
self.gridLayout_92.setContentsMargins(8, 8, 8, 8)
self.gridLayout_92.setSpacing(5)
self.gridLayout_92.setObjectName("gridLayout_92")
self.label_656 = QtWidgets.QLabel(self.groupBox_49)
self.label_656.setObjectName("label_656")
self.gridLayout_92.addWidget(self.label_656, 11, 0, 1, 1)
self.label_654 = QtWidgets.QLabel(self.groupBox_49)
self.label_654.setObjectName("label_654")
self.gridLayout_92.addWidget(self.label_654, 9, 0, 1, 1)
self.label_653 = QtWidgets.QLabel(self.groupBox_49)
self.label_653.setObjectName("label_653")
self.gridLayout_92.addWidget(self.label_653, 0, 0, 1, 1)
self.label_655 = QtWidgets.QLabel(self.groupBox_49)
self.label_655.setObjectName("label_655")
self.gridLayout_92.addWidget(self.label_655, 8, 0, 1, 1)
self.label_660 = QtWidgets.QLabel(self.groupBox_49)
self.label_660.setObjectName("label_660")
self.gridLayout_92.addWidget(self.label_660, 2, 0, 1, 1)
self.label_657 = QtWidgets.QLabel(self.groupBox_49)
self.label_657.setObjectName("label_657")
self.gridLayout_92.addWidget(self.label_657, 10, 0, 1, 1)
self.label_659 = QtWidgets.QLabel(self.groupBox_49)
self.label_659.setObjectName("label_659")
self.gridLayout_92.addWidget(self.label_659, 3, 0, 1, 1)
self.label_662 = QtWidgets.QLabel(self.groupBox_49)
self.label_662.setObjectName("label_662")
self.gridLayout_92.addWidget(self.label_662, 7, 0, 1, 1)
self.label_663 = QtWidgets.QLabel(self.groupBox_49)
self.label_663.setObjectName("label_663")
self.gridLayout_92.addWidget(self.label_663, 5, 0, 1, 1)
self.label_658 = QtWidgets.QLabel(self.groupBox_49)
self.label_658.setObjectName("label_658")
self.gridLayout_92.addWidget(self.label_658, 1, 0, 1, 1)
self.label_664 = QtWidgets.QLabel(self.groupBox_49)
self.label_664.setObjectName("label_664")
self.gridLayout_92.addWidget(self.label_664, 4, 0, 1, 1)
self.label_661 = QtWidgets.QLabel(self.groupBox_49)
self.label_661.setObjectName("label_661")
self.gridLayout_92.addWidget(self.label_661, 6, 0, 1, 1)
self.ss7i71out_24 = QtWidgets.QPushButton(self.groupBox_49)
self.ss7i71out_24.setObjectName("ss7i71out_24")
self.gridLayout_92.addWidget(self.ss7i71out_24, 0, 1, 1, 1)
self.ss7i71out_25 = QtWidgets.QPushButton(self.groupBox_49)
self.ss7i71out_25.setObjectName("ss7i71out_25")
self.gridLayout_92.addWidget(self.ss7i71out_25, 1, 1, 1, 1)
self.ss7i71out_26 = QtWidgets.QPushButton(self.groupBox_49)
self.ss7i71out_26.setObjectName("ss7i71out_26")
self.gridLayout_92.addWidget(self.ss7i71out_26, 2, 1, 1, 1)
self.ss7i71out_27 = QtWidgets.QPushButton(self.groupBox_49)
self.ss7i71out_27.setObjectName("ss7i71out_27")
self.gridLayout_92.addWidget(self.ss7i71out_27, 3, 1, 1, 1)
self.ss7i71out_28 = QtWidgets.QPushButton(self.groupBox_49)
self.ss7i71out_28.setObjectName("ss7i71out_28")
self.gridLayout_92.addWidget(self.ss7i71out_28, 4, 1, 1, 1)
self.ss7i71out_29 = QtWidgets.QPushButton(self.groupBox_49)
self.ss7i71out_29.setObjectName("ss7i71out_29")
self.gridLayout_92.addWidget(self.ss7i71out_29, 5, 1, 1, 1)
self.ss7i71out_30 = QtWidgets.QPushButton(self.groupBox_49)
self.ss7i71out_30.setObjectName("ss7i71out_30")
self.gridLayout_92.addWidget(self.ss7i71out_30, 6, 1, 1, 1)
self.ss7i71out_31 = QtWidgets.QPushButton(self.groupBox_49)
self.ss7i71out_31.setObjectName("ss7i71out_31")
self.gridLayout_92.addWidget(self.ss7i71out_31, 7, 1, 1, 1)
self.ss7i71out_32 = QtWidgets.QPushButton(self.groupBox_49)
self.ss7i71out_32.setObjectName("ss7i71out_32")
self.gridLayout_92.addWidget(self.ss7i71out_32, 8, 1, 1, 1)
self.ss7i71out_33 = QtWidgets.QPushButton(self.groupBox_49)
self.ss7i71out_33.setObjectName("ss7i71out_33")
self.gridLayout_92.addWidget(self.ss7i71out_33, 9, 1, 1, 1)
self.ss7i71out_34 = QtWidgets.QPushButton(self.groupBox_49)
self.ss7i71out_34.setObjectName("ss7i71out_34")
self.gridLayout_92.addWidget(self.ss7i71out_34, 10, 1, 1, 1)
self.ss7i71out_35 = QtWidgets.QPushButton(self.groupBox_49)
self.ss7i71out_35.setObjectName("ss7i71out_35")
self.gridLayout_92.addWidget(self.ss7i71out_35, 11, 1, 1, 1)
self.gridLayout_94.addWidget(self.groupBox_49, 0, 2, 1, 1)
self.groupBox_50 = QtWidgets.QGroupBox(self.groupBox_35)
self.groupBox_50.setObjectName("groupBox_50")
self.gridLayout_93 = QtWidgets.QGridLayout(self.groupBox_50)
self.gridLayout_93.setContentsMargins(8, 8, 8, 8)
self.gridLayout_93.setSpacing(5)
self.gridLayout_93.setObjectName("gridLayout_93")
self.label_665 = QtWidgets.QLabel(self.groupBox_50)
self.label_665.setObjectName("label_665")
self.gridLayout_93.addWidget(self.label_665, 2, 0, 1, 1)
self.label_666 = QtWidgets.QLabel(self.groupBox_50)
self.label_666.setObjectName("label_666")
self.gridLayout_93.addWidget(self.label_666, 6, 0, 1, 1)
self.label_667 = QtWidgets.QLabel(self.groupBox_50)
self.label_667.setObjectName("label_667")
self.gridLayout_93.addWidget(self.label_667, 1, 0, 1, 1)
self.label_668 = QtWidgets.QLabel(self.groupBox_50)
self.label_668.setObjectName("label_668")
self.gridLayout_93.addWidget(self.label_668, 4, 0, 1, 1)
self.label_669 = QtWidgets.QLabel(self.groupBox_50)
self.label_669.setObjectName("label_669")
self.gridLayout_93.addWidget(self.label_669, 11, 0, 1, 1)
self.label_670 = QtWidgets.QLabel(self.groupBox_50)
self.label_670.setObjectName("label_670")
self.gridLayout_93.addWidget(self.label_670, 7, 0, 1, 1)
self.label_671 = QtWidgets.QLabel(self.groupBox_50)
self.label_671.setObjectName("label_671")
self.gridLayout_93.addWidget(self.label_671, 9, 0, 1, 1)
self.label_672 = QtWidgets.QLabel(self.groupBox_50)
self.label_672.setObjectName("label_672")
self.gridLayout_93.addWidget(self.label_672, 10, 0, 1, 1)
self.label_673 = QtWidgets.QLabel(self.groupBox_50)
self.label_673.setObjectName("label_673")
self.gridLayout_93.addWidget(self.label_673, 8, 0, 1, 1)
self.label_674 = QtWidgets.QLabel(self.groupBox_50)
self.label_674.setObjectName("label_674")
self.gridLayout_93.addWidget(self.label_674, 5, 0, 1, 1)
self.label_415 = QtWidgets.QLabel(self.groupBox_50)
self.label_415.setObjectName("label_415")
self.gridLayout_93.addWidget(self.label_415, 0, 0, 1, 1)
self.label_675 = QtWidgets.QLabel(self.groupBox_50)
self.label_675.setObjectName("label_675")
self.gridLayout_93.addWidget(self.label_675, 3, 0, 1, 1)
self.ss7i71out_0 = QtWidgets.QPushButton(self.groupBox_50)
self.ss7i71out_0.setObjectName("ss7i71out_0")
self.gridLayout_93.addWidget(self.ss7i71out_0, 0, 1, 1, 1)
self.ss7i71out_1 = QtWidgets.QPushButton(self.groupBox_50)
self.ss7i71out_1.setObjectName("ss7i71out_1")
self.gridLayout_93.addWidget(self.ss7i71out_1, 1, 1, 1, 1)
self.ss7i71out_2 = QtWidgets.QPushButton(self.groupBox_50)
self.ss7i71out_2.setObjectName("ss7i71out_2")
self.gridLayout_93.addWidget(self.ss7i71out_2, 2, 1, 1, 1)
self.ss7i71out_3 = QtWidgets.QPushButton(self.groupBox_50)
self.ss7i71out_3.setObjectName("ss7i71out_3")
self.gridLayout_93.addWidget(self.ss7i71out_3, 3, 1, 1, 1)
self.ss7i71out_4 = QtWidgets.QPushButton(self.groupBox_50)
self.ss7i71out_4.setObjectName("ss7i71out_4")
self.gridLayout_93.addWidget(self.ss7i71out_4, 4, 1, 1, 1)
self.ss7i71out_5 = QtWidgets.QPushButton(self.groupBox_50)
self.ss7i71out_5.setObjectName("ss7i71out_5")
self.gridLayout_93.addWidget(self.ss7i71out_5, 5, 1, 1, 1)
self.ss7i71out_6 = QtWidgets.QPushButton(self.groupBox_50)
self.ss7i71out_6.setObjectName("ss7i71out_6")
self.gridLayout_93.addWidget(self.ss7i71out_6, 6, 1, 1, 1)
self.ss7i71out_7 = QtWidgets.QPushButton(self.groupBox_50)
self.ss7i71out_7.setObjectName("ss7i71out_7")
self.gridLayout_93.addWidget(self.ss7i71out_7, 7, 1, 1, 1)
self.ss7i71out_8 = QtWidgets.QPushButton(self.groupBox_50)
self.ss7i71out_8.setObjectName("ss7i71out_8")
self.gridLayout_93.addWidget(self.ss7i71out_8, 8, 1, 1, 1)
self.ss7i71out_9 = QtWidgets.QPushButton(self.groupBox_50)
self.ss7i71out_9.setObjectName("ss7i71out_9")
self.gridLayout_93.addWidget(self.ss7i71out_9, 9, 1, 1, 1)
self.ss7i71out_10 = QtWidgets.QPushButton(self.groupBox_50)
self.ss7i71out_10.setObjectName("ss7i71out_10")
self.gridLayout_93.addWidget(self.ss7i71out_10, 10, 1, 1, 1)
self.ss7i71out_11 = QtWidgets.QPushButton(self.groupBox_50)
self.ss7i71out_11.setObjectName("ss7i71out_11")
self.gridLayout_93.addWidget(self.ss7i71out_11, 11, 1, 1, 1)
self.gridLayout_94.addWidget(self.groupBox_50, 0, 0, 1, 1)
spacerItem6 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_94.addItem(spacerItem6, 1, 0, 1, 1)
self.gridLayout_76.addWidget(self.groupBox_35, 0, 0, 1, 1)
self.smartSerialSW.addWidget(self.ss7i71)
self.ss7i72 = QtWidgets.QWidget()
self.ss7i72.setObjectName("ss7i72")
self.gridLayout_77 = QtWidgets.QGridLayout(self.ss7i72)
self.gridLayout_77.setContentsMargins(8, 8, 8, 8)
self.gridLayout_77.setSpacing(5)
self.gridLayout_77.setObjectName("gridLayout_77")
self.groupBox_36 = QtWidgets.QGroupBox(self.ss7i72)
self.groupBox_36.setObjectName("groupBox_36")
self.gridLayout_99 = QtWidgets.QGridLayout(self.groupBox_36)
self.gridLayout_99.setContentsMargins(8, 8, 8, 8)
self.gridLayout_99.setSpacing(5)
self.gridLayout_99.setObjectName("gridLayout_99")
self.groupBox_51 = QtWidgets.QGroupBox(self.groupBox_36)
self.groupBox_51.setObjectName("groupBox_51")
self.gridLayout_95 = QtWidgets.QGridLayout(self.groupBox_51)
self.gridLayout_95.setContentsMargins(8, 8, 8, 8)
self.gridLayout_95.setSpacing(5)
self.gridLayout_95.setObjectName("gridLayout_95")
self.label_676 = QtWidgets.QLabel(self.groupBox_51)
self.label_676.setObjectName("label_676")
self.gridLayout_95.addWidget(self.label_676, 2, 0, 1, 1)
self.label_677 = QtWidgets.QLabel(self.groupBox_51)
self.label_677.setObjectName("label_677")
self.gridLayout_95.addWidget(self.label_677, 6, 0, 1, 1)
self.label_678 = QtWidgets.QLabel(self.groupBox_51)
self.label_678.setObjectName("label_678")
self.gridLayout_95.addWidget(self.label_678, 1, 0, 1, 1)
self.label_679 = QtWidgets.QLabel(self.groupBox_51)
self.label_679.setObjectName("label_679")
self.gridLayout_95.addWidget(self.label_679, 4, 0, 1, 1)
self.label_680 = QtWidgets.QLabel(self.groupBox_51)
self.label_680.setObjectName("label_680")
self.gridLayout_95.addWidget(self.label_680, 11, 0, 1, 1)
self.label_681 = QtWidgets.QLabel(self.groupBox_51)
self.label_681.setObjectName("label_681")
self.gridLayout_95.addWidget(self.label_681, 7, 0, 1, 1)
self.label_682 = QtWidgets.QLabel(self.groupBox_51)
self.label_682.setObjectName("label_682")
self.gridLayout_95.addWidget(self.label_682, 9, 0, 1, 1)
self.label_683 = QtWidgets.QLabel(self.groupBox_51)
self.label_683.setObjectName("label_683")
self.gridLayout_95.addWidget(self.label_683, 10, 0, 1, 1)
self.label_684 = QtWidgets.QLabel(self.groupBox_51)
self.label_684.setObjectName("label_684")
self.gridLayout_95.addWidget(self.label_684, 8, 0, 1, 1)
self.label_685 = QtWidgets.QLabel(self.groupBox_51)
self.label_685.setObjectName("label_685")
self.gridLayout_95.addWidget(self.label_685, 5, 0, 1, 1)
self.label_416 = QtWidgets.QLabel(self.groupBox_51)
self.label_416.setObjectName("label_416")
self.gridLayout_95.addWidget(self.label_416, 0, 0, 1, 1)
self.label_686 = QtWidgets.QLabel(self.groupBox_51)
self.label_686.setObjectName("label_686")
self.gridLayout_95.addWidget(self.label_686, 3, 0, 1, 1)
self.ss7i72out_0 = QtWidgets.QPushButton(self.groupBox_51)
self.ss7i72out_0.setObjectName("ss7i72out_0")
self.gridLayout_95.addWidget(self.ss7i72out_0, 0, 1, 1, 1)
self.ss7i72out_1 = QtWidgets.QPushButton(self.groupBox_51)
self.ss7i72out_1.setObjectName("ss7i72out_1")
self.gridLayout_95.addWidget(self.ss7i72out_1, 1, 1, 1, 1)
self.ss7i72out_2 = QtWidgets.QPushButton(self.groupBox_51)
self.ss7i72out_2.setObjectName("ss7i72out_2")
self.gridLayout_95.addWidget(self.ss7i72out_2, 2, 1, 1, 1)
self.ss7i72out_3 = QtWidgets.QPushButton(self.groupBox_51)
self.ss7i72out_3.setObjectName("ss7i72out_3")
self.gridLayout_95.addWidget(self.ss7i72out_3, 3, 1, 1, 1)
self.ss7i72out_4 = QtWidgets.QPushButton(self.groupBox_51)
self.ss7i72out_4.setObjectName("ss7i72out_4")
self.gridLayout_95.addWidget(self.ss7i72out_4, 4, 1, 1, 1)
self.ss7i72out_5 = QtWidgets.QPushButton(self.groupBox_51)
self.ss7i72out_5.setObjectName("ss7i72out_5")
self.gridLayout_95.addWidget(self.ss7i72out_5, 5, 1, 1, 1)
self.ss7i72out_6 = QtWidgets.QPushButton(self.groupBox_51)
self.ss7i72out_6.setObjectName("ss7i72out_6")
self.gridLayout_95.addWidget(self.ss7i72out_6, 6, 1, 1, 1)
self.ss7i72out_7 = QtWidgets.QPushButton(self.groupBox_51)
self.ss7i72out_7.setObjectName("ss7i72out_7")
self.gridLayout_95.addWidget(self.ss7i72out_7, 7, 1, 1, 1)
self.ss7i72out_8 = QtWidgets.QPushButton(self.groupBox_51)
self.ss7i72out_8.setObjectName("ss7i72out_8")
self.gridLayout_95.addWidget(self.ss7i72out_8, 8, 1, 1, 1)
self.ss7i72out_9 = QtWidgets.QPushButton(self.groupBox_51)
self.ss7i72out_9.setObjectName("ss7i72out_9")
self.gridLayout_95.addWidget(self.ss7i72out_9, 9, 1, 1, 1)
self.ss7i72out_10 = QtWidgets.QPushButton(self.groupBox_51)
self.ss7i72out_10.setObjectName("ss7i72out_10")
self.gridLayout_95.addWidget(self.ss7i72out_10, 10, 1, 1, 1)
self.ss7i72out_11 = QtWidgets.QPushButton(self.groupBox_51)
self.ss7i72out_11.setObjectName("ss7i72out_11")
self.gridLayout_95.addWidget(self.ss7i72out_11, 11, 1, 1, 1)
self.gridLayout_99.addWidget(self.groupBox_51, 0, 0, 1, 1)
self.groupBox_52 = QtWidgets.QGroupBox(self.groupBox_36)
self.groupBox_52.setObjectName("groupBox_52")
self.gridLayout_96 = QtWidgets.QGridLayout(self.groupBox_52)
self.gridLayout_96.setContentsMargins(8, 8, 8, 8)
self.gridLayout_96.setSpacing(5)
self.gridLayout_96.setObjectName("gridLayout_96")
self.label_687 = QtWidgets.QLabel(self.groupBox_52)
self.label_687.setObjectName("label_687")
self.gridLayout_96.addWidget(self.label_687, 2, 0, 1, 1)
self.label_690 = QtWidgets.QLabel(self.groupBox_52)
self.label_690.setObjectName("label_690")
self.gridLayout_96.addWidget(self.label_690, 3, 0, 1, 1)
self.label_689 = QtWidgets.QLabel(self.groupBox_52)
self.label_689.setObjectName("label_689")
self.gridLayout_96.addWidget(self.label_689, 9, 0, 1, 1)
self.label_692 = QtWidgets.QLabel(self.groupBox_52)
self.label_692.setObjectName("label_692")
self.gridLayout_96.addWidget(self.label_692, 0, 0, 1, 1)
self.label_694 = QtWidgets.QLabel(self.groupBox_52)
self.label_694.setObjectName("label_694")
self.gridLayout_96.addWidget(self.label_694, 10, 0, 1, 1)
self.label_693 = QtWidgets.QLabel(self.groupBox_52)
self.label_693.setObjectName("label_693")
self.gridLayout_96.addWidget(self.label_693, 4, 0, 1, 1)
self.label_688 = QtWidgets.QLabel(self.groupBox_52)
self.label_688.setObjectName("label_688")
self.gridLayout_96.addWidget(self.label_688, 11, 0, 1, 1)
self.label_697 = QtWidgets.QLabel(self.groupBox_52)
self.label_697.setObjectName("label_697")
self.gridLayout_96.addWidget(self.label_697, 6, 0, 1, 1)
self.label_698 = QtWidgets.QLabel(self.groupBox_52)
self.label_698.setObjectName("label_698")
self.gridLayout_96.addWidget(self.label_698, 1, 0, 1, 1)
self.label_696 = QtWidgets.QLabel(self.groupBox_52)
self.label_696.setObjectName("label_696")
self.gridLayout_96.addWidget(self.label_696, 7, 0, 1, 1)
self.label_695 = QtWidgets.QLabel(self.groupBox_52)
self.label_695.setObjectName("label_695")
self.gridLayout_96.addWidget(self.label_695, 5, 0, 1, 1)
self.label_691 = QtWidgets.QLabel(self.groupBox_52)
self.label_691.setObjectName("label_691")
self.gridLayout_96.addWidget(self.label_691, 8, 0, 1, 1)
self.ss7i72out_12 = QtWidgets.QPushButton(self.groupBox_52)
self.ss7i72out_12.setObjectName("ss7i72out_12")
self.gridLayout_96.addWidget(self.ss7i72out_12, 0, 1, 1, 1)
self.ss7i72out_13 = QtWidgets.QPushButton(self.groupBox_52)
self.ss7i72out_13.setObjectName("ss7i72out_13")
self.gridLayout_96.addWidget(self.ss7i72out_13, 1, 1, 1, 1)
self.ss7i72out_14 = QtWidgets.QPushButton(self.groupBox_52)
self.ss7i72out_14.setObjectName("ss7i72out_14")
self.gridLayout_96.addWidget(self.ss7i72out_14, 2, 1, 1, 1)
self.ss7i72out_15 = QtWidgets.QPushButton(self.groupBox_52)
self.ss7i72out_15.setObjectName("ss7i72out_15")
self.gridLayout_96.addWidget(self.ss7i72out_15, 3, 1, 1, 1)
self.ss7i72out_16 = QtWidgets.QPushButton(self.groupBox_52)
self.ss7i72out_16.setObjectName("ss7i72out_16")
self.gridLayout_96.addWidget(self.ss7i72out_16, 4, 1, 1, 1)
self.ss7i72out_17 = QtWidgets.QPushButton(self.groupBox_52)
self.ss7i72out_17.setObjectName("ss7i72out_17")
self.gridLayout_96.addWidget(self.ss7i72out_17, 5, 1, 1, 1)
self.ss7i72out_18 = QtWidgets.QPushButton(self.groupBox_52)
self.ss7i72out_18.setObjectName("ss7i72out_18")
self.gridLayout_96.addWidget(self.ss7i72out_18, 6, 1, 1, 1)
self.ss7i72out_19 = QtWidgets.QPushButton(self.groupBox_52)
self.ss7i72out_19.setObjectName("ss7i72out_19")
self.gridLayout_96.addWidget(self.ss7i72out_19, 7, 1, 1, 1)
self.ss7i72out_20 = QtWidgets.QPushButton(self.groupBox_52)
self.ss7i72out_20.setObjectName("ss7i72out_20")
self.gridLayout_96.addWidget(self.ss7i72out_20, 8, 1, 1, 1)
self.ss7i72out_21 = QtWidgets.QPushButton(self.groupBox_52)
self.ss7i72out_21.setObjectName("ss7i72out_21")
self.gridLayout_96.addWidget(self.ss7i72out_21, 9, 1, 1, 1)
self.ss7i72out_22 = QtWidgets.QPushButton(self.groupBox_52)
self.ss7i72out_22.setObjectName("ss7i72out_22")
self.gridLayout_96.addWidget(self.ss7i72out_22, 10, 1, 1, 1)
self.ss7i72out_23 = QtWidgets.QPushButton(self.groupBox_52)
self.ss7i72out_23.setObjectName("ss7i72out_23")
self.gridLayout_96.addWidget(self.ss7i72out_23, 11, 1, 1, 1)
self.gridLayout_99.addWidget(self.groupBox_52, 0, 1, 1, 1)
self.groupBox_54 = QtWidgets.QGroupBox(self.groupBox_36)
self.groupBox_54.setObjectName("groupBox_54")
self.gridLayout_98 = QtWidgets.QGridLayout(self.groupBox_54)
self.gridLayout_98.setContentsMargins(8, 8, 8, 8)
self.gridLayout_98.setSpacing(5)
self.gridLayout_98.setObjectName("gridLayout_98")
self.label_712 = QtWidgets.QLabel(self.groupBox_54)
self.label_712.setObjectName("label_712")
self.gridLayout_98.addWidget(self.label_712, 5, 0, 1, 1)
self.label_716 = QtWidgets.QLabel(self.groupBox_54)
self.label_716.setObjectName("label_716")
self.gridLayout_98.addWidget(self.label_716, 9, 0, 1, 1)
self.label_717 = QtWidgets.QLabel(self.groupBox_54)
self.label_717.setObjectName("label_717")
self.gridLayout_98.addWidget(self.label_717, 8, 0, 1, 1)
self.label_718 = QtWidgets.QLabel(self.groupBox_54)
self.label_718.setObjectName("label_718")
self.gridLayout_98.addWidget(self.label_718, 1, 0, 1, 1)
self.label_715 = QtWidgets.QLabel(self.groupBox_54)
self.label_715.setObjectName("label_715")
self.gridLayout_98.addWidget(self.label_715, 7, 0, 1, 1)
self.label_721 = QtWidgets.QLabel(self.groupBox_54)
self.label_721.setObjectName("label_721")
self.gridLayout_98.addWidget(self.label_721, 4, 0, 1, 1)
self.label_714 = QtWidgets.QLabel(self.groupBox_54)
self.label_714.setObjectName("label_714")
self.gridLayout_98.addWidget(self.label_714, 6, 0, 1, 1)
self.label_722 = QtWidgets.QLabel(self.groupBox_54)
self.label_722.setObjectName("label_722")
self.gridLayout_98.addWidget(self.label_722, 3, 0, 1, 1)
self.label_720 = QtWidgets.QLabel(self.groupBox_54)
self.label_720.setObjectName("label_720")
self.gridLayout_98.addWidget(self.label_720, 0, 0, 1, 1)
self.label_719 = QtWidgets.QLabel(self.groupBox_54)
self.label_719.setObjectName("label_719")
self.gridLayout_98.addWidget(self.label_719, 11, 0, 1, 1)
self.label_711 = QtWidgets.QLabel(self.groupBox_54)
self.label_711.setObjectName("label_711")
self.gridLayout_98.addWidget(self.label_711, 10, 0, 1, 1)
self.label_713 = QtWidgets.QLabel(self.groupBox_54)
self.label_713.setObjectName("label_713")
self.gridLayout_98.addWidget(self.label_713, 2, 0, 1, 1)
self.ss7i72out_36 = QtWidgets.QPushButton(self.groupBox_54)
self.ss7i72out_36.setObjectName("ss7i72out_36")
self.gridLayout_98.addWidget(self.ss7i72out_36, 0, 1, 1, 1)
self.ss7i72out_37 = QtWidgets.QPushButton(self.groupBox_54)
self.ss7i72out_37.setObjectName("ss7i72out_37")
self.gridLayout_98.addWidget(self.ss7i72out_37, 1, 1, 1, 1)
self.ss7i72out_38 = QtWidgets.QPushButton(self.groupBox_54)
self.ss7i72out_38.setObjectName("ss7i72out_38")
self.gridLayout_98.addWidget(self.ss7i72out_38, 2, 1, 1, 1)
self.ss7i72out_39 = QtWidgets.QPushButton(self.groupBox_54)
self.ss7i72out_39.setObjectName("ss7i72out_39")
self.gridLayout_98.addWidget(self.ss7i72out_39, 3, 1, 1, 1)
self.ss7i72out_40 = QtWidgets.QPushButton(self.groupBox_54)
self.ss7i72out_40.setObjectName("ss7i72out_40")
self.gridLayout_98.addWidget(self.ss7i72out_40, 4, 1, 1, 1)
self.ss7i72out_41 = QtWidgets.QPushButton(self.groupBox_54)
self.ss7i72out_41.setObjectName("ss7i72out_41")
self.gridLayout_98.addWidget(self.ss7i72out_41, 5, 1, 1, 1)
self.ss7i72out_42 = QtWidgets.QPushButton(self.groupBox_54)
self.ss7i72out_42.setObjectName("ss7i72out_42")
self.gridLayout_98.addWidget(self.ss7i72out_42, 6, 1, 1, 1)
self.ss7i72out_43 = QtWidgets.QPushButton(self.groupBox_54)
self.ss7i72out_43.setObjectName("ss7i72out_43")
self.gridLayout_98.addWidget(self.ss7i72out_43, 7, 1, 1, 1)
self.ss7i72out_44 = QtWidgets.QPushButton(self.groupBox_54)
self.ss7i72out_44.setObjectName("ss7i72out_44")
self.gridLayout_98.addWidget(self.ss7i72out_44, 8, 1, 1, 1)
self.ss7i72out_45 = QtWidgets.QPushButton(self.groupBox_54)
self.ss7i72out_45.setObjectName("ss7i72out_45")
self.gridLayout_98.addWidget(self.ss7i72out_45, 9, 1, 1, 1)
self.ss7i72out_46 = QtWidgets.QPushButton(self.groupBox_54)
self.ss7i72out_46.setObjectName("ss7i72out_46")
self.gridLayout_98.addWidget(self.ss7i72out_46, 10, 1, 1, 1)
self.ss7i72out_47 = QtWidgets.QPushButton(self.groupBox_54)
self.ss7i72out_47.setObjectName("ss7i72out_47")
self.gridLayout_98.addWidget(self.ss7i72out_47, 11, 1, 1, 1)
self.gridLayout_99.addWidget(self.groupBox_54, 0, 3, 1, 1)
self.groupBox_53 = QtWidgets.QGroupBox(self.groupBox_36)
self.groupBox_53.setObjectName("groupBox_53")
self.gridLayout_97 = QtWidgets.QGridLayout(self.groupBox_53)
self.gridLayout_97.setContentsMargins(8, 8, 8, 8)
self.gridLayout_97.setSpacing(5)
self.gridLayout_97.setObjectName("gridLayout_97")
self.label_702 = QtWidgets.QLabel(self.groupBox_53)
self.label_702.setObjectName("label_702")
self.gridLayout_97.addWidget(self.label_702, 11, 0, 1, 1)
self.label_701 = QtWidgets.QLabel(self.groupBox_53)
self.label_701.setObjectName("label_701")
self.gridLayout_97.addWidget(self.label_701, 8, 0, 1, 1)
self.label_707 = QtWidgets.QLabel(self.groupBox_53)
self.label_707.setObjectName("label_707")
self.gridLayout_97.addWidget(self.label_707, 6, 0, 1, 1)
self.label_706 = QtWidgets.QLabel(self.groupBox_53)
self.label_706.setObjectName("label_706")
self.gridLayout_97.addWidget(self.label_706, 2, 0, 1, 1)
self.label_700 = QtWidgets.QLabel(self.groupBox_53)
self.label_700.setObjectName("label_700")
self.gridLayout_97.addWidget(self.label_700, 9, 0, 1, 1)
self.label_699 = QtWidgets.QLabel(self.groupBox_53)
self.label_699.setObjectName("label_699")
self.gridLayout_97.addWidget(self.label_699, 0, 0, 1, 1)
self.label_704 = QtWidgets.QLabel(self.groupBox_53)
self.label_704.setObjectName("label_704")
self.gridLayout_97.addWidget(self.label_704, 1, 0, 1, 1)
self.label_709 = QtWidgets.QLabel(self.groupBox_53)
self.label_709.setObjectName("label_709")
self.gridLayout_97.addWidget(self.label_709, 5, 0, 1, 1)
self.label_710 = QtWidgets.QLabel(self.groupBox_53)
self.label_710.setObjectName("label_710")
self.gridLayout_97.addWidget(self.label_710, 4, 0, 1, 1)
self.label_703 = QtWidgets.QLabel(self.groupBox_53)
self.label_703.setObjectName("label_703")
self.gridLayout_97.addWidget(self.label_703, 10, 0, 1, 1)
self.label_705 = QtWidgets.QLabel(self.groupBox_53)
self.label_705.setObjectName("label_705")
self.gridLayout_97.addWidget(self.label_705, 3, 0, 1, 1)
self.label_708 = QtWidgets.QLabel(self.groupBox_53)
self.label_708.setObjectName("label_708")
self.gridLayout_97.addWidget(self.label_708, 7, 0, 1, 1)
self.ss7i72out_24 = QtWidgets.QPushButton(self.groupBox_53)
self.ss7i72out_24.setObjectName("ss7i72out_24")
self.gridLayout_97.addWidget(self.ss7i72out_24, 0, 1, 1, 1)
self.ss7i72out_25 = QtWidgets.QPushButton(self.groupBox_53)
self.ss7i72out_25.setObjectName("ss7i72out_25")
self.gridLayout_97.addWidget(self.ss7i72out_25, 1, 1, 1, 1)
self.ss7i72out_26 = QtWidgets.QPushButton(self.groupBox_53)
self.ss7i72out_26.setObjectName("ss7i72out_26")
self.gridLayout_97.addWidget(self.ss7i72out_26, 2, 1, 1, 1)
self.ss7i72out_27 = QtWidgets.QPushButton(self.groupBox_53)
self.ss7i72out_27.setObjectName("ss7i72out_27")
self.gridLayout_97.addWidget(self.ss7i72out_27, 3, 1, 1, 1)
self.ss7i72out_28 = QtWidgets.QPushButton(self.groupBox_53)
self.ss7i72out_28.setObjectName("ss7i72out_28")
self.gridLayout_97.addWidget(self.ss7i72out_28, 4, 1, 1, 1)
self.ss7i72out_29 = QtWidgets.QPushButton(self.groupBox_53)
self.ss7i72out_29.setObjectName("ss7i72out_29")
self.gridLayout_97.addWidget(self.ss7i72out_29, 5, 1, 1, 1)
self.ss7i72out_30 = QtWidgets.QPushButton(self.groupBox_53)
self.ss7i72out_30.setObjectName("ss7i72out_30")
self.gridLayout_97.addWidget(self.ss7i72out_30, 6, 1, 1, 1)
self.ss7i72out_31 = QtWidgets.QPushButton(self.groupBox_53)
self.ss7i72out_31.setObjectName("ss7i72out_31")
self.gridLayout_97.addWidget(self.ss7i72out_31, 7, 1, 1, 1)
self.ss7i72out_32 = QtWidgets.QPushButton(self.groupBox_53)
self.ss7i72out_32.setObjectName("ss7i72out_32")
self.gridLayout_97.addWidget(self.ss7i72out_32, 8, 1, 1, 1)
self.ss7i72out_33 = QtWidgets.QPushButton(self.groupBox_53)
self.ss7i72out_33.setObjectName("ss7i72out_33")
self.gridLayout_97.addWidget(self.ss7i72out_33, 9, 1, 1, 1)
self.ss7i72out_34 = QtWidgets.QPushButton(self.groupBox_53)
self.ss7i72out_34.setObjectName("ss7i72out_34")
self.gridLayout_97.addWidget(self.ss7i72out_34, 10, 1, 1, 1)
self.ss7i72out_35 = QtWidgets.QPushButton(self.groupBox_53)
self.ss7i72out_35.setObjectName("ss7i72out_35")
self.gridLayout_97.addWidget(self.ss7i72out_35, 11, 1, 1, 1)
self.gridLayout_99.addWidget(self.groupBox_53, 0, 2, 1, 1)
spacerItem7 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_99.addItem(spacerItem7, 1, 0, 1, 1)
self.gridLayout_77.addWidget(self.groupBox_36, 0, 0, 1, 1)
self.smartSerialSW.addWidget(self.ss7i72)
self.ss7i73 = QtWidgets.QWidget()
self.ss7i73.setObjectName("ss7i73")
self.gridLayout_78 = QtWidgets.QGridLayout(self.ss7i73)
self.gridLayout_78.setContentsMargins(8, 8, 8, 8)
self.gridLayout_78.setSpacing(5)
self.gridLayout_78.setObjectName("gridLayout_78")
self.groupBox_37 = QtWidgets.QGroupBox(self.ss7i73)
self.groupBox_37.setObjectName("groupBox_37")
self.gridLayout_101 = QtWidgets.QGridLayout(self.groupBox_37)
self.gridLayout_101.setContentsMargins(8, 8, 8, 8)
self.gridLayout_101.setSpacing(5)
self.gridLayout_101.setObjectName("gridLayout_101")
self.groupBox_56 = QtWidgets.QGroupBox(self.groupBox_37)
self.groupBox_56.setObjectName("groupBox_56")
self.gridLayout_67 = QtWidgets.QGridLayout(self.groupBox_56)
self.gridLayout_67.setContentsMargins(8, 8, 8, 8)
self.gridLayout_67.setSpacing(5)
self.gridLayout_67.setObjectName("gridLayout_67")
self.label_509 = QtWidgets.QLabel(self.groupBox_56)
self.label_509.setObjectName("label_509")
self.gridLayout_67.addWidget(self.label_509, 0, 0, 1, 1)
self.ss7i73_keypadCB = QtWidgets.QComboBox(self.groupBox_56)
self.ss7i73_keypadCB.setObjectName("ss7i73_keypadCB")
self.gridLayout_67.addWidget(self.ss7i73_keypadCB, 1, 0, 1, 1)
self.ss7i73w5Lbl = QtWidgets.QLabel(self.groupBox_56)
self.ss7i73w5Lbl.setMinimumSize(QtCore.QSize(0, 0))
self.ss7i73w5Lbl.setFrameShape(QtWidgets.QFrame.Box)
self.ss7i73w5Lbl.setObjectName("ss7i73w5Lbl")
self.gridLayout_67.addWidget(self.ss7i73w5Lbl, 2, 0, 1, 1)
self.ss7i73w6Lbl = QtWidgets.QLabel(self.groupBox_56)
self.ss7i73w6Lbl.setMinimumSize(QtCore.QSize(0, 0))
self.ss7i73w6Lbl.setFrameShape(QtWidgets.QFrame.Box)
self.ss7i73w6Lbl.setObjectName("ss7i73w6Lbl")
self.gridLayout_67.addWidget(self.ss7i73w6Lbl, 3, 0, 1, 1)
self.label_728 = QtWidgets.QLabel(self.groupBox_56)
self.label_728.setObjectName("label_728")
self.gridLayout_67.addWidget(self.label_728, 4, 0, 1, 1)
self.ss7i97lcdCB = QtWidgets.QComboBox(self.groupBox_56)
self.ss7i97lcdCB.setObjectName("ss7i97lcdCB")
self.gridLayout_67.addWidget(self.ss7i97lcdCB, 5, 0, 1, 1)
self.ss7i97w7Lbl = QtWidgets.QLabel(self.groupBox_56)
self.ss7i97w7Lbl.setFrameShape(QtWidgets.QFrame.Box)
self.ss7i97w7Lbl.setObjectName("ss7i97w7Lbl")
self.gridLayout_67.addWidget(self.ss7i97w7Lbl, 6, 0, 1, 1)
self.gridLayout_101.addWidget(self.groupBox_56, 0, 1, 1, 1)
spacerItem8 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_101.addItem(spacerItem8, 1, 1, 1, 1)
self.groupBox_58 = QtWidgets.QGroupBox(self.groupBox_37)
self.groupBox_58.setObjectName("groupBox_58")
self.gridLayout_104 = QtWidgets.QGridLayout(self.groupBox_58)
self.gridLayout_104.setContentsMargins(8, 8, 8, 8)
self.gridLayout_104.setSpacing(5)
self.gridLayout_104.setObjectName("gridLayout_104")
self.label_726 = QtWidgets.QLabel(self.groupBox_58)
self.label_726.setObjectName("label_726")
self.gridLayout_104.addWidget(self.label_726, 0, 0, 1, 1)
self.label_730 = QtWidgets.QLabel(self.groupBox_58)
self.label_730.setObjectName("label_730")
self.gridLayout_104.addWidget(self.label_730, 2, 0, 1, 1)
self.label_468 = QtWidgets.QLabel(self.groupBox_58)
self.label_468.setObjectName("label_468")
self.gridLayout_104.addWidget(self.label_468, 0, 2, 1, 1)
self.label_736 = QtWidgets.QLabel(self.groupBox_58)
self.label_736.setObjectName("label_736")
self.gridLayout_104.addWidget(self.label_736, 6, 0, 1, 1)
self.label_743 = QtWidgets.QLabel(self.groupBox_58)
self.label_743.setObjectName("label_743")
self.gridLayout_104.addWidget(self.label_743, 13, 0, 1, 1)
self.label_738 = QtWidgets.QLabel(self.groupBox_58)
self.label_738.setObjectName("label_738")
self.gridLayout_104.addWidget(self.label_738, 8, 0, 1, 1)
self.label_734 = QtWidgets.QLabel(self.groupBox_58)
self.label_734.setObjectName("label_734")
self.gridLayout_104.addWidget(self.label_734, 4, 0, 1, 1)
self.label_735 = QtWidgets.QLabel(self.groupBox_58)
self.label_735.setObjectName("label_735")
self.gridLayout_104.addWidget(self.label_735, 5, 0, 1, 1)
self.label_729 = QtWidgets.QLabel(self.groupBox_58)
self.label_729.setObjectName("label_729")
self.gridLayout_104.addWidget(self.label_729, 1, 0, 1, 1)
self.label_741 = QtWidgets.QLabel(self.groupBox_58)
self.label_741.setObjectName("label_741")
self.gridLayout_104.addWidget(self.label_741, 11, 0, 1, 1)
self.label_737 = QtWidgets.QLabel(self.groupBox_58)
self.label_737.setObjectName("label_737")
self.gridLayout_104.addWidget(self.label_737, 7, 0, 1, 1)
self.label_733 = QtWidgets.QLabel(self.groupBox_58)
self.label_733.setObjectName("label_733")
self.gridLayout_104.addWidget(self.label_733, 3, 0, 1, 1)
self.label_739 = QtWidgets.QLabel(self.groupBox_58)
self.label_739.setObjectName("label_739")
self.gridLayout_104.addWidget(self.label_739, 9, 0, 1, 1)
self.label_742 = QtWidgets.QLabel(self.groupBox_58)
self.label_742.setObjectName("label_742")
self.gridLayout_104.addWidget(self.label_742, 12, 0, 1, 1)
self.label_740 = QtWidgets.QLabel(self.groupBox_58)
self.label_740.setObjectName("label_740")
self.gridLayout_104.addWidget(self.label_740, 10, 0, 1, 1)
self.label_744 = QtWidgets.QLabel(self.groupBox_58)
self.label_744.setObjectName("label_744")
self.gridLayout_104.addWidget(self.label_744, 14, 0, 1, 1)
self.label_745 = QtWidgets.QLabel(self.groupBox_58)
self.label_745.setObjectName("label_745")
self.gridLayout_104.addWidget(self.label_745, 15, 0, 1, 1)
self.label_469 = QtWidgets.QLabel(self.groupBox_58)
self.label_469.setObjectName("label_469")
self.gridLayout_104.addWidget(self.label_469, 1, 2, 1, 1)
self.ss7i73in_0 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_0.setObjectName("ss7i73in_0")
self.gridLayout_104.addWidget(self.ss7i73in_0, 0, 1, 1, 1)
self.ss7i73in_1 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_1.setObjectName("ss7i73in_1")
self.gridLayout_104.addWidget(self.ss7i73in_1, 1, 1, 1, 1)
self.ss7i73in_2 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_2.setObjectName("ss7i73in_2")
self.gridLayout_104.addWidget(self.ss7i73in_2, 2, 1, 1, 1)
self.ss7i73in_3 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_3.setObjectName("ss7i73in_3")
self.gridLayout_104.addWidget(self.ss7i73in_3, 3, 1, 1, 1)
self.ss7i73in_4 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_4.setObjectName("ss7i73in_4")
self.gridLayout_104.addWidget(self.ss7i73in_4, 4, 1, 1, 1)
self.ss7i73in_5 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_5.setObjectName("ss7i73in_5")
self.gridLayout_104.addWidget(self.ss7i73in_5, 5, 1, 1, 1)
self.ss7i73in_6 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_6.setObjectName("ss7i73in_6")
self.gridLayout_104.addWidget(self.ss7i73in_6, 6, 1, 1, 1)
self.ss7i73in_7 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_7.setObjectName("ss7i73in_7")
self.gridLayout_104.addWidget(self.ss7i73in_7, 7, 1, 1, 1)
self.ss7i73in_8 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_8.setObjectName("ss7i73in_8")
self.gridLayout_104.addWidget(self.ss7i73in_8, 8, 1, 1, 1)
self.ss7i73in_9 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_9.setObjectName("ss7i73in_9")
self.gridLayout_104.addWidget(self.ss7i73in_9, 9, 1, 1, 1)
self.ss7i73in_10 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_10.setObjectName("ss7i73in_10")
self.gridLayout_104.addWidget(self.ss7i73in_10, 10, 1, 1, 1)
self.ss7i73in_11 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_11.setObjectName("ss7i73in_11")
self.gridLayout_104.addWidget(self.ss7i73in_11, 11, 1, 1, 1)
self.ss7i73in_12 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_12.setObjectName("ss7i73in_12")
self.gridLayout_104.addWidget(self.ss7i73in_12, 12, 1, 1, 1)
self.ss7i73in_13 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_13.setObjectName("ss7i73in_13")
self.gridLayout_104.addWidget(self.ss7i73in_13, 13, 1, 1, 1)
self.ss7i73in_14 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_14.setObjectName("ss7i73in_14")
self.gridLayout_104.addWidget(self.ss7i73in_14, 14, 1, 1, 1)
self.ss7i73in_15 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73in_15.setObjectName("ss7i73in_15")
self.gridLayout_104.addWidget(self.ss7i73in_15, 15, 1, 1, 1)
self.ss7i73out_0 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73out_0.setObjectName("ss7i73out_0")
self.gridLayout_104.addWidget(self.ss7i73out_0, 0, 3, 1, 1)
self.ss7i73out_1 = QtWidgets.QPushButton(self.groupBox_58)
self.ss7i73out_1.setObjectName("ss7i73out_1")
self.gridLayout_104.addWidget(self.ss7i73out_1, 1, 3, 1, 1)
self.gridLayout_101.addWidget(self.groupBox_58, 0, 2, 2, 1)
self.groupBox_57 = QtWidgets.QGroupBox(self.groupBox_37)
self.groupBox_57.setObjectName("groupBox_57")
self.gridLayout_103 = QtWidgets.QGridLayout(self.groupBox_57)
self.gridLayout_103.setContentsMargins(8, 8, 8, 8)
self.gridLayout_103.setSpacing(5)
self.gridLayout_103.setObjectName("gridLayout_103")
self.ss7i73keylbl_0 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_0.setObjectName("ss7i73keylbl_0")
self.gridLayout_103.addWidget(self.ss7i73keylbl_0, 14, 3, 1, 1)
self.ss7i73lcdlbl_0 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73lcdlbl_0.setObjectName("ss7i73lcdlbl_0")
self.gridLayout_103.addWidget(self.ss7i73lcdlbl_0, 14, 5, 1, 1)
self.ss7i73keylbl_1 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_1.setObjectName("ss7i73keylbl_1")
self.gridLayout_103.addWidget(self.ss7i73keylbl_1, 15, 3, 1, 1)
self.ss7i73keylbl_2 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_2.setObjectName("ss7i73keylbl_2")
self.gridLayout_103.addWidget(self.ss7i73keylbl_2, 16, 3, 1, 1)
self.ss7i73keylbl_3 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_3.setObjectName("ss7i73keylbl_3")
self.gridLayout_103.addWidget(self.ss7i73keylbl_3, 17, 3, 1, 1)
self.ss7i73keylbl_4 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_4.setObjectName("ss7i73keylbl_4")
self.gridLayout_103.addWidget(self.ss7i73keylbl_4, 18, 3, 1, 1)
self.ss7i73keylbl_5 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_5.setObjectName("ss7i73keylbl_5")
self.gridLayout_103.addWidget(self.ss7i73keylbl_5, 19, 3, 1, 1)
self.ss7i73keylbl_6 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_6.setObjectName("ss7i73keylbl_6")
self.gridLayout_103.addWidget(self.ss7i73keylbl_6, 20, 3, 1, 1)
self.ss7i73keylbl_7 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_7.setObjectName("ss7i73keylbl_7")
self.gridLayout_103.addWidget(self.ss7i73keylbl_7, 21, 3, 1, 1)
self.ss7i73keylbl_8 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_8.setObjectName("ss7i73keylbl_8")
self.gridLayout_103.addWidget(self.ss7i73keylbl_8, 22, 3, 1, 1)
self.ss7i73keylbl_9 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_9.setObjectName("ss7i73keylbl_9")
self.gridLayout_103.addWidget(self.ss7i73keylbl_9, 23, 3, 1, 1)
self.ss7i73keylbl_10 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_10.setObjectName("ss7i73keylbl_10")
self.gridLayout_103.addWidget(self.ss7i73keylbl_10, 24, 3, 1, 1)
self.ss7i73keylbl_11 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_11.setObjectName("ss7i73keylbl_11")
self.gridLayout_103.addWidget(self.ss7i73keylbl_11, 25, 3, 1, 1)
self.ss7i73keylbl_12 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_12.setObjectName("ss7i73keylbl_12")
self.gridLayout_103.addWidget(self.ss7i73keylbl_12, 26, 3, 1, 1)
self.ss7i73keylbl_13 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_13.setObjectName("ss7i73keylbl_13")
self.gridLayout_103.addWidget(self.ss7i73keylbl_13, 27, 3, 1, 1)
self.ss7i73keylbl_14 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_14.setObjectName("ss7i73keylbl_14")
self.gridLayout_103.addWidget(self.ss7i73keylbl_14, 28, 3, 1, 1)
self.ss7i73keylbl_15 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73keylbl_15.setObjectName("ss7i73keylbl_15")
self.gridLayout_103.addWidget(self.ss7i73keylbl_15, 29, 3, 1, 1)
self.ss7i73lcdlbl_1 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73lcdlbl_1.setObjectName("ss7i73lcdlbl_1")
self.gridLayout_103.addWidget(self.ss7i73lcdlbl_1, 15, 5, 1, 1)
self.ss7i73lcdlbl_2 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73lcdlbl_2.setObjectName("ss7i73lcdlbl_2")
self.gridLayout_103.addWidget(self.ss7i73lcdlbl_2, 16, 5, 1, 1)
self.ss7i73lcdlbl_3 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73lcdlbl_3.setObjectName("ss7i73lcdlbl_3")
self.gridLayout_103.addWidget(self.ss7i73lcdlbl_3, 17, 5, 1, 1)
self.ss7i73lcdlbl_4 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73lcdlbl_4.setObjectName("ss7i73lcdlbl_4")
self.gridLayout_103.addWidget(self.ss7i73lcdlbl_4, 18, 5, 1, 1)
self.ss7i73lcdlbl_5 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73lcdlbl_5.setObjectName("ss7i73lcdlbl_5")
self.gridLayout_103.addWidget(self.ss7i73lcdlbl_5, 19, 5, 1, 1)
self.ss7i73lcdlbl_6 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73lcdlbl_6.setObjectName("ss7i73lcdlbl_6")
self.gridLayout_103.addWidget(self.ss7i73lcdlbl_6, 20, 5, 1, 1)
self.ss7i73lcdlbl_7 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73lcdlbl_7.setObjectName("ss7i73lcdlbl_7")
self.gridLayout_103.addWidget(self.ss7i73lcdlbl_7, 21, 5, 1, 1)
self.ss7i73lcdlbl_8 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73lcdlbl_8.setObjectName("ss7i73lcdlbl_8")
self.gridLayout_103.addWidget(self.ss7i73lcdlbl_8, 22, 5, 1, 1)
self.ss7i73lcdlbl_9 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73lcdlbl_9.setObjectName("ss7i73lcdlbl_9")
self.gridLayout_103.addWidget(self.ss7i73lcdlbl_9, 23, 5, 1, 1)
self.ss7i73lcdlbl_10 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73lcdlbl_10.setObjectName("ss7i73lcdlbl_10")
self.gridLayout_103.addWidget(self.ss7i73lcdlbl_10, 24, 5, 1, 1)
self.ss7i73lcdlbl_11 = QtWidgets.QLabel(self.groupBox_57)
self.ss7i73lcdlbl_11.setObjectName("ss7i73lcdlbl_11")
self.gridLayout_103.addWidget(self.ss7i73lcdlbl_11, 25, 5, 1, 1)
self.ss7i73key_0 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_0.setObjectName("ss7i73key_0")
self.gridLayout_103.addWidget(self.ss7i73key_0, 14, 4, 1, 1)
self.ss7i73key_1 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_1.setObjectName("ss7i73key_1")
self.gridLayout_103.addWidget(self.ss7i73key_1, 15, 4, 1, 1)
self.ss7i73key_2 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_2.setObjectName("ss7i73key_2")
self.gridLayout_103.addWidget(self.ss7i73key_2, 16, 4, 1, 1)
self.ss7i73key_3 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_3.setObjectName("ss7i73key_3")
self.gridLayout_103.addWidget(self.ss7i73key_3, 17, 4, 1, 1)
self.ss7i73key_4 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_4.setObjectName("ss7i73key_4")
self.gridLayout_103.addWidget(self.ss7i73key_4, 18, 4, 1, 1)
self.ss7i73key_5 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_5.setObjectName("ss7i73key_5")
self.gridLayout_103.addWidget(self.ss7i73key_5, 19, 4, 1, 1)
self.ss7i73key_6 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_6.setObjectName("ss7i73key_6")
self.gridLayout_103.addWidget(self.ss7i73key_6, 20, 4, 1, 1)
self.ss7i73key_7 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_7.setObjectName("ss7i73key_7")
self.gridLayout_103.addWidget(self.ss7i73key_7, 21, 4, 1, 1)
self.ss7i73key_8 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_8.setObjectName("ss7i73key_8")
self.gridLayout_103.addWidget(self.ss7i73key_8, 22, 4, 1, 1)
self.ss7i73key_9 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_9.setObjectName("ss7i73key_9")
self.gridLayout_103.addWidget(self.ss7i73key_9, 23, 4, 1, 1)
self.ss7i73key_10 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_10.setObjectName("ss7i73key_10")
self.gridLayout_103.addWidget(self.ss7i73key_10, 24, 4, 1, 1)
self.ss7i73key_11 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_11.setObjectName("ss7i73key_11")
self.gridLayout_103.addWidget(self.ss7i73key_11, 25, 4, 1, 1)
self.ss7i73key_12 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_12.setObjectName("ss7i73key_12")
self.gridLayout_103.addWidget(self.ss7i73key_12, 26, 4, 1, 1)
self.ss7i73key_13 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_13.setObjectName("ss7i73key_13")
self.gridLayout_103.addWidget(self.ss7i73key_13, 27, 4, 1, 1)
self.ss7i73key_14 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_14.setObjectName("ss7i73key_14")
self.gridLayout_103.addWidget(self.ss7i73key_14, 28, 4, 1, 1)
self.ss7i73key_15 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73key_15.setObjectName("ss7i73key_15")
self.gridLayout_103.addWidget(self.ss7i73key_15, 29, 4, 1, 1)
self.ss7i73lcd_0 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73lcd_0.setObjectName("ss7i73lcd_0")
self.gridLayout_103.addWidget(self.ss7i73lcd_0, 14, 6, 1, 1)
self.ss7i73lcd_1 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73lcd_1.setObjectName("ss7i73lcd_1")
self.gridLayout_103.addWidget(self.ss7i73lcd_1, 15, 6, 1, 1)
self.ss7i73lcd_2 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73lcd_2.setObjectName("ss7i73lcd_2")
self.gridLayout_103.addWidget(self.ss7i73lcd_2, 16, 6, 1, 1)
self.ss7i73lcd_3 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73lcd_3.setObjectName("ss7i73lcd_3")
self.gridLayout_103.addWidget(self.ss7i73lcd_3, 17, 6, 1, 1)
self.ss7i73lcd_4 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73lcd_4.setObjectName("ss7i73lcd_4")
self.gridLayout_103.addWidget(self.ss7i73lcd_4, 18, 6, 1, 1)
self.ss7i73lcd_5 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73lcd_5.setObjectName("ss7i73lcd_5")
self.gridLayout_103.addWidget(self.ss7i73lcd_5, 19, 6, 1, 1)
self.ss7i73lcd_6 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73lcd_6.setObjectName("ss7i73lcd_6")
self.gridLayout_103.addWidget(self.ss7i73lcd_6, 20, 6, 1, 1)
self.ss7i73lcd_7 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73lcd_7.setObjectName("ss7i73lcd_7")
self.gridLayout_103.addWidget(self.ss7i73lcd_7, 21, 6, 1, 1)
self.ss7i73lcd_8 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73lcd_8.setObjectName("ss7i73lcd_8")
self.gridLayout_103.addWidget(self.ss7i73lcd_8, 22, 6, 1, 1)
self.ss7i73lcd_9 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73lcd_9.setObjectName("ss7i73lcd_9")
self.gridLayout_103.addWidget(self.ss7i73lcd_9, 23, 6, 1, 1)
self.ss7i73lcd_10 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73lcd_10.setObjectName("ss7i73lcd_10")
self.gridLayout_103.addWidget(self.ss7i73lcd_10, 24, 6, 1, 1)
self.ss7i73lcd_11 = QtWidgets.QPushButton(self.groupBox_57)
self.ss7i73lcd_11.setObjectName("ss7i73lcd_11")
self.gridLayout_103.addWidget(self.ss7i73lcd_11, 25, 6, 1, 1)
self.gridLayout_101.addWidget(self.groupBox_57, 0, 0, 2, 1)
self.gridLayout_78.addWidget(self.groupBox_37, 0, 0, 1, 1)
self.smartSerialSW.addWidget(self.ss7i73)
self.ss7i84 = QtWidgets.QWidget()
self.ss7i84.setObjectName("ss7i84")
self.gridLayout_60 = QtWidgets.QGridLayout(self.ss7i84)
self.gridLayout_60.setContentsMargins(8, 8, 8, 8)
self.gridLayout_60.setSpacing(5)
self.gridLayout_60.setObjectName("gridLayout_60")
self.groupBox_22 = QtWidgets.QGroupBox(self.ss7i84)
self.groupBox_22.setObjectName("groupBox_22")
self.gridLayout_65 = QtWidgets.QGridLayout(self.groupBox_22)
self.gridLayout_65.setContentsMargins(8, 8, 8, 8)
self.gridLayout_65.setSpacing(5)
self.gridLayout_65.setObjectName("gridLayout_65")
self.groupBox_26 = QtWidgets.QGroupBox(self.groupBox_22)
self.groupBox_26.setObjectName("groupBox_26")
self.gridLayout_64 = QtWidgets.QGridLayout(self.groupBox_26)
self.gridLayout_64.setContentsMargins(8, 8, 8, 8)
self.gridLayout_64.setSpacing(5)
self.gridLayout_64.setObjectName("gridLayout_64")
self.label_460 = QtWidgets.QLabel(self.groupBox_26)
self.label_460.setAlignment(QtCore.Qt.AlignCenter)
self.label_460.setObjectName("label_460")
self.gridLayout_64.addWidget(self.label_460, 2, 0, 1, 1)
self.label_466 = QtWidgets.QLabel(self.groupBox_26)
self.label_466.setAlignment(QtCore.Qt.AlignCenter)
self.label_466.setObjectName("label_466")
self.gridLayout_64.addWidget(self.label_466, 1, 0, 1, 1)
self.label_465 = QtWidgets.QLabel(self.groupBox_26)
self.label_465.setAlignment(QtCore.Qt.AlignCenter)
self.label_465.setObjectName("label_465")
self.gridLayout_64.addWidget(self.label_465, 7, 0, 1, 1)
self.label_467 = QtWidgets.QLabel(self.groupBox_26)
self.label_467.setAlignment(QtCore.Qt.AlignCenter)
self.label_467.setObjectName("label_467")
self.gridLayout_64.addWidget(self.label_467, 0, 0, 1, 1)
self.label_463 = QtWidgets.QLabel(self.groupBox_26)
self.label_463.setAlignment(QtCore.Qt.AlignCenter)
self.label_463.setObjectName("label_463")
self.gridLayout_64.addWidget(self.label_463, 5, 0, 1, 1)
self.label_464 = QtWidgets.QLabel(self.groupBox_26)
self.label_464.setAlignment(QtCore.Qt.AlignCenter)
self.label_464.setObjectName("label_464")
self.gridLayout_64.addWidget(self.label_464, 6, 0, 1, 1)
self.label_462 = QtWidgets.QLabel(self.groupBox_26)
self.label_462.setAlignment(QtCore.Qt.AlignCenter)
self.label_462.setObjectName("label_462")
self.gridLayout_64.addWidget(self.label_462, 4, 0, 1, 1)
self.label_461 = QtWidgets.QLabel(self.groupBox_26)
self.label_461.setAlignment(QtCore.Qt.AlignCenter)
self.label_461.setObjectName("label_461")
self.gridLayout_64.addWidget(self.label_461, 3, 0, 1, 1)
self.ss7i84out_8 = QtWidgets.QPushButton(self.groupBox_26)
self.ss7i84out_8.setObjectName("ss7i84out_8")
self.gridLayout_64.addWidget(self.ss7i84out_8, 0, 1, 1, 1)
self.ss7i84out_9 = QtWidgets.QPushButton(self.groupBox_26)
self.ss7i84out_9.setObjectName("ss7i84out_9")
self.gridLayout_64.addWidget(self.ss7i84out_9, 1, 1, 1, 1)
self.ss7i84out_10 = QtWidgets.QPushButton(self.groupBox_26)
self.ss7i84out_10.setObjectName("ss7i84out_10")
self.gridLayout_64.addWidget(self.ss7i84out_10, 2, 1, 1, 1)
self.ss7i84out_11 = QtWidgets.QPushButton(self.groupBox_26)
self.ss7i84out_11.setObjectName("ss7i84out_11")
self.gridLayout_64.addWidget(self.ss7i84out_11, 3, 1, 1, 1)
self.ss7i84out_12 = QtWidgets.QPushButton(self.groupBox_26)
self.ss7i84out_12.setObjectName("ss7i84out_12")
self.gridLayout_64.addWidget(self.ss7i84out_12, 4, 1, 1, 1)
self.ss7i84out_13 = QtWidgets.QPushButton(self.groupBox_26)
self.ss7i84out_13.setObjectName("ss7i84out_13")
self.gridLayout_64.addWidget(self.ss7i84out_13, 5, 1, 1, 1)
self.ss7i84out_14 = QtWidgets.QPushButton(self.groupBox_26)
self.ss7i84out_14.setObjectName("ss7i84out_14")
self.gridLayout_64.addWidget(self.ss7i84out_14, 6, 1, 1, 1)
self.ss7i84out_15 = QtWidgets.QPushButton(self.groupBox_26)
self.ss7i84out_15.setObjectName("ss7i84out_15")
self.gridLayout_64.addWidget(self.ss7i84out_15, 7, 1, 1, 1)
self.gridLayout_65.addWidget(self.groupBox_26, 0, 3, 1, 1)
self.groupBox_23 = QtWidgets.QGroupBox(self.groupBox_22)
self.groupBox_23.setObjectName("groupBox_23")
self.gridLayout_61 = QtWidgets.QGridLayout(self.groupBox_23)
self.gridLayout_61.setContentsMargins(8, 8, 8, 8)
self.gridLayout_61.setSpacing(5)
self.gridLayout_61.setObjectName("gridLayout_61")
self.label_454 = QtWidgets.QLabel(self.groupBox_23)
self.label_454.setAlignment(QtCore.Qt.AlignCenter)
self.label_454.setObjectName("label_454")
self.gridLayout_61.addWidget(self.label_454, 2, 0, 1, 1)
self.label_455 = QtWidgets.QLabel(self.groupBox_23)
self.label_455.setAlignment(QtCore.Qt.AlignCenter)
self.label_455.setObjectName("label_455")
self.gridLayout_61.addWidget(self.label_455, 3, 0, 1, 1)
self.label_456 = QtWidgets.QLabel(self.groupBox_23)
self.label_456.setAlignment(QtCore.Qt.AlignCenter)
self.label_456.setObjectName("label_456")
self.gridLayout_61.addWidget(self.label_456, 4, 0, 1, 1)
self.label_457 = QtWidgets.QLabel(self.groupBox_23)
self.label_457.setAlignment(QtCore.Qt.AlignCenter)
self.label_457.setObjectName("label_457")
self.gridLayout_61.addWidget(self.label_457, 5, 0, 1, 1)
self.label_458 = QtWidgets.QLabel(self.groupBox_23)
self.label_458.setAlignment(QtCore.Qt.AlignCenter)
self.label_458.setObjectName("label_458")
self.gridLayout_61.addWidget(self.label_458, 6, 0, 1, 1)
self.label_459 = QtWidgets.QLabel(self.groupBox_23)
self.label_459.setAlignment(QtCore.Qt.AlignCenter)
self.label_459.setObjectName("label_459")
self.gridLayout_61.addWidget(self.label_459, 7, 0, 1, 1)
self.label_453 = QtWidgets.QLabel(self.groupBox_23)
self.label_453.setAlignment(QtCore.Qt.AlignCenter)
self.label_453.setObjectName("label_453")
self.gridLayout_61.addWidget(self.label_453, 1, 0, 1, 1)
self.label_452 = QtWidgets.QLabel(self.groupBox_23)
self.label_452.setAlignment(QtCore.Qt.AlignCenter)
self.label_452.setObjectName("label_452")
self.gridLayout_61.addWidget(self.label_452, 0, 0, 1, 1)
self.ss7i84out_0 = QtWidgets.QPushButton(self.groupBox_23)
self.ss7i84out_0.setObjectName("ss7i84out_0")
self.gridLayout_61.addWidget(self.ss7i84out_0, 0, 1, 1, 1)
self.ss7i84out_1 = QtWidgets.QPushButton(self.groupBox_23)
self.ss7i84out_1.setObjectName("ss7i84out_1")
self.gridLayout_61.addWidget(self.ss7i84out_1, 1, 1, 1, 1)
self.ss7i84out_2 = QtWidgets.QPushButton(self.groupBox_23)
self.ss7i84out_2.setObjectName("ss7i84out_2")
self.gridLayout_61.addWidget(self.ss7i84out_2, 2, 1, 1, 1)
self.ss7i84out_3 = QtWidgets.QPushButton(self.groupBox_23)
self.ss7i84out_3.setObjectName("ss7i84out_3")
self.gridLayout_61.addWidget(self.ss7i84out_3, 3, 1, 1, 1)
self.ss7i84out_4 = QtWidgets.QPushButton(self.groupBox_23)
self.ss7i84out_4.setObjectName("ss7i84out_4")
self.gridLayout_61.addWidget(self.ss7i84out_4, 4, 1, 1, 1)
self.ss7i84out_5 = QtWidgets.QPushButton(self.groupBox_23)
self.ss7i84out_5.setObjectName("ss7i84out_5")
self.gridLayout_61.addWidget(self.ss7i84out_5, 5, 1, 1, 1)
self.ss7i84out_6 = QtWidgets.QPushButton(self.groupBox_23)
self.ss7i84out_6.setObjectName("ss7i84out_6")
self.gridLayout_61.addWidget(self.ss7i84out_6, 6, 1, 1, 1)
self.ss7i84out_7 = QtWidgets.QPushButton(self.groupBox_23)
self.ss7i84out_7.setObjectName("ss7i84out_7")
self.gridLayout_61.addWidget(self.ss7i84out_7, 7, 1, 1, 1)
self.gridLayout_65.addWidget(self.groupBox_23, 0, 2, 1, 1)
spacerItem9 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_65.addItem(spacerItem9, 1, 2, 1, 1)
spacerItem10 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_65.addItem(spacerItem10, 1, 3, 1, 1)
self.groupBox_24 = QtWidgets.QGroupBox(self.groupBox_22)
self.groupBox_24.setObjectName("groupBox_24")
self.gridLayout_62 = QtWidgets.QGridLayout(self.groupBox_24)
self.gridLayout_62.setContentsMargins(8, 8, 8, 8)
self.gridLayout_62.setSpacing(5)
self.gridLayout_62.setObjectName("gridLayout_62")
self.label_434 = QtWidgets.QLabel(self.groupBox_24)
self.label_434.setAlignment(QtCore.Qt.AlignCenter)
self.label_434.setObjectName("label_434")
self.gridLayout_62.addWidget(self.label_434, 14, 0, 1, 1)
self.label_422 = QtWidgets.QLabel(self.groupBox_24)
self.label_422.setAlignment(QtCore.Qt.AlignCenter)
self.label_422.setObjectName("label_422")
self.gridLayout_62.addWidget(self.label_422, 2, 0, 1, 1)
self.label_431 = QtWidgets.QLabel(self.groupBox_24)
self.label_431.setAlignment(QtCore.Qt.AlignCenter)
self.label_431.setObjectName("label_431")
self.gridLayout_62.addWidget(self.label_431, 11, 0, 1, 1)
self.label_421 = QtWidgets.QLabel(self.groupBox_24)
self.label_421.setAlignment(QtCore.Qt.AlignCenter)
self.label_421.setObjectName("label_421")
self.gridLayout_62.addWidget(self.label_421, 1, 0, 1, 1)
self.label_427 = QtWidgets.QLabel(self.groupBox_24)
self.label_427.setAlignment(QtCore.Qt.AlignCenter)
self.label_427.setObjectName("label_427")
self.gridLayout_62.addWidget(self.label_427, 7, 0, 1, 1)
self.label_430 = QtWidgets.QLabel(self.groupBox_24)
self.label_430.setAlignment(QtCore.Qt.AlignCenter)
self.label_430.setObjectName("label_430")
self.gridLayout_62.addWidget(self.label_430, 10, 0, 1, 1)
self.label_425 = QtWidgets.QLabel(self.groupBox_24)
self.label_425.setAlignment(QtCore.Qt.AlignCenter)
self.label_425.setObjectName("label_425")
self.gridLayout_62.addWidget(self.label_425, 5, 0, 1, 1)
self.label_426 = QtWidgets.QLabel(self.groupBox_24)
self.label_426.setAlignment(QtCore.Qt.AlignCenter)
self.label_426.setObjectName("label_426")
self.gridLayout_62.addWidget(self.label_426, 6, 0, 1, 1)
self.label_429 = QtWidgets.QLabel(self.groupBox_24)
self.label_429.setAlignment(QtCore.Qt.AlignCenter)
self.label_429.setObjectName("label_429")
self.gridLayout_62.addWidget(self.label_429, 9, 0, 1, 1)
self.label_435 = QtWidgets.QLabel(self.groupBox_24)
self.label_435.setAlignment(QtCore.Qt.AlignCenter)
self.label_435.setObjectName("label_435")
self.gridLayout_62.addWidget(self.label_435, 15, 0, 1, 1)
self.label_428 = QtWidgets.QLabel(self.groupBox_24)
self.label_428.setAlignment(QtCore.Qt.AlignCenter)
self.label_428.setObjectName("label_428")
self.gridLayout_62.addWidget(self.label_428, 8, 0, 1, 1)
self.label_418 = QtWidgets.QLabel(self.groupBox_24)
self.label_418.setAlignment(QtCore.Qt.AlignCenter)
self.label_418.setObjectName("label_418")
self.gridLayout_62.addWidget(self.label_418, 0, 0, 1, 1)
self.label_423 = QtWidgets.QLabel(self.groupBox_24)
self.label_423.setAlignment(QtCore.Qt.AlignCenter)
self.label_423.setObjectName("label_423")
self.gridLayout_62.addWidget(self.label_423, 3, 0, 1, 1)
self.label_424 = QtWidgets.QLabel(self.groupBox_24)
self.label_424.setAlignment(QtCore.Qt.AlignCenter)
self.label_424.setObjectName("label_424")
self.gridLayout_62.addWidget(self.label_424, 4, 0, 1, 1)
self.label_433 = QtWidgets.QLabel(self.groupBox_24)
self.label_433.setAlignment(QtCore.Qt.AlignCenter)
self.label_433.setObjectName("label_433")
self.gridLayout_62.addWidget(self.label_433, 13, 0, 1, 1)
self.label_432 = QtWidgets.QLabel(self.groupBox_24)
self.label_432.setAlignment(QtCore.Qt.AlignCenter)
self.label_432.setObjectName("label_432")
self.gridLayout_62.addWidget(self.label_432, 12, 0, 1, 1)
self.ss7i84in_0 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_0.setObjectName("ss7i84in_0")
self.gridLayout_62.addWidget(self.ss7i84in_0, 0, 2, 1, 1)
self.ss7i84in_1 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_1.setObjectName("ss7i84in_1")
self.gridLayout_62.addWidget(self.ss7i84in_1, 1, 2, 1, 1)
self.ss7i84in_2 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_2.setObjectName("ss7i84in_2")
self.gridLayout_62.addWidget(self.ss7i84in_2, 2, 2, 1, 1)
self.ss7i84in_3 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_3.setObjectName("ss7i84in_3")
self.gridLayout_62.addWidget(self.ss7i84in_3, 3, 2, 1, 1)
self.ss7i84in_4 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_4.setObjectName("ss7i84in_4")
self.gridLayout_62.addWidget(self.ss7i84in_4, 4, 2, 1, 1)
self.ss7i84in_5 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_5.setObjectName("ss7i84in_5")
self.gridLayout_62.addWidget(self.ss7i84in_5, 5, 2, 1, 1)
self.ss7i84in_6 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_6.setObjectName("ss7i84in_6")
self.gridLayout_62.addWidget(self.ss7i84in_6, 6, 2, 1, 1)
self.ss7i84in_7 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_7.setObjectName("ss7i84in_7")
self.gridLayout_62.addWidget(self.ss7i84in_7, 7, 2, 1, 1)
self.ss7i84in_8 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_8.setObjectName("ss7i84in_8")
self.gridLayout_62.addWidget(self.ss7i84in_8, 8, 2, 1, 1)
self.ss7i84in_9 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_9.setObjectName("ss7i84in_9")
self.gridLayout_62.addWidget(self.ss7i84in_9, 9, 2, 1, 1)
self.ss7i84in_10 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_10.setObjectName("ss7i84in_10")
self.gridLayout_62.addWidget(self.ss7i84in_10, 10, 2, 1, 1)
self.ss7i84in_11 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_11.setObjectName("ss7i84in_11")
self.gridLayout_62.addWidget(self.ss7i84in_11, 11, 2, 1, 1)
self.ss7i84in_12 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_12.setObjectName("ss7i84in_12")
self.gridLayout_62.addWidget(self.ss7i84in_12, 12, 2, 1, 1)
self.ss7i84in_13 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_13.setObjectName("ss7i84in_13")
self.gridLayout_62.addWidget(self.ss7i84in_13, 13, 2, 1, 1)
self.ss7i84in_14 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_14.setObjectName("ss7i84in_14")
self.gridLayout_62.addWidget(self.ss7i84in_14, 14, 2, 1, 1)
self.ss7i84in_15 = QtWidgets.QPushButton(self.groupBox_24)
self.ss7i84in_15.setObjectName("ss7i84in_15")
self.gridLayout_62.addWidget(self.ss7i84in_15, 15, 2, 1, 1)
self.gridLayout_65.addWidget(self.groupBox_24, 0, 0, 2, 1)
self.groupBox_25 = QtWidgets.QGroupBox(self.groupBox_22)
self.groupBox_25.setObjectName("groupBox_25")
self.gridLayout_63 = QtWidgets.QGridLayout(self.groupBox_25)
self.gridLayout_63.setContentsMargins(8, 8, 8, 8)
self.gridLayout_63.setSpacing(5)
self.gridLayout_63.setObjectName("gridLayout_63")
self.label_449 = QtWidgets.QLabel(self.groupBox_25)
self.label_449.setAlignment(QtCore.Qt.AlignCenter)
self.label_449.setObjectName("label_449")
self.gridLayout_63.addWidget(self.label_449, 13, 0, 1, 1)
self.label_444 = QtWidgets.QLabel(self.groupBox_25)
self.label_444.setAlignment(QtCore.Qt.AlignCenter)
self.label_444.setObjectName("label_444")
self.gridLayout_63.addWidget(self.label_444, 8, 0, 1, 1)
self.label_448 = QtWidgets.QLabel(self.groupBox_25)
self.label_448.setAlignment(QtCore.Qt.AlignCenter)
self.label_448.setObjectName("label_448")
self.gridLayout_63.addWidget(self.label_448, 12, 0, 1, 1)
self.label_441 = QtWidgets.QLabel(self.groupBox_25)
self.label_441.setAlignment(QtCore.Qt.AlignCenter)
self.label_441.setObjectName("label_441")
self.gridLayout_63.addWidget(self.label_441, 5, 0, 1, 1)
self.label_450 = QtWidgets.QLabel(self.groupBox_25)
self.label_450.setAlignment(QtCore.Qt.AlignCenter)
self.label_450.setObjectName("label_450")
self.gridLayout_63.addWidget(self.label_450, 14, 0, 1, 1)
self.label_438 = QtWidgets.QLabel(self.groupBox_25)
self.label_438.setAlignment(QtCore.Qt.AlignCenter)
self.label_438.setObjectName("label_438")
self.gridLayout_63.addWidget(self.label_438, 2, 0, 1, 1)
self.label_439 = QtWidgets.QLabel(self.groupBox_25)
self.label_439.setAlignment(QtCore.Qt.AlignCenter)
self.label_439.setObjectName("label_439")
self.gridLayout_63.addWidget(self.label_439, 3, 0, 1, 1)
self.label_440 = QtWidgets.QLabel(self.groupBox_25)
self.label_440.setAlignment(QtCore.Qt.AlignCenter)
self.label_440.setObjectName("label_440")
self.gridLayout_63.addWidget(self.label_440, 4, 0, 1, 1)
self.label_442 = QtWidgets.QLabel(self.groupBox_25)
self.label_442.setAlignment(QtCore.Qt.AlignCenter)
self.label_442.setObjectName("label_442")
self.gridLayout_63.addWidget(self.label_442, 6, 0, 1, 1)
self.label_447 = QtWidgets.QLabel(self.groupBox_25)
self.label_447.setAlignment(QtCore.Qt.AlignCenter)
self.label_447.setObjectName("label_447")
self.gridLayout_63.addWidget(self.label_447, 11, 0, 1, 1)
self.label_436 = QtWidgets.QLabel(self.groupBox_25)
self.label_436.setAlignment(QtCore.Qt.AlignCenter)
self.label_436.setObjectName("label_436")
self.gridLayout_63.addWidget(self.label_436, 0, 0, 1, 1)
self.label_437 = QtWidgets.QLabel(self.groupBox_25)
self.label_437.setAlignment(QtCore.Qt.AlignCenter)
self.label_437.setObjectName("label_437")
self.gridLayout_63.addWidget(self.label_437, 1, 0, 1, 1)
self.label_451 = QtWidgets.QLabel(self.groupBox_25)
self.label_451.setAlignment(QtCore.Qt.AlignCenter)
self.label_451.setObjectName("label_451")
self.gridLayout_63.addWidget(self.label_451, 15, 0, 1, 1)
self.label_446 = QtWidgets.QLabel(self.groupBox_25)
self.label_446.setAlignment(QtCore.Qt.AlignCenter)
self.label_446.setObjectName("label_446")
self.gridLayout_63.addWidget(self.label_446, 10, 0, 1, 1)
self.label_443 = QtWidgets.QLabel(self.groupBox_25)
self.label_443.setAlignment(QtCore.Qt.AlignCenter)
self.label_443.setObjectName("label_443")
self.gridLayout_63.addWidget(self.label_443, 7, 0, 1, 1)
self.label_445 = QtWidgets.QLabel(self.groupBox_25)
self.label_445.setAlignment(QtCore.Qt.AlignCenter)
self.label_445.setObjectName("label_445")
self.gridLayout_63.addWidget(self.label_445, 9, 0, 1, 1)
self.ss7i84in_16 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_16.setObjectName("ss7i84in_16")
self.gridLayout_63.addWidget(self.ss7i84in_16, 0, 1, 1, 1)
self.ss7i84in_17 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_17.setObjectName("ss7i84in_17")
self.gridLayout_63.addWidget(self.ss7i84in_17, 1, 1, 1, 1)
self.ss7i84in_18 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_18.setObjectName("ss7i84in_18")
self.gridLayout_63.addWidget(self.ss7i84in_18, 2, 1, 1, 1)
self.ss7i84in_19 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_19.setObjectName("ss7i84in_19")
self.gridLayout_63.addWidget(self.ss7i84in_19, 3, 1, 1, 1)
self.ss7i84in_20 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_20.setObjectName("ss7i84in_20")
self.gridLayout_63.addWidget(self.ss7i84in_20, 4, 1, 1, 1)
self.ss7i84in_21 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_21.setObjectName("ss7i84in_21")
self.gridLayout_63.addWidget(self.ss7i84in_21, 5, 1, 1, 1)
self.ss7i84in_22 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_22.setObjectName("ss7i84in_22")
self.gridLayout_63.addWidget(self.ss7i84in_22, 6, 1, 1, 1)
self.ss7i84in_23 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_23.setObjectName("ss7i84in_23")
self.gridLayout_63.addWidget(self.ss7i84in_23, 7, 1, 1, 1)
self.ss7i84in_24 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_24.setObjectName("ss7i84in_24")
self.gridLayout_63.addWidget(self.ss7i84in_24, 8, 1, 1, 1)
self.ss7i84in_25 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_25.setObjectName("ss7i84in_25")
self.gridLayout_63.addWidget(self.ss7i84in_25, 9, 1, 1, 1)
self.ss7i84in_26 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_26.setObjectName("ss7i84in_26")
self.gridLayout_63.addWidget(self.ss7i84in_26, 10, 1, 1, 1)
self.ss7i84in_27 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_27.setObjectName("ss7i84in_27")
self.gridLayout_63.addWidget(self.ss7i84in_27, 11, 1, 1, 1)
self.ss7i84in_28 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_28.setObjectName("ss7i84in_28")
self.gridLayout_63.addWidget(self.ss7i84in_28, 12, 1, 1, 1)
self.ss7i84in_29 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_29.setObjectName("ss7i84in_29")
self.gridLayout_63.addWidget(self.ss7i84in_29, 13, 1, 1, 1)
self.ss7i84in_30 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_30.setObjectName("ss7i84in_30")
self.gridLayout_63.addWidget(self.ss7i84in_30, 14, 1, 1, 1)
self.ss7i84in_31 = QtWidgets.QPushButton(self.groupBox_25)
self.ss7i84in_31.setObjectName("ss7i84in_31")
self.gridLayout_63.addWidget(self.ss7i84in_31, 15, 1, 1, 1)
self.gridLayout_65.addWidget(self.groupBox_25, 0, 1, 2, 1)
self.gridLayout_60.addWidget(self.groupBox_22, 0, 0, 1, 1)
self.smartSerialSW.addWidget(self.ss7i84)
self.ss7i87 = QtWidgets.QWidget()
self.ss7i87.setObjectName("ss7i87")
self.gridLayout_79 = QtWidgets.QGridLayout(self.ss7i87)
self.gridLayout_79.setContentsMargins(8, 8, 8, 8)
self.gridLayout_79.setSpacing(5)
self.gridLayout_79.setObjectName("gridLayout_79")
self.groupBox_38 = QtWidgets.QGroupBox(self.ss7i87)
self.groupBox_38.setObjectName("groupBox_38")
self.gridLayout_102 = QtWidgets.QGridLayout(self.groupBox_38)
self.gridLayout_102.setContentsMargins(8, 8, 8, 8)
self.gridLayout_102.setSpacing(5)
self.gridLayout_102.setObjectName("gridLayout_102")
spacerItem11 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)
self.gridLayout_102.addItem(spacerItem11, 0, 1, 1, 1)
self.groupBox_55 = QtWidgets.QGroupBox(self.groupBox_38)
self.groupBox_55.setObjectName("groupBox_55")
self.gridLayout_100 = QtWidgets.QGridLayout(self.groupBox_55)
self.gridLayout_100.setContentsMargins(8, 8, 8, 8)
self.gridLayout_100.setSpacing(5)
self.gridLayout_100.setObjectName("gridLayout_100")
self.label_573 = QtWidgets.QLabel(self.groupBox_55)
self.label_573.setObjectName("label_573")
self.gridLayout_100.addWidget(self.label_573, 2, 0, 1, 1)
self.label_723 = QtWidgets.QLabel(self.groupBox_55)
self.label_723.setObjectName("label_723")
self.gridLayout_100.addWidget(self.label_723, 6, 0, 1, 1)
self.label_731 = QtWidgets.QLabel(self.groupBox_55)
self.label_731.setObjectName("label_731")
self.gridLayout_100.addWidget(self.label_731, 5, 0, 1, 1)
self.label_417 = QtWidgets.QLabel(self.groupBox_55)
self.label_417.setObjectName("label_417")
self.gridLayout_100.addWidget(self.label_417, 0, 0, 1, 1)
self.label_732 = QtWidgets.QLabel(self.groupBox_55)
self.label_732.setObjectName("label_732")
self.gridLayout_100.addWidget(self.label_732, 3, 0, 1, 1)
self.label_725 = QtWidgets.QLabel(self.groupBox_55)
self.label_725.setObjectName("label_725")
self.gridLayout_100.addWidget(self.label_725, 4, 0, 1, 1)
self.label_727 = QtWidgets.QLabel(self.groupBox_55)
self.label_727.setObjectName("label_727")
self.gridLayout_100.addWidget(self.label_727, 7, 0, 1, 1)
self.label_724 = QtWidgets.QLabel(self.groupBox_55)
self.label_724.setObjectName("label_724")
self.gridLayout_100.addWidget(self.label_724, 1, 0, 1, 1)
self.ss7i87in_0 = QtWidgets.QPushButton(self.groupBox_55)
self.ss7i87in_0.setObjectName("ss7i87in_0")
self.gridLayout_100.addWidget(self.ss7i87in_0, 0, 1, 1, 1)
self.ss7i87in_1 = QtWidgets.QPushButton(self.groupBox_55)
self.ss7i87in_1.setObjectName("ss7i87in_1")
self.gridLayout_100.addWidget(self.ss7i87in_1, 1, 1, 1, 1)
self.ss7i87in_2 = QtWidgets.QPushButton(self.groupBox_55)
self.ss7i87in_2.setObjectName("ss7i87in_2")
self.gridLayout_100.addWidget(self.ss7i87in_2, 2, 1, 1, 1)
self.ss7i87in_3 = QtWidgets.QPushButton(self.groupBox_55)
self.ss7i87in_3.setObjectName("ss7i87in_3")
self.gridLayout_100.addWidget(self.ss7i87in_3, 3, 1, 1, 1)
self.ss7i87in_4 = QtWidgets.QPushButton(self.groupBox_55)
self.ss7i87in_4.setObjectName("ss7i87in_4")
self.gridLayout_100.addWidget(self.ss7i87in_4, 4, 1, 1, 1)
self.ss7i87in_5 = QtWidgets.QPushButton(self.groupBox_55)
self.ss7i87in_5.setObjectName("ss7i87in_5")
self.gridLayout_100.addWidget(self.ss7i87in_5, 5, 1, 1, 1)
self.ss7i87in_6 = QtWidgets.QPushButton(self.groupBox_55)
self.ss7i87in_6.setObjectName("ss7i87in_6")
self.gridLayout_100.addWidget(self.ss7i87in_6, 6, 1, 1, 1)
self.ss7i87in_7 = QtWidgets.QPushButton(self.groupBox_55)
self.ss7i87in_7.setObjectName("ss7i87in_7")
self.gridLayout_100.addWidget(self.ss7i87in_7, 7, 1, 1, 1)
self.gridLayout_102.addWidget(self.groupBox_55, 0, 0, 1, 1)
spacerItem12 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_102.addItem(spacerItem12, 1, 0, 1, 1)
self.gridLayout_79.addWidget(self.groupBox_38, 0, 0, 1, 1)
self.smartSerialSW.addWidget(self.ss7i87)
self.gridLayout_59.addWidget(self.smartSerialSW, 1, 0, 1, 1)
self.tabWidget.addTab(self.tab_2, "")
self.options = QtWidgets.QWidget()
self.options.setObjectName("options")
self.manualToolChangeCB = QtWidgets.QCheckBox(self.options)
self.manualToolChangeCB.setGeometry(QtCore.QRect(20, 30, 351, 21))
self.manualToolChangeCB.setObjectName("manualToolChangeCB")
self.debugCB = QtWidgets.QComboBox(self.options)
self.debugCB.setGeometry(QtCore.QRect(468, 30, 241, 23))
self.debugCB.setObjectName("debugCB")
self.label_107 = QtWidgets.QLabel(self.options)
self.label_107.setGeometry(QtCore.QRect(470, 10, 101, 16))
self.label_107.setObjectName("label_107")
self.servoPeriodSB = QtWidgets.QSpinBox(self.options)
self.servoPeriodSB.setGeometry(QtCore.QRect(480, 110, 121, 24))
self.servoPeriodSB.setMaximum(2500000)
self.servoPeriodSB.setSingleStep(1000)
self.servoPeriodSB.setProperty("value", 1000000)
self.servoPeriodSB.setObjectName("servoPeriodSB")
self.label_211 = QtWidgets.QLabel(self.options)
self.label_211.setGeometry(QtCore.QRect(480, 80, 161, 16))
self.label_211.setObjectName("label_211")
self.groupBox_6 = QtWidgets.QGroupBox(self.options)
self.groupBox_6.setGeometry(QtCore.QRect(60, 210, 191, 151))
self.groupBox_6.setObjectName("groupBox_6")
self.gridLayout_51 = QtWidgets.QGridLayout(self.groupBox_6)
self.gridLayout_51.setContentsMargins(8, 15, 8, 8)
self.gridLayout_51.setSpacing(5)
self.gridLayout_51.setObjectName("gridLayout_51")
self.shutdownCB = QtWidgets.QCheckBox(self.groupBox_6)
self.shutdownCB.setObjectName("shutdownCB")
self.gridLayout_51.addWidget(self.shutdownCB, 3, 0, 1, 1)
self.customhalCB = QtWidgets.QCheckBox(self.groupBox_6)
self.customhalCB.setObjectName("customhalCB")
self.gridLayout_51.addWidget(self.customhalCB, 1, 0, 1, 1)
self.postguiCB = QtWidgets.QCheckBox(self.groupBox_6)
self.postguiCB.setObjectName("postguiCB")
self.gridLayout_51.addWidget(self.postguiCB, 2, 0, 1, 1)
self.haluiCB = QtWidgets.QCheckBox(self.groupBox_6)
self.haluiCB.setObjectName("haluiCB")
self.gridLayout_51.addWidget(self.haluiCB, 4, 0, 1, 1)
self.groupBox_10 = QtWidgets.QGroupBox(self.options)
self.groupBox_10.setGeometry(QtCore.QRect(60, 400, 164, 86))
self.groupBox_10.setObjectName("groupBox_10")
self.gridLayout_53 = QtWidgets.QGridLayout(self.groupBox_10)
self.gridLayout_53.setContentsMargins(8, 15, 8, 8)
self.gridLayout_53.setSpacing(5)
self.gridLayout_53.setObjectName("gridLayout_53")
self.pyvcpCB = QtWidgets.QCheckBox(self.groupBox_10)
self.pyvcpCB.setObjectName("pyvcpCB")
self.gridLayout_53.addWidget(self.pyvcpCB, 0, 0, 1, 1)
self.gladevcpCB = QtWidgets.QCheckBox(self.groupBox_10)
self.gladevcpCB.setObjectName("gladevcpCB")
self.gridLayout_53.addWidget(self.gladevcpCB, 1, 0, 1, 1)
self.label_359 = QtWidgets.QLabel(self.options)
self.label_359.setGeometry(QtCore.QRect(480, 140, 381, 20))
self.label_359.setObjectName("label_359")
self.groupBox_14 = QtWidgets.QGroupBox(self.options)
self.groupBox_14.setGeometry(QtCore.QRect(530, 280, 231, 111))
self.groupBox_14.setObjectName("groupBox_14")
self.gridLayout_56 = QtWidgets.QGridLayout(self.groupBox_14)
self.gridLayout_56.setContentsMargins(8, 8, 8, 8)
self.gridLayout_56.setSpacing(5)
self.gridLayout_56.setObjectName("gridLayout_56")
self.splashScreenSB = QtWidgets.QSpinBox(self.groupBox_14)
self.splashScreenSB.setObjectName("splashScreenSB")
self.gridLayout_56.addWidget(self.splashScreenSB, 1, 1, 1, 1)
self.label_360 = QtWidgets.QLabel(self.groupBox_14)
self.label_360.setObjectName("label_360")
self.gridLayout_56.addWidget(self.label_360, 1, 0, 1, 1)
self.label_361 = QtWidgets.QLabel(self.groupBox_14)
self.label_361.setObjectName("label_361")
self.gridLayout_56.addWidget(self.label_361, 0, 0, 1, 1)
self.introGraphicLE = QtWidgets.QLineEdit(self.groupBox_14)
self.introGraphicLE.setObjectName("introGraphicLE")
self.gridLayout_56.addWidget(self.introGraphicLE, 0, 1, 1, 1)
self.label_358 = QtWidgets.QLabel(self.groupBox_14)
self.label_358.setAlignment(QtCore.Qt.AlignCenter)
self.label_358.setObjectName("label_358")
self.gridLayout_56.addWidget(self.label_358, 2, 0, 1, 2)
self.groupBox1 = QtWidgets.QGroupBox(self.options)
self.groupBox1.setGeometry(QtCore.QRect(60, 100, 166, 53))
self.groupBox1.setObjectName("groupBox1")
self.gridLayout_50 = QtWidgets.QGridLayout(self.groupBox1)
self.gridLayout_50.setContentsMargins(8, 8, 8, 8)
self.gridLayout_50.setSpacing(5)
self.gridLayout_50.setObjectName("gridLayout_50")
self.noforcehomingCB = QtWidgets.QCheckBox(self.groupBox1)
self.noforcehomingCB.setObjectName("noforcehomingCB")
self.gridLayout_50.addWidget(self.noforcehomingCB, 0, 0, 1, 1)
self.tabWidget.addTab(self.options, "")
self.plc = QtWidgets.QWidget()
self.plc.setObjectName("plc")
self.ladderGB = QtWidgets.QGroupBox(self.plc)
self.ladderGB.setGeometry(QtCore.QRect(40, 30, 271, 451))
self.ladderGB.setCheckable(True)
self.ladderGB.setChecked(False)
self.ladderGB.setObjectName("ladderGB")
self.gridLayout_28 = QtWidgets.QGridLayout(self.ladderGB)
self.gridLayout_28.setContentsMargins(8, 8, 8, 8)
self.gridLayout_28.setSpacing(5)
self.gridLayout_28.setObjectName("gridLayout_28")
self.label_155 = QtWidgets.QLabel(self.ladderGB)
self.label_155.setObjectName("label_155")
self.gridLayout_28.addWidget(self.label_155, 2, 2, 1, 1)
self.label_143 = QtWidgets.QLabel(self.ladderGB)
self.label_143.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_143.setObjectName("label_143")
self.gridLayout_28.addWidget(self.label_143, 1, 0, 1, 1)
self.label_147 = QtWidgets.QLabel(self.ladderGB)
self.label_147.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_147.setObjectName("label_147")
self.gridLayout_28.addWidget(self.label_147, 6, 0, 1, 1)
self.ladderWordsSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderWordsSB.setObjectName("ladderWordsSB")
self.gridLayout_28.addWidget(self.ladderWordsSB, 3, 1, 1, 1)
self.label_153 = QtWidgets.QLabel(self.ladderGB)
self.label_153.setObjectName("label_153")
self.gridLayout_28.addWidget(self.label_153, 1, 2, 1, 1)
self.label_148 = QtWidgets.QLabel(self.ladderGB)
self.label_148.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_148.setObjectName("label_148")
self.gridLayout_28.addWidget(self.label_148, 8, 0, 1, 1)
self.ladderTimersSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderTimersSB.setObjectName("ladderTimersSB")
self.gridLayout_28.addWidget(self.ladderTimersSB, 4, 1, 1, 1)
self.ladderRungsSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderRungsSB.setMaximum(200)
self.ladderRungsSB.setObjectName("ladderRungsSB")
self.gridLayout_28.addWidget(self.ladderRungsSB, 1, 1, 1, 1)
self.label_146 = QtWidgets.QLabel(self.ladderGB)
self.label_146.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_146.setObjectName("label_146")
self.gridLayout_28.addWidget(self.label_146, 4, 0, 1, 1)
self.ladderInputsSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderInputsSB.setObjectName("ladderInputsSB")
self.gridLayout_28.addWidget(self.ladderInputsSB, 8, 1, 1, 1)
self.label_154 = QtWidgets.QLabel(self.ladderGB)
self.label_154.setObjectName("label_154")
self.gridLayout_28.addWidget(self.label_154, 0, 2, 1, 1)
self.label_157 = QtWidgets.QLabel(self.ladderGB)
self.label_157.setObjectName("label_157")
self.gridLayout_28.addWidget(self.label_157, 4, 2, 1, 1)
self.iecTimerSB = QtWidgets.QSpinBox(self.ladderGB)
self.iecTimerSB.setObjectName("iecTimerSB")
self.gridLayout_28.addWidget(self.iecTimerSB, 5, 1, 1, 1)
self.label_149 = QtWidgets.QLabel(self.ladderGB)
self.label_149.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_149.setObjectName("label_149")
self.gridLayout_28.addWidget(self.label_149, 9, 0, 1, 1)
self.label_144 = QtWidgets.QLabel(self.ladderGB)
self.label_144.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_144.setObjectName("label_144")
self.gridLayout_28.addWidget(self.label_144, 2, 0, 1, 1)
self.ladderOutputsSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderOutputsSB.setObjectName("ladderOutputsSB")
self.gridLayout_28.addWidget(self.ladderOutputsSB, 9, 1, 1, 1)
self.label_159 = QtWidgets.QLabel(self.ladderGB)
self.label_159.setObjectName("label_159")
self.gridLayout_28.addWidget(self.label_159, 5, 2, 1, 1)
self.ladderSectionsSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderSectionsSB.setObjectName("ladderSectionsSB")
self.gridLayout_28.addWidget(self.ladderSectionsSB, 11, 1, 1, 1)
self.label_165 = QtWidgets.QLabel(self.ladderGB)
self.label_165.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_165.setObjectName("label_165")
self.gridLayout_28.addWidget(self.label_165, 7, 0, 1, 1)
self.label_166 = QtWidgets.QLabel(self.ladderGB)
self.label_166.setObjectName("label_166")
self.gridLayout_28.addWidget(self.label_166, 7, 2, 1, 1)
self.label_151 = QtWidgets.QLabel(self.ladderGB)
self.label_151.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_151.setObjectName("label_151")
self.gridLayout_28.addWidget(self.label_151, 11, 0, 1, 1)
self.label_145 = QtWidgets.QLabel(self.ladderGB)
self.label_145.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_145.setObjectName("label_145")
self.gridLayout_28.addWidget(self.label_145, 3, 0, 1, 1)
self.ladderExpresionsSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderExpresionsSB.setObjectName("ladderExpresionsSB")
self.gridLayout_28.addWidget(self.ladderExpresionsSB, 10, 1, 1, 1)
self.label_161 = QtWidgets.QLabel(self.ladderGB)
self.label_161.setObjectName("label_161")
self.gridLayout_28.addWidget(self.label_161, 8, 2, 1, 1)
self.label_160 = QtWidgets.QLabel(self.ladderGB)
self.label_160.setObjectName("label_160")
self.gridLayout_28.addWidget(self.label_160, 6, 2, 1, 1)
self.ladderBitsSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderBitsSB.setObjectName("ladderBitsSB")
self.gridLayout_28.addWidget(self.ladderBitsSB, 2, 1, 1, 1)
self.ladderMonostablesSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderMonostablesSB.setObjectName("ladderMonostablesSB")
self.gridLayout_28.addWidget(self.ladderMonostablesSB, 6, 1, 1, 1)
self.label_150 = QtWidgets.QLabel(self.ladderGB)
self.label_150.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_150.setObjectName("label_150")
self.gridLayout_28.addWidget(self.label_150, 10, 0, 1, 1)
self.label_163 = QtWidgets.QLabel(self.ladderGB)
self.label_163.setObjectName("label_163")
self.gridLayout_28.addWidget(self.label_163, 10, 2, 1, 1)
self.label_162 = QtWidgets.QLabel(self.ladderGB)
self.label_162.setObjectName("label_162")
self.gridLayout_28.addWidget(self.label_162, 9, 2, 1, 1)
self.ladderCountersSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderCountersSB.setObjectName("ladderCountersSB")
self.gridLayout_28.addWidget(self.ladderCountersSB, 7, 1, 1, 1)
self.label_164 = QtWidgets.QLabel(self.ladderGB)
self.label_164.setObjectName("label_164")
self.gridLayout_28.addWidget(self.label_164, 11, 2, 1, 1)
self.label_168 = QtWidgets.QLabel(self.ladderGB)
self.label_168.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_168.setObjectName("label_168")
self.gridLayout_28.addWidget(self.label_168, 13, 0, 1, 1)
self.label_170 = QtWidgets.QLabel(self.ladderGB)
self.label_170.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_170.setObjectName("label_170")
self.gridLayout_28.addWidget(self.label_170, 15, 0, 1, 1)
self.label_158 = QtWidgets.QLabel(self.ladderGB)
self.label_158.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_158.setObjectName("label_158")
self.gridLayout_28.addWidget(self.label_158, 5, 0, 1, 1)
self.label_156 = QtWidgets.QLabel(self.ladderGB)
self.label_156.setObjectName("label_156")
self.gridLayout_28.addWidget(self.label_156, 3, 2, 1, 1)
self.label_167 = QtWidgets.QLabel(self.ladderGB)
self.label_167.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_167.setObjectName("label_167")
self.gridLayout_28.addWidget(self.label_167, 12, 0, 1, 1)
self.label_169 = QtWidgets.QLabel(self.ladderGB)
self.label_169.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_169.setObjectName("label_169")
self.gridLayout_28.addWidget(self.label_169, 14, 0, 1, 1)
self.label_171 = QtWidgets.QLabel(self.ladderGB)
self.label_171.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.label_171.setObjectName("label_171")
self.gridLayout_28.addWidget(self.label_171, 16, 0, 1, 1)
self.ladderSymbolsSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderSymbolsSB.setObjectName("ladderSymbolsSB")
self.gridLayout_28.addWidget(self.ladderSymbolsSB, 12, 1, 1, 1)
self.ladderS32InputsSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderS32InputsSB.setObjectName("ladderS32InputsSB")
self.gridLayout_28.addWidget(self.ladderS32InputsSB, 13, 1, 1, 1)
self.ladderS32OuputsSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderS32OuputsSB.setObjectName("ladderS32OuputsSB")
self.gridLayout_28.addWidget(self.ladderS32OuputsSB, 14, 1, 1, 1)
self.ladderFloatInputsSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderFloatInputsSB.setObjectName("ladderFloatInputsSB")
self.gridLayout_28.addWidget(self.ladderFloatInputsSB, 15, 1, 1, 1)
self.ladderFloatOutputsSB = QtWidgets.QSpinBox(self.ladderGB)
self.ladderFloatOutputsSB.setObjectName("ladderFloatOutputsSB")
self.gridLayout_28.addWidget(self.ladderFloatOutputsSB, 16, 1, 1, 1)
self.label_172 = QtWidgets.QLabel(self.ladderGB)
self.label_172.setObjectName("label_172")
self.gridLayout_28.addWidget(self.label_172, 12, 2, 1, 1)
self.label_173 = QtWidgets.QLabel(self.ladderGB)
self.label_173.setObjectName("label_173")
self.gridLayout_28.addWidget(self.label_173, 13, 2, 1, 1)
self.label_174 = QtWidgets.QLabel(self.ladderGB)
self.label_174.setObjectName("label_174")
self.gridLayout_28.addWidget(self.label_174, 14, 2, 1, 1)
self.label_175 = QtWidgets.QLabel(self.ladderGB)
self.label_175.setObjectName("label_175")
self.gridLayout_28.addWidget(self.label_175, 15, 2, 1, 1)
self.label_176 = QtWidgets.QLabel(self.ladderGB)
self.label_176.setObjectName("label_176")
self.gridLayout_28.addWidget(self.label_176, 16, 2, 1, 1)
self.label_177 = QtWidgets.QLabel(self.ladderGB)
self.label_177.setObjectName("label_177")
self.gridLayout_28.addWidget(self.label_177, 0, 0, 1, 1)
self.label_152 = QtWidgets.QLabel(self.plc)
self.label_152.setGeometry(QtCore.QRect(30, 490, 261, 16))
self.label_152.setObjectName("label_152")
self.tabWidget.addTab(self.plc, "")
self.pins = QtWidgets.QWidget()
self.pins.setObjectName("pins")
self.gridLayout_48 = QtWidgets.QGridLayout(self.pins)
self.gridLayout_48.setContentsMargins(8, 8, 8, 8)
self.gridLayout_48.setSpacing(5)
self.gridLayout_48.setObjectName("gridLayout_48")
self.tabWidget_2 = QtWidgets.QTabWidget(self.pins)
self.tabWidget_2.setObjectName("tabWidget_2")
self.tab_4 = QtWidgets.QWidget()
self.tab_4.setObjectName("tab_4")
self.gridLayout_122 = QtWidgets.QGridLayout(self.tab_4)
self.gridLayout_122.setContentsMargins(8, 8, 8, 8)
self.gridLayout_122.setSpacing(5)
self.gridLayout_122.setObjectName("gridLayout_122")
self.gridGroupBox_3 = QtWidgets.QGroupBox(self.tab_4)
self.gridGroupBox_3.setObjectName("gridGroupBox_3")
self.gridLayout_44 = QtWidgets.QGridLayout(self.gridGroupBox_3)
self.gridLayout_44.setContentsMargins(8, 8, 8, 8)
self.gridLayout_44.setSpacing(5)
self.gridLayout_44.setObjectName("gridLayout_44")
self.label_363 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_363.setObjectName("label_363")
self.gridLayout_44.addWidget(self.label_363, 2, 0, 1, 1)
self.label_364 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_364.setObjectName("label_364")
self.gridLayout_44.addWidget(self.label_364, 0, 0, 1, 1)
self.label_365 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_365.setObjectName("label_365")
self.gridLayout_44.addWidget(self.label_365, 8, 0, 1, 1)
self.label_366 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_366.setObjectName("label_366")
self.gridLayout_44.addWidget(self.label_366, 5, 0, 1, 1)
self.label_367 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_367.setObjectName("label_367")
self.gridLayout_44.addWidget(self.label_367, 15, 0, 1, 1)
self.label_368 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_368.setObjectName("label_368")
self.gridLayout_44.addWidget(self.label_368, 4, 0, 1, 1)
self.label_369 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_369.setObjectName("label_369")
self.gridLayout_44.addWidget(self.label_369, 11, 0, 1, 1)
self.label_370 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_370.setObjectName("label_370")
self.gridLayout_44.addWidget(self.label_370, 9, 0, 1, 1)
self.label_371 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_371.setObjectName("label_371")
self.gridLayout_44.addWidget(self.label_371, 13, 0, 1, 1)
self.label_372 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_372.setObjectName("label_372")
self.gridLayout_44.addWidget(self.label_372, 16, 0, 1, 1)
self.label_373 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_373.setObjectName("label_373")
self.gridLayout_44.addWidget(self.label_373, 6, 0, 1, 1)
self.label_374 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_374.setObjectName("label_374")
self.gridLayout_44.addWidget(self.label_374, 12, 0, 1, 1)
self.label_375 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_375.setObjectName("label_375")
self.gridLayout_44.addWidget(self.label_375, 1, 0, 1, 1)
self.label_376 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_376.setObjectName("label_376")
self.gridLayout_44.addWidget(self.label_376, 10, 0, 1, 1)
self.label_377 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_377.setObjectName("label_377")
self.gridLayout_44.addWidget(self.label_377, 3, 0, 1, 1)
self.label_378 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_378.setObjectName("label_378")
self.gridLayout_44.addWidget(self.label_378, 17, 0, 1, 1)
self.label_379 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_379.setObjectName("label_379")
self.gridLayout_44.addWidget(self.label_379, 18, 0, 1, 1)
self.label_380 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_380.setObjectName("label_380")
self.gridLayout_44.addWidget(self.label_380, 19, 0, 1, 1)
self.label_381 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_381.setObjectName("label_381")
self.gridLayout_44.addWidget(self.label_381, 20, 0, 1, 1)
self.label_382 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_382.setObjectName("label_382")
self.gridLayout_44.addWidget(self.label_382, 21, 0, 1, 1)
self.label_383 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_383.setObjectName("label_383")
self.gridLayout_44.addWidget(self.label_383, 22, 0, 1, 1)
self.label_384 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_384.setObjectName("label_384")
self.gridLayout_44.addWidget(self.label_384, 23, 0, 1, 1)
self.label_385 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_385.setObjectName("label_385")
self.gridLayout_44.addWidget(self.label_385, 14, 0, 1, 1)
self.label_386 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_386.setObjectName("label_386")
self.gridLayout_44.addWidget(self.label_386, 7, 0, 1, 1)
self.label_387 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_387.setObjectName("label_387")
self.gridLayout_44.addWidget(self.label_387, 0, 1, 1, 1)
self.label_388 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_388.setObjectName("label_388")
self.gridLayout_44.addWidget(self.label_388, 1, 1, 1, 1)
self.label_389 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_389.setObjectName("label_389")
self.gridLayout_44.addWidget(self.label_389, 2, 1, 1, 1)
self.label_390 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_390.setObjectName("label_390")
self.gridLayout_44.addWidget(self.label_390, 3, 1, 1, 1)
self.label_391 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_391.setObjectName("label_391")
self.gridLayout_44.addWidget(self.label_391, 4, 1, 1, 1)
self.label_392 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_392.setObjectName("label_392")
self.gridLayout_44.addWidget(self.label_392, 5, 1, 1, 1)
self.label_393 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_393.setObjectName("label_393")
self.gridLayout_44.addWidget(self.label_393, 6, 1, 1, 1)
self.label_394 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_394.setObjectName("label_394")
self.gridLayout_44.addWidget(self.label_394, 7, 1, 1, 1)
self.label_395 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_395.setObjectName("label_395")
self.gridLayout_44.addWidget(self.label_395, 8, 1, 1, 1)
self.label_396 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_396.setObjectName("label_396")
self.gridLayout_44.addWidget(self.label_396, 9, 1, 1, 1)
self.label_397 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_397.setObjectName("label_397")
self.gridLayout_44.addWidget(self.label_397, 10, 1, 1, 1)
self.label_398 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_398.setObjectName("label_398")
self.gridLayout_44.addWidget(self.label_398, 11, 1, 1, 1)
self.label_399 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_399.setObjectName("label_399")
self.gridLayout_44.addWidget(self.label_399, 12, 1, 1, 1)
self.label_400 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_400.setObjectName("label_400")
self.gridLayout_44.addWidget(self.label_400, 13, 1, 1, 1)
self.label_401 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_401.setObjectName("label_401")
self.gridLayout_44.addWidget(self.label_401, 14, 1, 1, 1)
self.label_402 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_402.setObjectName("label_402")
self.gridLayout_44.addWidget(self.label_402, 15, 1, 1, 1)
self.label_403 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_403.setObjectName("label_403")
self.gridLayout_44.addWidget(self.label_403, 16, 1, 1, 1)
self.label_404 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_404.setObjectName("label_404")
self.gridLayout_44.addWidget(self.label_404, 17, 1, 1, 1)
self.label_405 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_405.setObjectName("label_405")
self.gridLayout_44.addWidget(self.label_405, 18, 1, 1, 1)
self.label_406 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_406.setObjectName("label_406")
self.gridLayout_44.addWidget(self.label_406, 19, 1, 1, 1)
self.label_407 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_407.setObjectName("label_407")
self.gridLayout_44.addWidget(self.label_407, 20, 1, 1, 1)
self.label_408 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_408.setObjectName("label_408")
self.gridLayout_44.addWidget(self.label_408, 21, 1, 1, 1)
self.label_409 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_409.setObjectName("label_409")
self.gridLayout_44.addWidget(self.label_409, 22, 1, 1, 1)
self.label_410 = QtWidgets.QLabel(self.gridGroupBox_3)
self.label_410.setObjectName("label_410")
self.gridLayout_44.addWidget(self.label_410, 23, 1, 1, 1)
self.gridLayout_122.addWidget(self.gridGroupBox_3, 0, 2, 1, 1)
self.gridGroupBox_5 = QtWidgets.QGroupBox(self.tab_4)
self.gridGroupBox_5.setObjectName("gridGroupBox_5")
self.gridLayout_121 = QtWidgets.QGridLayout(self.gridGroupBox_5)
self.gridLayout_121.setContentsMargins(8, 8, 8, 8)
self.gridLayout_121.setSpacing(5)
self.gridLayout_121.setObjectName("gridLayout_121")
self.label_774 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_774.setObjectName("label_774")
self.gridLayout_121.addWidget(self.label_774, 2, 0, 1, 1)
self.label_775 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_775.setObjectName("label_775")
self.gridLayout_121.addWidget(self.label_775, 0, 0, 1, 1)
self.label_776 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_776.setObjectName("label_776")
self.gridLayout_121.addWidget(self.label_776, 8, 0, 1, 1)
self.label_777 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_777.setObjectName("label_777")
self.gridLayout_121.addWidget(self.label_777, 5, 0, 1, 1)
self.label_778 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_778.setObjectName("label_778")
self.gridLayout_121.addWidget(self.label_778, 15, 0, 1, 1)
self.label_779 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_779.setObjectName("label_779")
self.gridLayout_121.addWidget(self.label_779, 4, 0, 1, 1)
self.label_780 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_780.setObjectName("label_780")
self.gridLayout_121.addWidget(self.label_780, 11, 0, 1, 1)
self.label_781 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_781.setObjectName("label_781")
self.gridLayout_121.addWidget(self.label_781, 9, 0, 1, 1)
self.label_782 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_782.setObjectName("label_782")
self.gridLayout_121.addWidget(self.label_782, 13, 0, 1, 1)
self.label_783 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_783.setObjectName("label_783")
self.gridLayout_121.addWidget(self.label_783, 16, 0, 1, 1)
self.label_784 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_784.setObjectName("label_784")
self.gridLayout_121.addWidget(self.label_784, 6, 0, 1, 1)
self.label_785 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_785.setObjectName("label_785")
self.gridLayout_121.addWidget(self.label_785, 12, 0, 1, 1)
self.label_786 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_786.setObjectName("label_786")
self.gridLayout_121.addWidget(self.label_786, 1, 0, 1, 1)
self.label_787 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_787.setObjectName("label_787")
self.gridLayout_121.addWidget(self.label_787, 10, 0, 1, 1)
self.label_788 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_788.setObjectName("label_788")
self.gridLayout_121.addWidget(self.label_788, 3, 0, 1, 1)
self.label_789 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_789.setObjectName("label_789")
self.gridLayout_121.addWidget(self.label_789, 17, 0, 1, 1)
self.label_790 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_790.setObjectName("label_790")
self.gridLayout_121.addWidget(self.label_790, 18, 0, 1, 1)
self.label_791 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_791.setObjectName("label_791")
self.gridLayout_121.addWidget(self.label_791, 19, 0, 1, 1)
self.label_792 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_792.setObjectName("label_792")
self.gridLayout_121.addWidget(self.label_792, 20, 0, 1, 1)
self.label_793 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_793.setObjectName("label_793")
self.gridLayout_121.addWidget(self.label_793, 21, 0, 1, 1)
self.label_794 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_794.setObjectName("label_794")
self.gridLayout_121.addWidget(self.label_794, 22, 0, 1, 1)
self.label_795 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_795.setObjectName("label_795")
self.gridLayout_121.addWidget(self.label_795, 23, 0, 1, 1)
self.label_796 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_796.setObjectName("label_796")
self.gridLayout_121.addWidget(self.label_796, 14, 0, 1, 1)
self.label_797 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_797.setObjectName("label_797")
self.gridLayout_121.addWidget(self.label_797, 7, 0, 1, 1)
self.label_798 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_798.setObjectName("label_798")
self.gridLayout_121.addWidget(self.label_798, 0, 1, 1, 1)
self.label_799 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_799.setObjectName("label_799")
self.gridLayout_121.addWidget(self.label_799, 1, 1, 1, 1)
self.label_800 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_800.setObjectName("label_800")
self.gridLayout_121.addWidget(self.label_800, 2, 1, 1, 1)
self.label_801 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_801.setObjectName("label_801")
self.gridLayout_121.addWidget(self.label_801, 3, 1, 1, 1)
self.label_802 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_802.setObjectName("label_802")
self.gridLayout_121.addWidget(self.label_802, 4, 1, 1, 1)
self.label_803 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_803.setObjectName("label_803")
self.gridLayout_121.addWidget(self.label_803, 5, 1, 1, 1)
self.label_804 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_804.setObjectName("label_804")
self.gridLayout_121.addWidget(self.label_804, 6, 1, 1, 1)
self.label_805 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_805.setObjectName("label_805")
self.gridLayout_121.addWidget(self.label_805, 7, 1, 1, 1)
self.label_806 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_806.setObjectName("label_806")
self.gridLayout_121.addWidget(self.label_806, 8, 1, 1, 1)
self.label_807 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_807.setObjectName("label_807")
self.gridLayout_121.addWidget(self.label_807, 9, 1, 1, 1)
self.label_808 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_808.setObjectName("label_808")
self.gridLayout_121.addWidget(self.label_808, 10, 1, 1, 1)
self.label_809 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_809.setObjectName("label_809")
self.gridLayout_121.addWidget(self.label_809, 11, 1, 1, 1)
self.label_810 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_810.setObjectName("label_810")
self.gridLayout_121.addWidget(self.label_810, 12, 1, 1, 1)
self.label_811 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_811.setObjectName("label_811")
self.gridLayout_121.addWidget(self.label_811, 13, 1, 1, 1)
self.label_812 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_812.setObjectName("label_812")
self.gridLayout_121.addWidget(self.label_812, 14, 1, 1, 1)
self.label_813 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_813.setObjectName("label_813")
self.gridLayout_121.addWidget(self.label_813, 15, 1, 1, 1)
self.label_814 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_814.setObjectName("label_814")
self.gridLayout_121.addWidget(self.label_814, 16, 1, 1, 1)
self.label_815 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_815.setObjectName("label_815")
self.gridLayout_121.addWidget(self.label_815, 17, 1, 1, 1)
self.label_816 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_816.setObjectName("label_816")
self.gridLayout_121.addWidget(self.label_816, 18, 1, 1, 1)
self.label_817 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_817.setObjectName("label_817")
self.gridLayout_121.addWidget(self.label_817, 19, 1, 1, 1)
self.label_818 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_818.setObjectName("label_818")
self.gridLayout_121.addWidget(self.label_818, 20, 1, 1, 1)
self.label_819 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_819.setObjectName("label_819")
self.gridLayout_121.addWidget(self.label_819, 21, 1, 1, 1)
self.label_820 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_820.setObjectName("label_820")
self.gridLayout_121.addWidget(self.label_820, 22, 1, 1, 1)
self.label_821 = QtWidgets.QLabel(self.gridGroupBox_5)
self.label_821.setObjectName("label_821")
self.gridLayout_121.addWidget(self.label_821, 23, 1, 1, 1)
self.gridLayout_122.addWidget(self.gridGroupBox_5, 0, 3, 1, 1)
spacerItem13 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_122.addItem(spacerItem13, 1, 0, 1, 1)
self.gridGroupBox_2 = QtWidgets.QGroupBox(self.tab_4)
self.gridGroupBox_2.setObjectName("gridGroupBox_2")
self.gridLayout_43 = QtWidgets.QGridLayout(self.gridGroupBox_2)
self.gridLayout_43.setContentsMargins(8, 8, 8, 8)
self.gridLayout_43.setSpacing(5)
self.gridLayout_43.setObjectName("gridLayout_43")
self.label_329 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_329.setObjectName("label_329")
self.gridLayout_43.addWidget(self.label_329, 3, 0, 1, 1)
self.label_319 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_319.setObjectName("label_319")
self.gridLayout_43.addWidget(self.label_319, 15, 0, 1, 1)
self.label_351 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_351.setObjectName("label_351")
self.gridLayout_43.addWidget(self.label_351, 12, 1, 1, 1)
self.label_355 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_355.setObjectName("label_355")
self.gridLayout_43.addWidget(self.label_355, 16, 1, 1, 1)
self.label_341 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_341.setObjectName("label_341")
self.gridLayout_43.addWidget(self.label_341, 2, 1, 1, 1)
self.label_350 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_350.setObjectName("label_350")
self.gridLayout_43.addWidget(self.label_350, 11, 1, 1, 1)
self.label_362 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_362.setObjectName("label_362")
self.gridLayout_43.addWidget(self.label_362, 23, 1, 1, 1)
self.label_336 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_336.setObjectName("label_336")
self.gridLayout_43.addWidget(self.label_336, 23, 0, 1, 1)
self.label_345 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_345.setObjectName("label_345")
self.gridLayout_43.addWidget(self.label_345, 6, 1, 1, 1)
self.label_315 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_315.setObjectName("label_315")
self.gridLayout_43.addWidget(self.label_315, 2, 0, 1, 1)
self.label_340 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_340.setObjectName("label_340")
self.gridLayout_43.addWidget(self.label_340, 1, 1, 1, 1)
self.tb2p5LB = QtWidgets.QLabel(self.gridGroupBox_2)
self.tb2p5LB.setObjectName("tb2p5LB")
self.gridLayout_43.addWidget(self.tb2p5LB, 19, 1, 1, 1)
self.label_357 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_357.setObjectName("label_357")
self.gridLayout_43.addWidget(self.label_357, 18, 1, 1, 1)
self.label_325 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_325.setObjectName("label_325")
self.gridLayout_43.addWidget(self.label_325, 6, 0, 1, 1)
self.label_346 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_346.setObjectName("label_346")
self.gridLayout_43.addWidget(self.label_346, 7, 1, 1, 1)
self.label_337 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_337.setObjectName("label_337")
self.gridLayout_43.addWidget(self.label_337, 14, 0, 1, 1)
self.label_316 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_316.setObjectName("label_316")
self.gridLayout_43.addWidget(self.label_316, 0, 0, 1, 1)
self.label_354 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_354.setObjectName("label_354")
self.gridLayout_43.addWidget(self.label_354, 15, 1, 1, 1)
self.label_353 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_353.setObjectName("label_353")
self.gridLayout_43.addWidget(self.label_353, 14, 1, 1, 1)
self.label_352 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_352.setObjectName("label_352")
self.gridLayout_43.addWidget(self.label_352, 13, 1, 1, 1)
self.label_335 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_335.setObjectName("label_335")
self.gridLayout_43.addWidget(self.label_335, 22, 0, 1, 1)
self.label_317 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_317.setObjectName("label_317")
self.gridLayout_43.addWidget(self.label_317, 8, 0, 1, 1)
self.label_321 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_321.setObjectName("label_321")
self.gridLayout_43.addWidget(self.label_321, 11, 0, 1, 1)
self.label_342 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_342.setObjectName("label_342")
self.gridLayout_43.addWidget(self.label_342, 3, 1, 1, 1)
self.label_327 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_327.setObjectName("label_327")
self.gridLayout_43.addWidget(self.label_327, 1, 0, 1, 1)
self.label_330 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_330.setObjectName("label_330")
self.gridLayout_43.addWidget(self.label_330, 17, 0, 1, 1)
self.label_320 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_320.setObjectName("label_320")
self.gridLayout_43.addWidget(self.label_320, 4, 0, 1, 1)
self.label_332 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_332.setObjectName("label_332")
self.gridLayout_43.addWidget(self.label_332, 19, 0, 1, 1)
self.label_349 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_349.setObjectName("label_349")
self.gridLayout_43.addWidget(self.label_349, 10, 1, 1, 1)
self.label_324 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_324.setObjectName("label_324")
self.gridLayout_43.addWidget(self.label_324, 16, 0, 1, 1)
self.label_331 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_331.setObjectName("label_331")
self.gridLayout_43.addWidget(self.label_331, 18, 0, 1, 1)
self.label_339 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_339.setObjectName("label_339")
self.gridLayout_43.addWidget(self.label_339, 0, 1, 1, 1)
self.label_348 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_348.setObjectName("label_348")
self.gridLayout_43.addWidget(self.label_348, 9, 1, 1, 1)
self.label_343 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_343.setObjectName("label_343")
self.gridLayout_43.addWidget(self.label_343, 4, 1, 1, 1)
self.label_322 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_322.setObjectName("label_322")
self.gridLayout_43.addWidget(self.label_322, 9, 0, 1, 1)
self.label_318 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_318.setObjectName("label_318")
self.gridLayout_43.addWidget(self.label_318, 5, 0, 1, 1)
self.label_323 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_323.setObjectName("label_323")
self.gridLayout_43.addWidget(self.label_323, 13, 0, 1, 1)
self.tb2p2LB = QtWidgets.QLabel(self.gridGroupBox_2)
self.tb2p2LB.setObjectName("tb2p2LB")
self.gridLayout_43.addWidget(self.tb2p2LB, 22, 1, 1, 1)
self.tb2p3LB = QtWidgets.QLabel(self.gridGroupBox_2)
self.tb2p3LB.setObjectName("tb2p3LB")
self.gridLayout_43.addWidget(self.tb2p3LB, 21, 1, 1, 1)
self.tb2p4LB = QtWidgets.QLabel(self.gridGroupBox_2)
self.tb2p4LB.setObjectName("tb2p4LB")
self.gridLayout_43.addWidget(self.tb2p4LB, 20, 1, 1, 1)
self.label_344 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_344.setObjectName("label_344")
self.gridLayout_43.addWidget(self.label_344, 5, 1, 1, 1)
self.label_338 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_338.setObjectName("label_338")
self.gridLayout_43.addWidget(self.label_338, 7, 0, 1, 1)
self.label_334 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_334.setObjectName("label_334")
self.gridLayout_43.addWidget(self.label_334, 21, 0, 1, 1)
self.label_333 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_333.setObjectName("label_333")
self.gridLayout_43.addWidget(self.label_333, 20, 0, 1, 1)
self.label_356 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_356.setObjectName("label_356")
self.gridLayout_43.addWidget(self.label_356, 17, 1, 1, 1)
self.label_328 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_328.setObjectName("label_328")
self.gridLayout_43.addWidget(self.label_328, 10, 0, 1, 1)
self.label_326 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_326.setObjectName("label_326")
self.gridLayout_43.addWidget(self.label_326, 12, 0, 1, 1)
self.label_347 = QtWidgets.QLabel(self.gridGroupBox_2)
self.label_347.setObjectName("label_347")
self.gridLayout_43.addWidget(self.label_347, 8, 1, 1, 1)
self.gridLayout_122.addWidget(self.gridGroupBox_2, 0, 1, 1, 1)
self.gridGroupBox10 = QtWidgets.QGroupBox(self.tab_4)
self.gridGroupBox10.setObjectName("gridGroupBox10")
self.gridLayout_42 = QtWidgets.QGridLayout(self.gridGroupBox10)
self.gridLayout_42.setContentsMargins(8, 8, 8, 8)
self.gridLayout_42.setSpacing(5)
self.gridLayout_42.setObjectName("gridLayout_42")
self.label_223 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_223.setObjectName("label_223")
self.gridLayout_42.addWidget(self.label_223, 2, 0, 1, 1)
self.label_212 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_212.setObjectName("label_212")
self.gridLayout_42.addWidget(self.label_212, 0, 0, 1, 1)
self.label_275 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_275.setObjectName("label_275")
self.gridLayout_42.addWidget(self.label_275, 8, 0, 1, 1)
self.label_251 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_251.setObjectName("label_251")
self.gridLayout_42.addWidget(self.label_251, 5, 0, 1, 1)
self.label_282 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_282.setObjectName("label_282")
self.gridLayout_42.addWidget(self.label_282, 15, 0, 1, 1)
self.label_241 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_241.setObjectName("label_241")
self.gridLayout_42.addWidget(self.label_241, 4, 0, 1, 1)
self.label_278 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_278.setObjectName("label_278")
self.gridLayout_42.addWidget(self.label_278, 11, 0, 1, 1)
self.label_276 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_276.setObjectName("label_276")
self.gridLayout_42.addWidget(self.label_276, 9, 0, 1, 1)
self.label_280 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_280.setObjectName("label_280")
self.gridLayout_42.addWidget(self.label_280, 13, 0, 1, 1)
self.label_283 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_283.setObjectName("label_283")
self.gridLayout_42.addWidget(self.label_283, 16, 0, 1, 1)
self.label_261 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_261.setObjectName("label_261")
self.gridLayout_42.addWidget(self.label_261, 6, 0, 1, 1)
self.label_279 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_279.setObjectName("label_279")
self.gridLayout_42.addWidget(self.label_279, 12, 0, 1, 1)
self.label_213 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_213.setObjectName("label_213")
self.gridLayout_42.addWidget(self.label_213, 1, 0, 1, 1)
self.label_277 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_277.setObjectName("label_277")
self.gridLayout_42.addWidget(self.label_277, 10, 0, 1, 1)
self.label_231 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_231.setObjectName("label_231")
self.gridLayout_42.addWidget(self.label_231, 3, 0, 1, 1)
self.label_284 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_284.setObjectName("label_284")
self.gridLayout_42.addWidget(self.label_284, 17, 0, 1, 1)
self.label_285 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_285.setObjectName("label_285")
self.gridLayout_42.addWidget(self.label_285, 18, 0, 1, 1)
self.label_286 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_286.setObjectName("label_286")
self.gridLayout_42.addWidget(self.label_286, 19, 0, 1, 1)
self.label_287 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_287.setObjectName("label_287")
self.gridLayout_42.addWidget(self.label_287, 20, 0, 1, 1)
self.label_288 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_288.setObjectName("label_288")
self.gridLayout_42.addWidget(self.label_288, 21, 0, 1, 1)
self.label_289 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_289.setObjectName("label_289")
self.gridLayout_42.addWidget(self.label_289, 22, 0, 1, 1)
self.label_290 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_290.setObjectName("label_290")
self.gridLayout_42.addWidget(self.label_290, 23, 0, 1, 1)
self.label_281 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_281.setObjectName("label_281")
self.gridLayout_42.addWidget(self.label_281, 14, 0, 1, 1)
self.label_274 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_274.setObjectName("label_274")
self.gridLayout_42.addWidget(self.label_274, 7, 0, 1, 1)
self.label_291 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_291.setObjectName("label_291")
self.gridLayout_42.addWidget(self.label_291, 0, 1, 1, 1)
self.tb1p23LB = QtWidgets.QLabel(self.gridGroupBox10)
self.tb1p23LB.setObjectName("tb1p23LB")
self.gridLayout_42.addWidget(self.tb1p23LB, 1, 1, 1, 1)
self.tb1p22LB = QtWidgets.QLabel(self.gridGroupBox10)
self.tb1p22LB.setObjectName("tb1p22LB")
self.gridLayout_42.addWidget(self.tb1p22LB, 2, 1, 1, 1)
self.tb1p21LB = QtWidgets.QLabel(self.gridGroupBox10)
self.tb1p21LB.setObjectName("tb1p21LB")
self.gridLayout_42.addWidget(self.tb1p21LB, 3, 1, 1, 1)
self.tb1p20LB = QtWidgets.QLabel(self.gridGroupBox10)
self.tb1p20LB.setObjectName("tb1p20LB")
self.gridLayout_42.addWidget(self.tb1p20LB, 4, 1, 1, 1)
self.label_296 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_296.setObjectName("label_296")
self.gridLayout_42.addWidget(self.label_296, 5, 1, 1, 1)
self.label_297 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_297.setObjectName("label_297")
self.gridLayout_42.addWidget(self.label_297, 6, 1, 1, 1)
self.label_298 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_298.setObjectName("label_298")
self.gridLayout_42.addWidget(self.label_298, 7, 1, 1, 1)
self.label_299 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_299.setObjectName("label_299")
self.gridLayout_42.addWidget(self.label_299, 8, 1, 1, 1)
self.label_300 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_300.setObjectName("label_300")
self.gridLayout_42.addWidget(self.label_300, 9, 1, 1, 1)
self.label_301 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_301.setObjectName("label_301")
self.gridLayout_42.addWidget(self.label_301, 10, 1, 1, 1)
self.label_302 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_302.setObjectName("label_302")
self.gridLayout_42.addWidget(self.label_302, 11, 1, 1, 1)
self.label_303 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_303.setObjectName("label_303")
self.gridLayout_42.addWidget(self.label_303, 12, 1, 1, 1)
self.label_304 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_304.setObjectName("label_304")
self.gridLayout_42.addWidget(self.label_304, 13, 1, 1, 1)
self.label_305 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_305.setObjectName("label_305")
self.gridLayout_42.addWidget(self.label_305, 14, 1, 1, 1)
self.label_306 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_306.setObjectName("label_306")
self.gridLayout_42.addWidget(self.label_306, 15, 1, 1, 1)
self.label_307 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_307.setObjectName("label_307")
self.gridLayout_42.addWidget(self.label_307, 16, 1, 1, 1)
self.label_308 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_308.setObjectName("label_308")
self.gridLayout_42.addWidget(self.label_308, 17, 1, 1, 1)
self.label_309 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_309.setObjectName("label_309")
self.gridLayout_42.addWidget(self.label_309, 18, 1, 1, 1)
self.label_310 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_310.setObjectName("label_310")
self.gridLayout_42.addWidget(self.label_310, 19, 1, 1, 1)
self.label_311 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_311.setObjectName("label_311")
self.gridLayout_42.addWidget(self.label_311, 20, 1, 1, 1)
self.label_312 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_312.setObjectName("label_312")
self.gridLayout_42.addWidget(self.label_312, 21, 1, 1, 1)
self.label_313 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_313.setObjectName("label_313")
self.gridLayout_42.addWidget(self.label_313, 22, 1, 1, 1)
self.label_314 = QtWidgets.QLabel(self.gridGroupBox10)
self.label_314.setObjectName("label_314")
self.gridLayout_42.addWidget(self.label_314, 23, 1, 1, 1)
self.gridLayout_122.addWidget(self.gridGroupBox10, 0, 0, 1, 1)
self.gridGroupBox_6 = QtWidgets.QGroupBox(self.tab_4)
self.gridGroupBox_6.setObjectName("gridGroupBox_6")
self.gridLayout_123 = QtWidgets.QGridLayout(self.gridGroupBox_6)
self.gridLayout_123.setContentsMargins(8, 8, 8, 8)
self.gridLayout_123.setSpacing(5)
self.gridLayout_123.setObjectName("gridLayout_123")
self.label_822 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_822.setObjectName("label_822")
self.gridLayout_123.addWidget(self.label_822, 2, 0, 1, 1)
self.label_823 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_823.setObjectName("label_823")
self.gridLayout_123.addWidget(self.label_823, 0, 0, 1, 1)
self.label_824 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_824.setObjectName("label_824")
self.gridLayout_123.addWidget(self.label_824, 8, 0, 1, 1)
self.label_825 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_825.setObjectName("label_825")
self.gridLayout_123.addWidget(self.label_825, 5, 0, 1, 1)
self.label_826 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_826.setObjectName("label_826")
self.gridLayout_123.addWidget(self.label_826, 15, 0, 1, 1)
self.label_827 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_827.setObjectName("label_827")
self.gridLayout_123.addWidget(self.label_827, 4, 0, 1, 1)
self.label_828 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_828.setObjectName("label_828")
self.gridLayout_123.addWidget(self.label_828, 11, 0, 1, 1)
self.label_829 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_829.setObjectName("label_829")
self.gridLayout_123.addWidget(self.label_829, 9, 0, 1, 1)
self.label_830 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_830.setObjectName("label_830")
self.gridLayout_123.addWidget(self.label_830, 13, 0, 1, 1)
self.label_831 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_831.setObjectName("label_831")
self.gridLayout_123.addWidget(self.label_831, 16, 0, 1, 1)
self.label_832 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_832.setObjectName("label_832")
self.gridLayout_123.addWidget(self.label_832, 6, 0, 1, 1)
self.label_833 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_833.setObjectName("label_833")
self.gridLayout_123.addWidget(self.label_833, 12, 0, 1, 1)
self.label_834 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_834.setObjectName("label_834")
self.gridLayout_123.addWidget(self.label_834, 1, 0, 1, 1)
self.label_835 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_835.setObjectName("label_835")
self.gridLayout_123.addWidget(self.label_835, 10, 0, 1, 1)
self.label_836 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_836.setObjectName("label_836")
self.gridLayout_123.addWidget(self.label_836, 3, 0, 1, 1)
self.label_837 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_837.setObjectName("label_837")
self.gridLayout_123.addWidget(self.label_837, 17, 0, 1, 1)
self.label_838 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_838.setObjectName("label_838")
self.gridLayout_123.addWidget(self.label_838, 18, 0, 1, 1)
self.label_839 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_839.setObjectName("label_839")
self.gridLayout_123.addWidget(self.label_839, 19, 0, 1, 1)
self.label_840 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_840.setObjectName("label_840")
self.gridLayout_123.addWidget(self.label_840, 20, 0, 1, 1)
self.label_841 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_841.setObjectName("label_841")
self.gridLayout_123.addWidget(self.label_841, 21, 0, 1, 1)
self.label_842 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_842.setObjectName("label_842")
self.gridLayout_123.addWidget(self.label_842, 22, 0, 1, 1)
self.label_843 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_843.setObjectName("label_843")
self.gridLayout_123.addWidget(self.label_843, 23, 0, 1, 1)
self.label_844 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_844.setObjectName("label_844")
self.gridLayout_123.addWidget(self.label_844, 14, 0, 1, 1)
self.label_845 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_845.setObjectName("label_845")
self.gridLayout_123.addWidget(self.label_845, 7, 0, 1, 1)
self.label_846 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_846.setObjectName("label_846")
self.gridLayout_123.addWidget(self.label_846, 0, 1, 1, 1)
self.tb1p23LB_2 = QtWidgets.QLabel(self.gridGroupBox_6)
self.tb1p23LB_2.setObjectName("tb1p23LB_2")
self.gridLayout_123.addWidget(self.tb1p23LB_2, 1, 1, 1, 1)
self.tb1p22LB_2 = QtWidgets.QLabel(self.gridGroupBox_6)
self.tb1p22LB_2.setObjectName("tb1p22LB_2")
self.gridLayout_123.addWidget(self.tb1p22LB_2, 2, 1, 1, 1)
self.tb1p21LB_2 = QtWidgets.QLabel(self.gridGroupBox_6)
self.tb1p21LB_2.setObjectName("tb1p21LB_2")
self.gridLayout_123.addWidget(self.tb1p21LB_2, 3, 1, 1, 1)
self.tb1p20LB_2 = QtWidgets.QLabel(self.gridGroupBox_6)
self.tb1p20LB_2.setObjectName("tb1p20LB_2")
self.gridLayout_123.addWidget(self.tb1p20LB_2, 4, 1, 1, 1)
self.label_847 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_847.setObjectName("label_847")
self.gridLayout_123.addWidget(self.label_847, 5, 1, 1, 1)
self.label_848 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_848.setObjectName("label_848")
self.gridLayout_123.addWidget(self.label_848, 6, 1, 1, 1)
self.label_849 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_849.setObjectName("label_849")
self.gridLayout_123.addWidget(self.label_849, 7, 1, 1, 1)
self.label_850 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_850.setObjectName("label_850")
self.gridLayout_123.addWidget(self.label_850, 8, 1, 1, 1)
self.label_851 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_851.setObjectName("label_851")
self.gridLayout_123.addWidget(self.label_851, 9, 1, 1, 1)
self.label_852 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_852.setObjectName("label_852")
self.gridLayout_123.addWidget(self.label_852, 10, 1, 1, 1)
self.label_853 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_853.setObjectName("label_853")
self.gridLayout_123.addWidget(self.label_853, 11, 1, 1, 1)
self.label_854 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_854.setObjectName("label_854")
self.gridLayout_123.addWidget(self.label_854, 12, 1, 1, 1)
self.label_855 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_855.setObjectName("label_855")
self.gridLayout_123.addWidget(self.label_855, 13, 1, 1, 1)
self.label_856 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_856.setObjectName("label_856")
self.gridLayout_123.addWidget(self.label_856, 14, 1, 1, 1)
self.label_857 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_857.setObjectName("label_857")
self.gridLayout_123.addWidget(self.label_857, 15, 1, 1, 1)
self.label_858 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_858.setObjectName("label_858")
self.gridLayout_123.addWidget(self.label_858, 16, 1, 1, 1)
self.label_859 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_859.setObjectName("label_859")
self.gridLayout_123.addWidget(self.label_859, 17, 1, 1, 1)
self.label_860 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_860.setObjectName("label_860")
self.gridLayout_123.addWidget(self.label_860, 18, 1, 1, 1)
self.label_861 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_861.setObjectName("label_861")
self.gridLayout_123.addWidget(self.label_861, 19, 1, 1, 1)
self.label_862 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_862.setObjectName("label_862")
self.gridLayout_123.addWidget(self.label_862, 20, 1, 1, 1)
self.label_863 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_863.setObjectName("label_863")
self.gridLayout_123.addWidget(self.label_863, 21, 1, 1, 1)
self.label_864 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_864.setObjectName("label_864")
self.gridLayout_123.addWidget(self.label_864, 22, 1, 1, 1)
self.label_865 = QtWidgets.QLabel(self.gridGroupBox_6)
self.label_865.setObjectName("label_865")
self.gridLayout_123.addWidget(self.label_865, 23, 1, 1, 1)
self.gridLayout_122.addWidget(self.gridGroupBox_6, 0, 4, 1, 1)
self.tabWidget_2.addTab(self.tab_4, "")
self.tab_5 = QtWidgets.QWidget()
self.tab_5.setObjectName("tab_5")
self.gridLayout_54 = QtWidgets.QGridLayout(self.tab_5)
self.gridLayout_54.setContentsMargins(8, 8, 8, 8)
self.gridLayout_54.setSpacing(5)
self.gridLayout_54.setObjectName("gridLayout_54")
self.scrollArea_4 = QtWidgets.QScrollArea(self.tab_5)
self.scrollArea_4.setWidgetResizable(True)
self.scrollArea_4.setObjectName("scrollArea_4")
self.scrollAreaWidgetContents_4 = QtWidgets.QWidget()
self.scrollAreaWidgetContents_4.setGeometry(QtCore.QRect(0, 0, 936, 647))
self.scrollAreaWidgetContents_4.setObjectName("scrollAreaWidgetContents_4")
self.gridLayout_41 = QtWidgets.QGridLayout(self.scrollAreaWidgetContents_4)
self.gridLayout_41.setContentsMargins(8, 8, 8, 8)
self.gridLayout_41.setSpacing(5)
self.gridLayout_41.setObjectName("gridLayout_41")
self.pinsPTE = QtWidgets.QPlainTextEdit(self.scrollAreaWidgetContents_4)
font = QtGui.QFont()
font.setFamily("Courier")
self.pinsPTE.setFont(font)
self.pinsPTE.setObjectName("pinsPTE")
self.gridLayout_41.addWidget(self.pinsPTE, 0, 0, 1, 1)
self.cardPinsPB = QtWidgets.QPushButton(self.scrollAreaWidgetContents_4)
self.cardPinsPB.setObjectName("cardPinsPB")
self.gridLayout_41.addWidget(self.cardPinsPB, 1, 0, 1, 1)
self.scrollArea_4.setWidget(self.scrollAreaWidgetContents_4)
self.gridLayout_54.addWidget(self.scrollArea_4, 0, 0, 1, 1)
self.tabWidget_2.addTab(self.tab_5, "")
self.gridLayout_48.addWidget(self.tabWidget_2, 0, 0, 1, 1)
self.tabWidget.addTab(self.pins, "")
self.info = QtWidgets.QWidget()
self.info.setObjectName("info")
self.gridLayout_113 = QtWidgets.QGridLayout(self.info)
self.gridLayout_113.setContentsMargins(8, 8, 8, 8)
self.gridLayout_113.setSpacing(5)
self.gridLayout_113.setObjectName("gridLayout_113")
self.tabWidget_3 = QtWidgets.QTabWidget(self.info)
self.tabWidget_3.setObjectName("tabWidget_3")
self.tab_6 = QtWidgets.QWidget()
self.tab_6.setObjectName("tab_6")
self.gridLayout_114 = QtWidgets.QGridLayout(self.tab_6)
self.gridLayout_114.setContentsMargins(8, 8, 8, 8)
self.gridLayout_114.setSpacing(5)
self.gridLayout_114.setObjectName("gridLayout_114")
self.card7i97LB = QtWidgets.QLabel(self.tab_6)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.card7i97LB.sizePolicy().hasHeightForWidth())
self.card7i97LB.setSizePolicy(sizePolicy)
self.card7i97LB.setFrameShape(QtWidgets.QFrame.Box)
self.card7i97LB.setText("")
self.card7i97LB.setObjectName("card7i97LB")
self.gridLayout_114.addWidget(self.card7i97LB, 0, 0, 1, 1)
self.label_103 = QtWidgets.QLabel(self.tab_6)
self.label_103.setFrameShape(QtWidgets.QFrame.Box)
self.label_103.setObjectName("label_103")
self.gridLayout_114.addWidget(self.label_103, 1, 0, 1, 1)
self.tabWidget_3.addTab(self.tab_6, "")
self.tab_7 = QtWidgets.QWidget()
self.tab_7.setObjectName("tab_7")
self.gridLayout_52 = QtWidgets.QGridLayout(self.tab_7)
self.gridLayout_52.setContentsMargins(8, 8, 8, 8)
self.gridLayout_52.setSpacing(5)
self.gridLayout_52.setObjectName("gridLayout_52")
self.infoPTE = QtWidgets.QPlainTextEdit(self.tab_7)
self.infoPTE.setEnabled(True)
font = QtGui.QFont()
font.setFamily("Courier")
self.infoPTE.setFont(font)
self.infoPTE.setTextInteractionFlags(QtCore.Qt.TextSelectableByKeyboard|QtCore.Qt.TextSelectableByMouse)
self.infoPTE.setObjectName("infoPTE")
self.gridLayout_52.addWidget(self.infoPTE, 0, 0, 1, 3)
self.cpuPB = QtWidgets.QPushButton(self.tab_7)
self.cpuPB.setObjectName("cpuPB")
self.gridLayout_52.addWidget(self.cpuPB, 1, 0, 1, 1)
self.nicPB = QtWidgets.QPushButton(self.tab_7)
self.nicPB.setObjectName("nicPB")
self.gridLayout_52.addWidget(self.nicPB, 1, 1, 1, 1)
self.copyInfoPB = QtWidgets.QPushButton(self.tab_7)
self.copyInfoPB.setObjectName("copyInfoPB")
self.gridLayout_52.addWidget(self.copyInfoPB, 1, 2, 1, 1)
self.tabWidget_3.addTab(self.tab_7, "")
self.gridLayout_113.addWidget(self.tabWidget_3, 0, 0, 1, 1)
self.tabWidget.addTab(self.info, "")
self.pc = QtWidgets.QWidget()
self.pc.setObjectName("pc")
self.gridGroupBox11 = QtWidgets.QGroupBox(self.pc)
self.gridGroupBox11.setGeometry(QtCore.QRect(30, 20, 701, 141))
self.gridGroupBox11.setObjectName("gridGroupBox11")
self.gridLayout_39 = QtWidgets.QGridLayout(self.gridGroupBox11)
self.gridLayout_39.setContentsMargins(8, 8, 8, 8)
self.gridLayout_39.setSpacing(5)
self.gridLayout_39.setObjectName("gridLayout_39")
self.label_199 = QtWidgets.QLabel(self.gridGroupBox11)
self.label_199.setMaximumSize(QtCore.QSize(16777215, 16777215))
self.label_199.setAlignment(QtCore.Qt.AlignCenter)
self.label_199.setObjectName("label_199")
self.gridLayout_39.addWidget(self.label_199, 1, 0, 1, 2)
self.label_200 = QtWidgets.QLabel(self.gridGroupBox11)
self.label_200.setAlignment(QtCore.Qt.AlignCenter)
self.label_200.setObjectName("label_200")
self.gridLayout_39.addWidget(self.label_200, 1, 2, 1, 1)
self.calcNicPB = QtWidgets.QPushButton(self.gridGroupBox11)
self.calcNicPB.setObjectName("calcNicPB")
self.gridLayout_39.addWidget(self.calcNicPB, 2, 5, 1, 1)
self.cpuSpeedCB = QtWidgets.QComboBox(self.gridGroupBox11)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.cpuSpeedCB.sizePolicy().hasHeightForWidth())
self.cpuSpeedCB.setSizePolicy(sizePolicy)
self.cpuSpeedCB.setMaximumSize(QtCore.QSize(75, 16777215))
self.cpuSpeedCB.setObjectName("cpuSpeedCB")
self.gridLayout_39.addWidget(self.cpuSpeedCB, 2, 1, 1, 1)
self.cpuSpeedLE = QtWidgets.QLineEdit(self.gridGroupBox11)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.cpuSpeedLE.sizePolicy().hasHeightForWidth())
self.cpuSpeedLE.setSizePolicy(sizePolicy)
self.cpuSpeedLE.setMaximumSize(QtCore.QSize(250, 16777215))
self.cpuSpeedLE.setObjectName("cpuSpeedLE")
self.gridLayout_39.addWidget(self.cpuSpeedLE, 2, 0, 1, 1)
self.thresholdLB = QtWidgets.QLabel(self.gridGroupBox11)
self.thresholdLB.setFrameShape(QtWidgets.QFrame.Box)
self.thresholdLB.setText("")
self.thresholdLB.setObjectName("thresholdLB")
self.gridLayout_39.addWidget(self.thresholdLB, 2, 4, 1, 1)
self.label_206 = QtWidgets.QLabel(self.gridGroupBox11)
self.label_206.setAlignment(QtCore.Qt.AlignCenter)
self.label_206.setObjectName("label_206")
self.gridLayout_39.addWidget(self.label_206, 1, 4, 1, 1)
self.packetTimeLB = QtWidgets.QLabel(self.gridGroupBox11)
self.packetTimeLB.setFrameShape(QtWidgets.QFrame.Box)
self.packetTimeLB.setText("")
self.packetTimeLB.setObjectName("packetTimeLB")
self.gridLayout_39.addWidget(self.packetTimeLB, 2, 3, 1, 1)
self.tMaxLE = QtWidgets.QLineEdit(self.gridGroupBox11)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.tMaxLE.sizePolicy().hasHeightForWidth())
self.tMaxLE.setSizePolicy(sizePolicy)
self.tMaxLE.setMaximumSize(QtCore.QSize(250, 16777215))
self.tMaxLE.setObjectName("tMaxLE")
self.gridLayout_39.addWidget(self.tMaxLE, 2, 2, 1, 1)
self.label_203 = QtWidgets.QLabel(self.gridGroupBox11)
self.label_203.setAlignment(QtCore.Qt.AlignCenter)
self.label_203.setObjectName("label_203")
self.gridLayout_39.addWidget(self.label_203, 1, 3, 1, 1)
self.label_204 = QtWidgets.QLabel(self.gridGroupBox11)
font = QtGui.QFont()
font.setPointSize(8)
self.label_204.setFont(font)
self.label_204.setObjectName("label_204")
self.gridLayout_39.addWidget(self.label_204, 3, 3, 1, 2)
self.label_51 = QtWidgets.QLabel(self.gridGroupBox11)
self.label_51.setObjectName("label_51")
self.gridLayout_39.addWidget(self.label_51, 4, 0, 1, 2)
self.label_295 = QtWidgets.QLabel(self.gridGroupBox11)
self.label_295.setTextInteractionFlags(QtCore.Qt.LinksAccessibleByMouse|QtCore.Qt.TextSelectableByMouse)
self.label_295.setObjectName("label_295")
self.gridLayout_39.addWidget(self.label_295, 3, 0, 1, 3)
self.scrollArea_3 = QtWidgets.QScrollArea(self.pc)
self.scrollArea_3.setGeometry(QtCore.QRect(40, 290, 651, 171))
self.scrollArea_3.setWidgetResizable(True)
self.scrollArea_3.setObjectName("scrollArea_3")
self.scrollAreaWidgetContents_3 = QtWidgets.QWidget()
self.scrollAreaWidgetContents_3.setGeometry(QtCore.QRect(0, 0, 649, 169))
self.scrollAreaWidgetContents_3.setObjectName("scrollAreaWidgetContents_3")
self.gridLayout_40 = QtWidgets.QGridLayout(self.scrollAreaWidgetContents_3)
self.gridLayout_40.setContentsMargins(8, 8, 8, 8)
self.gridLayout_40.setSpacing(5)
self.gridLayout_40.setObjectName("gridLayout_40")
self.tmaxPTE = QtWidgets.QPlainTextEdit(self.scrollAreaWidgetContents_3)
font = QtGui.QFont()
font.setFamily("Courier")
self.tmaxPTE.setFont(font)
self.tmaxPTE.setObjectName("tmaxPTE")
self.gridLayout_40.addWidget(self.tmaxPTE, 0, 0, 1, 1)
self.scrollArea_3.setWidget(self.scrollAreaWidgetContents_3)
self.readTmaxPB = QtWidgets.QPushButton(self.pc)
self.readTmaxPB.setGeometry(QtCore.QRect(40, 480, 91, 23))
self.readTmaxPB.setObjectName("readTmaxPB")
self.label_210 = QtWidgets.QLabel(self.pc)
self.label_210.setGeometry(QtCore.QRect(400, 180, 331, 91))
self.label_210.setFrameShape(QtWidgets.QFrame.Box)
self.label_210.setObjectName("label_210")
self.label_294 = QtWidgets.QLabel(self.pc)
self.label_294.setGeometry(QtCore.QRect(40, 510, 421, 41))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
font.setItalic(True)
font.setWeight(75)
self.label_294.setFont(font)
self.label_294.setObjectName("label_294")
self.testMePB = QtWidgets.QPushButton(self.pc)
self.testMePB.setGeometry(QtCore.QRect(80, 200, 93, 28))
self.testMePB.setObjectName("testMePB")
self.tabWidget.addTab(self.pc, "")
self.verticalLayout.addWidget(self.tabWidget)
mainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(mainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 1000, 24))
self.menubar.setObjectName("menubar")
self.menuFile = QtWidgets.QMenu(self.menubar)
self.menuFile.setObjectName("menuFile")
self.menuTools = QtWidgets.QMenu(self.menubar)
self.menuTools.setObjectName("menuTools")
self.menuHelp = QtWidgets.QMenu(self.menubar)
self.menuHelp.setObjectName("menuHelp")
self.menuEdit = QtWidgets.QMenu(self.menubar)
self.menuEdit.setObjectName("menuEdit")
self.menuLanguage = QtWidgets.QMenu(self.menuEdit)
self.menuLanguage.setObjectName("menuLanguage")
mainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(mainWindow)
self.statusbar.setObjectName("statusbar")
mainWindow.setStatusBar(self.statusbar)
self.toolBar = QtWidgets.QToolBar(mainWindow)
self.toolBar.setObjectName("toolBar")
mainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
self.actionNew = QtWidgets.QAction(mainWindow)
self.actionNew.setObjectName("actionNew")
self.actionOpen = QtWidgets.QAction(mainWindow)
self.actionOpen.setObjectName("actionOpen")
self.actionSave = QtWidgets.QAction(mainWindow)
self.actionSave.setObjectName("actionSave")
self.actionSaveAs = QtWidgets.QAction(mainWindow)
self.actionSaveAs.setObjectName("actionSaveAs")
self.actionExit = QtWidgets.QAction(mainWindow)
self.actionExit.setObjectName("actionExit")
self.actionCheck = QtWidgets.QAction(mainWindow)
self.actionCheck.setObjectName("actionCheck")
self.actionAbout = QtWidgets.QAction(mainWindow)
self.actionAbout.setObjectName("actionAbout")
self.actionBuild = QtWidgets.QAction(mainWindow)
self.actionBuild.setObjectName("actionBuild")
self.actionTabHelp = QtWidgets.QAction(mainWindow)
self.actionTabHelp.setObjectName("actionTabHelp")
self.actionBuildHelp = QtWidgets.QAction(mainWindow)
self.actionBuildHelp.setObjectName("actionBuildHelp")
self.actionPCHelp = QtWidgets.QAction(mainWindow)
self.actionPCHelp.setObjectName("actionPCHelp")
self.actionSavePins = QtWidgets.QAction(mainWindow)
self.actionSavePins.setObjectName("actionSavePins")
self.actionSaveSignals = QtWidgets.QAction(mainWindow)
self.actionSaveSignals.setObjectName("actionSaveSignals")
self.actionSaveParameters = QtWidgets.QAction(mainWindow)
self.actionSaveParameters.setObjectName("actionSaveParameters")
self.actionOpen7i97 = QtWidgets.QAction(mainWindow)
self.actionOpen7i97.setObjectName("actionOpen7i97")
self.actionEnglish = QtWidgets.QAction(mainWindow)
self.actionEnglish.setObjectName("actionEnglish")
self.actionGerman = QtWidgets.QAction(mainWindow)
self.actionGerman.setObjectName("actionGerman")
self.menuFile.addAction(self.actionNew)
self.menuFile.addAction(self.actionOpen)
self.menuFile.addAction(self.actionOpen7i97)
self.menuFile.addAction(self.actionSave)
self.menuFile.addAction(self.actionSaveAs)
self.menuFile.addSeparator()
self.menuFile.addAction(self.actionSavePins)
self.menuFile.addAction(self.actionSaveParameters)
self.menuFile.addAction(self.actionSaveSignals)
self.menuFile.addSeparator()
self.menuFile.addAction(self.actionExit)
self.menuTools.addAction(self.actionCheck)
self.menuTools.addAction(self.actionBuild)
self.menuHelp.addAction(self.actionTabHelp)
self.menuHelp.addAction(self.actionBuildHelp)
self.menuHelp.addAction(self.actionPCHelp)
self.menuHelp.addAction(self.actionAbout)
self.menuLanguage.addAction(self.actionEnglish)
self.menuLanguage.addAction(self.actionGerman)
self.menuEdit.addAction(self.menuLanguage.menuAction())
self.menubar.addAction(self.menuFile.menuAction())
self.menubar.addAction(self.menuEdit.menuAction())
self.menubar.addAction(self.menuTools.menuAction())
self.menubar.addAction(self.menuHelp.menuAction())
self.toolBar.addAction(self.actionOpen)
self.toolBar.addAction(self.actionOpen7i97)
self.toolBar.addAction(self.actionCheck)
self.toolBar.addAction(self.actionBuild)
self.toolBar.addAction(self.actionExit)
self.retranslateUi(mainWindow)
self.tabWidget.setCurrentIndex(0)
self.jointType_3.setCurrentIndex(0)
self.smartSerialSW.setCurrentIndex(0)
self.tabWidget_2.setCurrentIndex(0)
self.tabWidget_3.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(mainWindow)
mainWindow.setTabOrder(self.configName, self.linearUnitsCB)
mainWindow.setTabOrder(self.linearUnitsCB, self.maxLinearVel)
mainWindow.setTabOrder(self.maxLinearVel, self.minLimit_0)
mainWindow.setTabOrder(self.minLimit_0, self.maxLimit_0)
mainWindow.setTabOrder(self.maxLimit_0, self.maxVelocity_0)
mainWindow.setTabOrder(self.maxVelocity_0, self.maxAccel_0)
mainWindow.setTabOrder(self.maxAccel_0, self.p_0)
mainWindow.setTabOrder(self.p_0, self.i_0)
mainWindow.setTabOrder(self.i_0, self.d_0)
mainWindow.setTabOrder(self.d_0, self.ff0_0)
mainWindow.setTabOrder(self.ff0_0, self.ff1_0)
mainWindow.setTabOrder(self.ff1_0, self.ff2_0)
mainWindow.setTabOrder(self.ff2_0, self.deadband_0)
mainWindow.setTabOrder(self.deadband_0, self.bias_0)
mainWindow.setTabOrder(self.bias_0, self.maxOutput_0)
mainWindow.setTabOrder(self.maxOutput_0, self.home_0)
mainWindow.setTabOrder(self.home_0, self.homeOffset_0)
mainWindow.setTabOrder(self.homeOffset_0, self.homeSearchVel_0)
mainWindow.setTabOrder(self.homeSearchVel_0, self.homeLatchVel_0)
mainWindow.setTabOrder(self.homeLatchVel_0, self.homeIgnoreLimits_0)
mainWindow.setTabOrder(self.homeIgnoreLimits_0, self.axisCB_1)
mainWindow.setTabOrder(self.axisCB_1, self.minLimit_1)
mainWindow.setTabOrder(self.minLimit_1, self.maxLimit_1)
mainWindow.setTabOrder(self.maxLimit_1, self.maxVelocity_1)
mainWindow.setTabOrder(self.maxVelocity_1, self.maxAccel_1)
mainWindow.setTabOrder(self.maxAccel_1, self.p_1)
mainWindow.setTabOrder(self.p_1, self.i_1)
mainWindow.setTabOrder(self.i_1, self.d_1)
mainWindow.setTabOrder(self.d_1, self.ff0_1)
mainWindow.setTabOrder(self.ff0_1, self.ff1_1)
mainWindow.setTabOrder(self.ff1_1, self.ff2_1)
mainWindow.setTabOrder(self.ff2_1, self.deadband_1)
mainWindow.setTabOrder(self.deadband_1, self.bias_1)
mainWindow.setTabOrder(self.bias_1, self.maxOutput_1)
mainWindow.setTabOrder(self.maxOutput_1, self.home_1)
mainWindow.setTabOrder(self.home_1, self.homeOffset_1)
mainWindow.setTabOrder(self.homeOffset_1, self.homeSearchVel_1)
mainWindow.setTabOrder(self.homeSearchVel_1, self.homeLatchVel_1)
mainWindow.setTabOrder(self.homeLatchVel_1, self.homeIgnoreLimits_1)
mainWindow.setTabOrder(self.homeIgnoreLimits_1, self.axisCB_2)
mainWindow.setTabOrder(self.axisCB_2, self.minLimit_2)
mainWindow.setTabOrder(self.minLimit_2, self.maxLimit_2)
mainWindow.setTabOrder(self.maxLimit_2, self.maxVelocity_2)
mainWindow.setTabOrder(self.maxVelocity_2, self.maxAccel_2)
mainWindow.setTabOrder(self.maxAccel_2, self.p_2)
mainWindow.setTabOrder(self.p_2, self.i_2)
mainWindow.setTabOrder(self.i_2, self.d_2)
mainWindow.setTabOrder(self.d_2, self.ff0_2)
mainWindow.setTabOrder(self.ff0_2, self.ff1_2)
mainWindow.setTabOrder(self.ff1_2, self.ff2_2)
mainWindow.setTabOrder(self.ff2_2, self.deadband_2)
mainWindow.setTabOrder(self.deadband_2, self.bias_2)
mainWindow.setTabOrder(self.bias_2, self.maxOutput_2)
mainWindow.setTabOrder(self.maxOutput_2, self.home_2)
mainWindow.setTabOrder(self.home_2, self.homeOffset_2)
mainWindow.setTabOrder(self.homeOffset_2, self.homeSearchVel_2)
mainWindow.setTabOrder(self.homeSearchVel_2, self.homeLatchVel_2)
mainWindow.setTabOrder(self.homeLatchVel_2, self.homeIgnoreLimits_2)
mainWindow.setTabOrder(self.homeIgnoreLimits_2, self.axisCB_3)
mainWindow.setTabOrder(self.axisCB_3, self.minLimit_3)
mainWindow.setTabOrder(self.minLimit_3, self.maxLimit_3)
mainWindow.setTabOrder(self.maxLimit_3, self.maxVelocity_3)
mainWindow.setTabOrder(self.maxVelocity_3, self.maxAccel_3)
mainWindow.setTabOrder(self.maxAccel_3, self.p_3)
mainWindow.setTabOrder(self.p_3, self.i_3)
mainWindow.setTabOrder(self.i_3, self.d_3)
mainWindow.setTabOrder(self.d_3, self.ff0_3)
mainWindow.setTabOrder(self.ff0_3, self.ff1_3)
mainWindow.setTabOrder(self.ff1_3, self.ff2_3)
mainWindow.setTabOrder(self.ff2_3, self.deadband_3)
mainWindow.setTabOrder(self.deadband_3, self.bias_3)
mainWindow.setTabOrder(self.bias_3, self.maxOutput_3)
mainWindow.setTabOrder(self.maxOutput_3, self.home_3)
mainWindow.setTabOrder(self.home_3, self.homeOffset_3)
mainWindow.setTabOrder(self.homeOffset_3, self.homeSearchVel_3)
mainWindow.setTabOrder(self.homeSearchVel_3, self.homeLatchVel_3)
mainWindow.setTabOrder(self.homeLatchVel_3, self.homeIgnoreLimits_3)
mainWindow.setTabOrder(self.homeIgnoreLimits_3, self.axisCB_4)
mainWindow.setTabOrder(self.axisCB_4, self.minLimit_4)
mainWindow.setTabOrder(self.minLimit_4, self.maxLimit_4)
mainWindow.setTabOrder(self.maxLimit_4, self.maxVelocity_4)
mainWindow.setTabOrder(self.maxVelocity_4, self.maxAccel_4)
mainWindow.setTabOrder(self.maxAccel_4, self.p_4)
mainWindow.setTabOrder(self.p_4, self.i_4)
mainWindow.setTabOrder(self.i_4, self.d_4)
mainWindow.setTabOrder(self.d_4, self.ff0_4)
mainWindow.setTabOrder(self.ff0_4, self.ff1_4)
mainWindow.setTabOrder(self.ff1_4, self.ff2_4)
mainWindow.setTabOrder(self.ff2_4, self.deadband_4)
mainWindow.setTabOrder(self.deadband_4, self.bias_4)
mainWindow.setTabOrder(self.bias_4, self.maxOutput_4)
mainWindow.setTabOrder(self.maxOutput_4, self.home_4)
mainWindow.setTabOrder(self.home_4, self.homeOffset_4)
mainWindow.setTabOrder(self.homeOffset_4, self.homeSearchVel_4)
mainWindow.setTabOrder(self.homeSearchVel_4, self.homeLatchVel_4)
mainWindow.setTabOrder(self.homeLatchVel_4, self.homeIgnoreLimits_4)
mainWindow.setTabOrder(self.homeIgnoreLimits_4, self.manualToolChangeCB)
mainWindow.setTabOrder(self.manualToolChangeCB, self.pyvcpCB)
mainWindow.setTabOrder(self.pyvcpCB, self.gladevcpCB)
mainWindow.setTabOrder(self.gladevcpCB, self.debugCB)
mainWindow.setTabOrder(self.debugCB, self.scrollArea)
mainWindow.setTabOrder(self.scrollArea, self.reloadPB)
mainWindow.setTabOrder(self.reloadPB, self.flashPB)
mainWindow.setTabOrder(self.flashPB, self.readPB)
mainWindow.setTabOrder(self.readPB, self.copyPB)
mainWindow.setTabOrder(self.copyPB, self.jointType_3)
mainWindow.setTabOrder(self.jointType_3, self.ipAddressCB)
mainWindow.setTabOrder(self.ipAddressCB, self.axisCB_0)
mainWindow.setTabOrder(self.axisCB_0, self.frontToolLatheCB)
mainWindow.setTabOrder(self.frontToolLatheCB, self.backToolLatheCB)
mainWindow.setTabOrder(self.backToolLatheCB, self.positionOffsetCB)
mainWindow.setTabOrder(self.positionOffsetCB, self.positionFeedbackCB)
mainWindow.setTabOrder(self.positionFeedbackCB, self.maxFeedOverrideSB)
mainWindow.setTabOrder(self.maxFeedOverrideSB, self.guiCB)
mainWindow.setTabOrder(self.guiCB, self.scale_0)
mainWindow.setTabOrder(self.scale_0, self.pidDefault_0)
mainWindow.setTabOrder(self.pidDefault_0, self.maxError_0)
mainWindow.setTabOrder(self.maxError_0, self.homeSequence_0)
mainWindow.setTabOrder(self.homeSequence_0, self.scale_1)
mainWindow.setTabOrder(self.scale_1, self.pidDefault_1)
mainWindow.setTabOrder(self.pidDefault_1, self.scale_2)
mainWindow.setTabOrder(self.scale_2, self.pidDefault_2)
mainWindow.setTabOrder(self.pidDefault_2, self.scale_3)
mainWindow.setTabOrder(self.scale_3, self.pidDefault_3)
mainWindow.setTabOrder(self.pidDefault_3, self.homeSequence_3)
mainWindow.setTabOrder(self.homeSequence_3, self.scale_4)
mainWindow.setTabOrder(self.scale_4, self.pidDefault_4)
mainWindow.setTabOrder(self.pidDefault_4, self.homeSequence_4)
mainWindow.setTabOrder(self.homeSequence_4, self.p_s)
mainWindow.setTabOrder(self.p_s, self.deadband_s)
mainWindow.setTabOrder(self.deadband_s, self.i_s)
mainWindow.setTabOrder(self.i_s, self.bias_s)
mainWindow.setTabOrder(self.bias_s, self.d_s)
mainWindow.setTabOrder(self.d_s, self.maxOutput_s)
mainWindow.setTabOrder(self.maxOutput_s, self.ff0_s)
mainWindow.setTabOrder(self.ff0_s, self.maxError_s)
mainWindow.setTabOrder(self.maxError_s, self.ff1_s)
mainWindow.setTabOrder(self.ff1_s, self.ff2_s)
mainWindow.setTabOrder(self.ff2_s, self.pidDefault_s)
mainWindow.setTabOrder(self.pidDefault_s, self.spindleScale)
mainWindow.setTabOrder(self.spindleScale, self.spindleTypeCB)
mainWindow.setTabOrder(self.spindleTypeCB, self.spindleMaxRpm)
mainWindow.setTabOrder(self.spindleMaxRpm, self.spindleMinRpm)
mainWindow.setTabOrder(self.spindleMinRpm, self.pwmFrequencySB)
mainWindow.setTabOrder(self.pwmFrequencySB, self.servoPeriodSB)
mainWindow.setTabOrder(self.servoPeriodSB, self.ladderGB)
mainWindow.setTabOrder(self.ladderGB, self.ladderWordsSB)
mainWindow.setTabOrder(self.ladderWordsSB, self.ladderTimersSB)
mainWindow.setTabOrder(self.ladderTimersSB, self.ladderRungsSB)
mainWindow.setTabOrder(self.ladderRungsSB, self.ladderInputsSB)
mainWindow.setTabOrder(self.ladderInputsSB, self.iecTimerSB)
mainWindow.setTabOrder(self.iecTimerSB, self.ladderOutputsSB)
mainWindow.setTabOrder(self.ladderOutputsSB, self.ladderSectionsSB)
mainWindow.setTabOrder(self.ladderSectionsSB, self.ladderExpresionsSB)
mainWindow.setTabOrder(self.ladderExpresionsSB, self.ladderBitsSB)
mainWindow.setTabOrder(self.ladderBitsSB, self.ladderMonostablesSB)
mainWindow.setTabOrder(self.ladderMonostablesSB, self.ladderCountersSB)
mainWindow.setTabOrder(self.ladderCountersSB, self.ladderSymbolsSB)
mainWindow.setTabOrder(self.ladderSymbolsSB, self.ladderS32InputsSB)
mainWindow.setTabOrder(self.ladderS32InputsSB, self.ladderS32OuputsSB)
mainWindow.setTabOrder(self.ladderS32OuputsSB, self.ladderFloatInputsSB)
mainWindow.setTabOrder(self.ladderFloatInputsSB, self.ladderFloatOutputsSB)
mainWindow.setTabOrder(self.ladderFloatOutputsSB, self.tabWidget_2)
mainWindow.setTabOrder(self.tabWidget_2, self.scrollArea_4)
mainWindow.setTabOrder(self.scrollArea_4, self.calcNicPB)
mainWindow.setTabOrder(self.calcNicPB, self.cpuSpeedCB)
mainWindow.setTabOrder(self.cpuSpeedCB, self.cpuSpeedLE)
mainWindow.setTabOrder(self.cpuSpeedLE, self.tMaxLE)
mainWindow.setTabOrder(self.tMaxLE, self.scrollArea_3)
mainWindow.setTabOrder(self.scrollArea_3, self.readTmaxPB)
def retranslateUi(self, mainWindow):
_translate = QtCore.QCoreApplication.translate
self.gridGroupBox.setTitle(_translate("mainWindow", "Machine"))
self.label_2.setText(_translate("mainWindow", "File Path"))
self.label_3.setText(_translate("mainWindow", "Linear Units"))
self.label_37.setText(_translate("mainWindow", "<html><head/><body><p>Max Linear Velocity</p></body></html>"))
self.label.setText(_translate("mainWindow", "Configuration Name"))
self.label_10.setText(_translate("mainWindow", "Coordinates"))
self.configName.setToolTip(_translate("mainWindow", "<html><head/><body><p>Any combination of letters and digits<br/>including the dash and underscore.<br/>Spaces are replaced with underscore.</p></body></html>"))
self.label_292.setText(_translate("mainWindow", "F1 for help on current tab"))
self.gridGroupBox1.setTitle(_translate("mainWindow", "Configuration Setup"))
self.label_27.setText(_translate("mainWindow", "IP Address"))
self.gridGroupBox2.setTitle(_translate("mainWindow", " Firmware"))
self.readPB.setStatusTip(_translate("mainWindow", "Read Card Pins"))
self.readPB.setText(_translate("mainWindow", "Read"))
self.reloadPB.setStatusTip(_translate("mainWindow", "Reload Firmware"))
self.reloadPB.setText(_translate("mainWindow", "Reload"))
self.copyPB.setToolTip(_translate("mainWindow", "<html><head/><body><p>Copy the Output<br/>to the clipboard</p></body></html>"))
self.copyPB.setStatusTip(_translate("mainWindow", "Copy to Clipboard"))
self.copyPB.setText(_translate("mainWindow", "Copy"))
self.firmwarePinsPB.setStatusTip(_translate("mainWindow", "View Pin File"))
self.firmwarePinsPB.setText(_translate("mainWindow", "Pins"))
self.flashPB.setStatusTip(_translate("mainWindow", "Flash Firmware"))
self.flashPB.setText(_translate("mainWindow", "Flash"))
self.verifyPB.setText(_translate("mainWindow", "Verify"))
self.groupBox_27.setTitle(_translate("mainWindow", "Backups"))
self.backupCB.setText(_translate("mainWindow", "Enable Backups"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.machine), _translate("mainWindow", "Machine"))
self.gridGroupBox3.setTitle(_translate("mainWindow", "Axis Display Options"))
self.frontToolLatheCB.setText(_translate("mainWindow", "Front Tool Lathe"))
self.backToolLatheCB.setText(_translate("mainWindow", "Back Tool Lathe"))
self.gridGroupBox4.setTitle(_translate("mainWindow", "Display"))
self.label_40.setText(_translate("mainWindow", "GUI"))
self.label_41.setText(_translate("mainWindow", "Position Offset"))
self.label_42.setText(_translate("mainWindow", "Position Feedback"))
self.label_9.setText(_translate("mainWindow", "Maximum Feed Override"))
self.label_179.setText(_translate("mainWindow", "1.0 = 100%"))
self.groupBox_60.setTitle(_translate("mainWindow", "G code Editor"))
self.groupBox_61.setTitle(_translate("mainWindow", "Default Settings"))
self.label_21.setText(_translate("mainWindow", "Default Jog Speed"))
self.defaultJogSpeedDSB.setSuffix(_translate("mainWindow", " ips"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.display), _translate("mainWindow", "Display"))
self.groupBox_2.setTitle(_translate("mainWindow", "PID Settings"))
self.label_215.setText(_translate("mainWindow", "P"))
self.label_214.setText(_translate("mainWindow", "Deadband"))
self.label_216.setText(_translate("mainWindow", "I"))
self.label_221.setText(_translate("mainWindow", "Bias"))
self.label_217.setText(_translate("mainWindow", "D"))
self.label_222.setText(_translate("mainWindow", "Max Output"))
self.label_218.setText(_translate("mainWindow", "FF0"))
self.label_219.setText(_translate("mainWindow", "FF1"))
self.label_220.setText(_translate("mainWindow", "FF2"))
self.pidDefault_0.setText(_translate("mainWindow", "Default Values"))
self.label_183.setText(_translate("mainWindow", "Max Error"))
self.jointAxisGroup_0.setTitle(_translate("mainWindow", "Axis"))
self.reverse_0.setText(_translate("mainWindow", "Reverse Dir"))
self.label_45.setText(_translate("mainWindow", "Scale"))
self.label_43.setText(_translate("mainWindow", "Axis"))
self.label_4.setText(_translate("mainWindow", "Axis Type"))
self.label_62.setText(_translate("mainWindow", "<html><head/><body><p>Minimum<br/>Limit</p></body></html>"))
self.label_67.setText(_translate("mainWindow", "Maximum Limit"))
self.label_72.setText(_translate("mainWindow", "Maximum Velocity"))
self.label_73.setText(_translate("mainWindow", "Maximum Acceleration"))
self.groupBox_3.setTitle(_translate("mainWindow", "Homing"))
self.label_83.setText(_translate("mainWindow", "Home Offset"))
self.label_38.setText(_translate("mainWindow", "Home Sequence"))
self.label_84.setText(_translate("mainWindow", "Home Search Velocity"))
self.homeOffset_0.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home Offset can be used to back off of the home switch</p></body></html>"))
self.homeIgnoreLimits_0.setText(_translate("mainWindow", "Home Ignore Limits"))
self.label_85.setText(_translate("mainWindow", "Home Latch Velocity"))
self.homeSequence_0.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home sequences start at 0 and do not skip a number.</p><p>Multiple joint axis use a negative number.</p><p>Leave blank to home the joint manually.</p></body></html>"))
self.homeSwitchShared_0.setText(_translate("mainWindow", "Home Switch is Shared"))
self.homeLatchVel_0.setToolTip(_translate("mainWindow", "<html><head/><body><p>Latch Velocity is in user units per second<br/>usually set slower than Search Velocity</p></body></html>"))
self.homeUseIndex_0.setText(_translate("mainWindow", "Home Use Index"))
self.label_82.setText(_translate("mainWindow", "Home"))
self.home_0.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home is usually set to 0</p></body></html>"))
self.homeSearchVel_0.setToolTip(_translate("mainWindow", "<html><head/><body><p>Search Velocity is in units per second</p></body></html>"))
self.label_11.setText(_translate("mainWindow", "Home Final Velocity"))
self.analogGB_0.setTitle(_translate("mainWindow", "Analog Output"))
self.label_18.setText(_translate("mainWindow", "Analog Max Limit"))
self.label_19.setText(_translate("mainWindow", "Analog Scale Max"))
self.analogDefault_0.setText(_translate("mainWindow", "Default Values"))
self.label_17.setText(_translate("mainWindow", "Analog Min Limit"))
self.gridGroupBox5.setTitle(_translate("mainWindow", "Joint Information"))
self.timeJoint_0.setText(_translate("mainWindow", "<html><head/><body><p align=\"center\"><br/></p></body></html>"))
self.label_181.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Time to accelerate<br/>to max speed</p></body></html>"))
self.label_182.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Distance to accelerate<br/>to max speed</p></body></html>"))
self.distanceJoint_0.setText(_translate("mainWindow", "<html><head/><body><p align=\"center\"><br/></p></body></html>"))
self.label_185.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Step rate at<br/>max speed</p></body></html>"))
self.stepRateJoint_0.setText(_translate("mainWindow", "<html><head/><body><p align=\"center\"><br/></p></body></html>"))
self.groupBox_4.setTitle(_translate("mainWindow", "Encoder"))
self.label_8.setText(_translate("mainWindow", "Encoder Scale"))
self.jointType_3.setTabText(self.jointType_3.indexOf(self.joint0tab), _translate("mainWindow", "Joint 0"))
self.groupBox_5.setTitle(_translate("mainWindow", "Homing"))
self.homeSwitchShared_1.setText(_translate("mainWindow", "Home Switch is Shared"))
self.label_88.setText(_translate("mainWindow", "Home Search Velocity"))
self.home_1.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home is usually set to 0</p></body></html>"))
self.label_39.setText(_translate("mainWindow", "Home Sequence"))
self.homeOffset_1.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home Offset can be used to back off of the home switch</p></body></html>"))
self.homeIgnoreLimits_1.setText(_translate("mainWindow", "Home Ignore Limits"))
self.homeUseIndex_1.setText(_translate("mainWindow", "Home Use Index"))
self.homeSearchVel_1.setToolTip(_translate("mainWindow", "<html><head/><body><p>Search Velocity is in units per second</p></body></html>"))
self.label_12.setText(_translate("mainWindow", "Home Final Velocity"))
self.homeLatchVel_1.setToolTip(_translate("mainWindow", "<html><head/><body><p>Latch Velocity is in user units per second<br/>usually set slower than Search Velocity</p></body></html>"))
self.label_86.setText(_translate("mainWindow", "Home"))
self.label_89.setText(_translate("mainWindow", "Home Latch Velocity"))
self.label_87.setText(_translate("mainWindow", "Home Offset"))
self.homeSequence_1.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home sequences start at 0 and do not skip a number.</p><p>Multiple joint axis use a negative number.</p><p>Leave blank to home the joint manually.</p></body></html>"))
self.gridGroupBox6.setTitle(_translate("mainWindow", "Joint Information"))
self.label_189.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Time to accelerate<br/>to max speed</p></body></html>"))
self.label_191.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Step rate at<br/>max speed</p></body></html>"))
self.label_190.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Distance to accelerate<br/>to max speed</p></body></html>"))
self.jointAxisGroup_1.setTitle(_translate("mainWindow", "Axis"))
self.label_75.setText(_translate("mainWindow", "Maximum Acceleration"))
self.label_63.setText(_translate("mainWindow", "<html><head/><body><p>Minimum<br/>Limit</p></body></html>"))
self.label_50.setText(_translate("mainWindow", "Axis"))
self.label_68.setText(_translate("mainWindow", "Maximum Limit"))
self.label_74.setText(_translate("mainWindow", "Maximum Velocity"))
self.label_52.setText(_translate("mainWindow", "Scale"))
self.label_5.setText(_translate("mainWindow", "Axis Type"))
self.reverse_1.setText(_translate("mainWindow", "Reverse Dir"))
self.analogGB_1.setTitle(_translate("mainWindow", "Analog Output"))
self.label_20.setText(_translate("mainWindow", "Analog Max Limit"))
self.label_22.setText(_translate("mainWindow", "Analog Scale Max"))
self.analogDefault_1.setText(_translate("mainWindow", "Default Values"))
self.label_23.setText(_translate("mainWindow", "Analog Min Limit"))
self.groupBox_7.setTitle(_translate("mainWindow", "PID Settings"))
self.label_224.setText(_translate("mainWindow", "P"))
self.label_225.setText(_translate("mainWindow", "Deadband"))
self.label_226.setText(_translate("mainWindow", "I"))
self.label_227.setText(_translate("mainWindow", "Bias"))
self.label_228.setText(_translate("mainWindow", "D"))
self.label_229.setText(_translate("mainWindow", "Max Output"))
self.label_230.setText(_translate("mainWindow", "FF0"))
self.label_232.setText(_translate("mainWindow", "FF1"))
self.label_233.setText(_translate("mainWindow", "FF2"))
self.pidDefault_1.setText(_translate("mainWindow", "Default Values"))
self.label_184.setText(_translate("mainWindow", "Max Error"))
self.groupBox_8.setTitle(_translate("mainWindow", "Encoder"))
self.label_32.setText(_translate("mainWindow", "Encoder Scale"))
self.jointType_3.setTabText(self.jointType_3.indexOf(self.joint1tab), _translate("mainWindow", "Joint 1"))
self.gridGroupBox7.setTitle(_translate("mainWindow", "Joint Information"))
self.label_196.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Distance to accelerate<br/>to max speed</p></body></html>"))
self.label_195.setText(_translate("mainWindow", "Time to accelerate\n"
"to max speed"))
self.label_197.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Step rate at<br/>max speed</p></body></html>"))
self.groupBox_9.setTitle(_translate("mainWindow", "Homing"))
self.homeIgnoreLimits_2.setText(_translate("mainWindow", "Home Ignore Limits"))
self.homeSearchVel_2.setToolTip(_translate("mainWindow", "<html><head/><body><p>Search Velocity is in units per second</p></body></html>"))
self.label_92.setText(_translate("mainWindow", "Home Search Velocity"))
self.homeOffset_2.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home Offset can be used to back off of the home switch</p></body></html>"))
self.label_13.setText(_translate("mainWindow", "Home Final Velocity"))
self.label_90.setText(_translate("mainWindow", "Home"))
self.home_2.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home is usually set to 0</p></body></html>"))
self.label_139.setText(_translate("mainWindow", "Home Sequence"))
self.label_93.setText(_translate("mainWindow", "Home Latch Velocity"))
self.homeLatchVel_2.setToolTip(_translate("mainWindow", "<html><head/><body><p>Latch Velocity is in user units per second<br/>usually set slower than Search Velocity</p></body></html>"))
self.homeUseIndex_2.setText(_translate("mainWindow", "Home Use Index"))
self.label_91.setText(_translate("mainWindow", "Home Offset"))
self.homeSwitchShared_2.setText(_translate("mainWindow", "Home Switch is Shared"))
self.homeSequence_2.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home sequences start at 0 and do not skip a number.</p><p>Multiple joint axis use a negative number.</p><p>Leave blank to home the joint manually.</p></body></html>"))
self.groupBox_11.setTitle(_translate("mainWindow", "PID Settings"))
self.label_234.setText(_translate("mainWindow", "P"))
self.label_235.setText(_translate("mainWindow", "Deadband"))
self.label_236.setText(_translate("mainWindow", "I"))
self.label_237.setText(_translate("mainWindow", "Bias"))
self.label_238.setText(_translate("mainWindow", "D"))
self.label_239.setText(_translate("mainWindow", "Max Output"))
self.label_240.setText(_translate("mainWindow", "FF0"))
self.label_242.setText(_translate("mainWindow", "FF1"))
self.label_243.setText(_translate("mainWindow", "FF2"))
self.pidDefault_2.setText(_translate("mainWindow", "Default Values"))
self.label_186.setText(_translate("mainWindow", "Max Error"))
self.jointAxisGroup_2.setTitle(_translate("mainWindow", "Axis"))
self.label_64.setText(_translate("mainWindow", "<html><head/><body><p>Minimum<br/>Limit</p></body></html>"))
self.label_53.setText(_translate("mainWindow", "Axis"))
self.label_69.setText(_translate("mainWindow", "Maximum Limit"))
self.label_76.setText(_translate("mainWindow", "Maximum Velocity"))
self.label_55.setText(_translate("mainWindow", "Scale"))
self.label_77.setText(_translate("mainWindow", "Maximum Acceleration"))
self.label_6.setText(_translate("mainWindow", "Axis Type"))
self.reverse_2.setText(_translate("mainWindow", "Reverse Dir"))
self.analogGB_2.setTitle(_translate("mainWindow", "Analog Output"))
self.label_24.setText(_translate("mainWindow", "Analog Max Limit"))
self.label_25.setText(_translate("mainWindow", "Analog Scale Max"))
self.analogDefault_2.setText(_translate("mainWindow", "Default Values"))
self.label_26.setText(_translate("mainWindow", "Analog Min Limit"))
self.groupBox_12.setTitle(_translate("mainWindow", "Encoder"))
self.label_34.setText(_translate("mainWindow", "Encoder Scale"))
self.jointType_3.setTabText(self.jointType_3.indexOf(self.joint2tab), _translate("mainWindow", "Joint 2"))
self.gridGroupBox8.setTitle(_translate("mainWindow", "Joint Information"))
self.label_201.setText(_translate("mainWindow", "Time to accelerate\n"
"to max speed"))
self.label_202.setText(_translate("mainWindow", "Distance to accelerate\n"
"to max speed"))
self.label_205.setText(_translate("mainWindow", "Step rate at\n"
"max speed"))
self.groupBox_13.setTitle(_translate("mainWindow", "Homing"))
self.label_96.setText(_translate("mainWindow", "Home Search Velocity"))
self.label_94.setText(_translate("mainWindow", "Home"))
self.homeSequence_3.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home sequences start at 0 and do not skip a number.</p><p>Multiple joint axis use a negative number.</p><p>Leave blank to home the joint manually.</p></body></html>"))
self.label_97.setText(_translate("mainWindow", "Home Latch Velocity"))
self.homeUseIndex_3.setText(_translate("mainWindow", "Home Use Index"))
self.homeIgnoreLimits_3.setText(_translate("mainWindow", "Home Ignore Limits"))
self.label_140.setText(_translate("mainWindow", "Home Sequence"))
self.homeOffset_3.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home Offset can be used to back off of the home switch</p></body></html>"))
self.homeSearchVel_3.setToolTip(_translate("mainWindow", "<html><head/><body><p>Search Velocity is in units per second</p></body></html>"))
self.homeLatchVel_3.setToolTip(_translate("mainWindow", "<html><head/><body><p>Latch Velocity is in user units per second<br/>usually set slower than Search Velocity</p></body></html>"))
self.label_14.setText(_translate("mainWindow", "Home Final Velocity"))
self.home_3.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home is usually set to 0</p></body></html>"))
self.label_95.setText(_translate("mainWindow", "Home Offset"))
self.homeSwitchShared_3.setText(_translate("mainWindow", "Home Switch is Shared"))
self.groupBox_15.setTitle(_translate("mainWindow", "PID Settings"))
self.label_244.setText(_translate("mainWindow", "P"))
self.label_245.setText(_translate("mainWindow", "Deadband"))
self.label_246.setText(_translate("mainWindow", "I"))
self.label_247.setText(_translate("mainWindow", "Bias"))
self.label_248.setText(_translate("mainWindow", "D"))
self.label_249.setText(_translate("mainWindow", "Max Output"))
self.label_250.setText(_translate("mainWindow", "FF0"))
self.label_252.setText(_translate("mainWindow", "FF1"))
self.label_253.setText(_translate("mainWindow", "FF2"))
self.pidDefault_3.setText(_translate("mainWindow", "Default Values"))
self.label_187.setText(_translate("mainWindow", "Max Error"))
self.jointAxisGroup_3.setTitle(_translate("mainWindow", "Axis"))
self.label_65.setText(_translate("mainWindow", "<html><head/><body><p>Minimum<br/>Limit</p></body></html>"))
self.label_56.setText(_translate("mainWindow", "Axis"))
self.label_70.setText(_translate("mainWindow", "Maximum Limit"))
self.label_78.setText(_translate("mainWindow", "Maximum Velocity"))
self.label_58.setText(_translate("mainWindow", "Scale"))
self.label_79.setText(_translate("mainWindow", "Maximum Acceleration"))
self.label_7.setText(_translate("mainWindow", "Axis Type"))
self.reverse_3.setText(_translate("mainWindow", "Reverse Dir"))
self.analogGB_3.setTitle(_translate("mainWindow", "Analog Output"))
self.label_28.setText(_translate("mainWindow", "Analog Max Limit"))
self.label_29.setText(_translate("mainWindow", "Analog Scale Max"))
self.analogDefault_3.setText(_translate("mainWindow", "Default Values"))
self.label_30.setText(_translate("mainWindow", "Analog Min Limit"))
self.groupBox_16.setTitle(_translate("mainWindow", "Encoder"))
self.label_49.setText(_translate("mainWindow", "Encoder Scale"))
self.jointType_3.setTabText(self.jointType_3.indexOf(self.joint3tab), _translate("mainWindow", "Joint 3"))
self.groupBox_17.setTitle(_translate("mainWindow", "Homing"))
self.label_98.setText(_translate("mainWindow", "Home"))
self.homeSearchVel_4.setToolTip(_translate("mainWindow", "<html><head/><body><p>Search Velocity is in units per second</p></body></html>"))
self.label_15.setText(_translate("mainWindow", "Home Final Velocity"))
self.label_141.setText(_translate("mainWindow", "Home Sequence"))
self.homeIgnoreLimits_4.setText(_translate("mainWindow", "Home Ignore Limits"))
self.homeSequence_4.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home sequences start at 0 and do not skip a number.</p><p>Multiple joint axis use a negative number.</p><p>Leave blank to home the joint manually.</p></body></html>"))
self.homeLatchVel_4.setToolTip(_translate("mainWindow", "<html><head/><body><p>Latch Velocity is in user units per second<br/>usually set slower than Search Velocity</p></body></html>"))
self.label_100.setText(_translate("mainWindow", "Home Search Velocity"))
self.home_4.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home is usually set to 0</p></body></html>"))
self.homeUseIndex_4.setText(_translate("mainWindow", "Home Use Index"))
self.label_99.setText(_translate("mainWindow", "Home Offset"))
self.homeOffset_4.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home Offset can be used to back off of the home switch</p></body></html>"))
self.label_101.setText(_translate("mainWindow", "Home Latch Velocity"))
self.homeSwitchShared_4.setText(_translate("mainWindow", "Home Switch is Shared"))
self.groupBox_19.setTitle(_translate("mainWindow", "PID Settings"))
self.label_254.setText(_translate("mainWindow", "P"))
self.label_255.setText(_translate("mainWindow", "Deadband"))
self.label_256.setText(_translate("mainWindow", "I"))
self.label_257.setText(_translate("mainWindow", "Bias"))
self.label_258.setText(_translate("mainWindow", "D"))
self.label_259.setText(_translate("mainWindow", "Max Output"))
self.label_260.setText(_translate("mainWindow", "FF0"))
self.label_262.setText(_translate("mainWindow", "FF1"))
self.label_263.setText(_translate("mainWindow", "FF2"))
self.pidDefault_4.setText(_translate("mainWindow", "Default Values"))
self.label_188.setText(_translate("mainWindow", "Max Error"))
self.analogGB_4.setTitle(_translate("mainWindow", "Analog Output"))
self.label_35.setText(_translate("mainWindow", "Analog Max Limit"))
self.label_36.setText(_translate("mainWindow", "Analog Scale Max"))
self.analogDefault_4.setText(_translate("mainWindow", "Default Values"))
self.label_44.setText(_translate("mainWindow", "Analog Min Limit"))
self.gridGroupBox9.setTitle(_translate("mainWindow", "Joint Information"))
self.label_207.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Time to accelerate<br/>to max speed</p></body></html>"))
self.label_208.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Distance to accelerate<br/>to max speed</p></body></html>"))
self.label_209.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Step rate at<br/>max speed</p></body></html>"))
self.jointAxisGroup_4.setTitle(_translate("mainWindow", "Axis"))
self.label_66.setText(_translate("mainWindow", "<html><head/><body><p>Minimum<br/>Limit</p></body></html>"))
self.label_59.setText(_translate("mainWindow", "Axis"))
self.label_71.setText(_translate("mainWindow", "Maximum Limit"))
self.label_80.setText(_translate("mainWindow", "Maximum Velocity"))
self.label_61.setText(_translate("mainWindow", "Scale"))
self.label_81.setText(_translate("mainWindow", "Maximum Acceleration"))
self.label_31.setText(_translate("mainWindow", "Axis Type"))
self.reverse_4.setText(_translate("mainWindow", "Reverse Dir"))
self.groupBox_20.setTitle(_translate("mainWindow", "Encoder"))
self.label_57.setText(_translate("mainWindow", "Encoder Scale"))
self.jointType_3.setTabText(self.jointType_3.indexOf(self.joint4tab), _translate("mainWindow", "Joint 4"))
self.groupBox_63.setTitle(_translate("mainWindow", "PID Settings"))
self.label_759.setText(_translate("mainWindow", "P"))
self.label_760.setText(_translate("mainWindow", "Deadband"))
self.label_761.setText(_translate("mainWindow", "I"))
self.label_762.setText(_translate("mainWindow", "Bias"))
self.label_763.setText(_translate("mainWindow", "D"))
self.label_764.setText(_translate("mainWindow", "Max Output"))
self.label_765.setText(_translate("mainWindow", "FF0"))
self.label_766.setText(_translate("mainWindow", "FF1"))
self.label_767.setText(_translate("mainWindow", "FF2"))
self.pidDefault_5.setText(_translate("mainWindow", "Default Values"))
self.label_768.setText(_translate("mainWindow", "Max Error"))
self.gridGroupBox_4.setTitle(_translate("mainWindow", "Joint Information"))
self.label_758.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Step rate at<br/>max speed</p></body></html>"))
self.label_756.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Time to accelerate<br/>to max speed</p></body></html>"))
self.label_757.setText(_translate("mainWindow", "<html><head/><body><p align=\"right\">Distance to accelerate<br/>to max speed</p></body></html>"))
self.groupBox_62.setTitle(_translate("mainWindow", "Homing"))
self.label_751.setText(_translate("mainWindow", "Home"))
self.homeSearchVel_5.setToolTip(_translate("mainWindow", "<html><head/><body><p>Search Velocity is in units per second</p></body></html>"))
self.label_16.setText(_translate("mainWindow", "Home Final Velocity"))
self.label_752.setText(_translate("mainWindow", "Home Sequence"))
self.homeIgnoreLimits_5.setText(_translate("mainWindow", "Home Ignore Limits"))
self.homeSequence_5.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home sequences start at 0 and do not skip a number.</p><p>Multiple joint axis use a negative number.</p><p>Leave blank to home the joint manually.</p></body></html>"))
self.homeLatchVel_5.setToolTip(_translate("mainWindow", "<html><head/><body><p>Latch Velocity is in user units per second<br/>usually set slower than Search Velocity</p></body></html>"))
self.label_753.setText(_translate("mainWindow", "Home Search Velocity"))
self.home_5.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home is usually set to 0</p></body></html>"))
self.homeUseIndex_5.setText(_translate("mainWindow", "Home Use Index"))
self.label_754.setText(_translate("mainWindow", "Home Offset"))
self.homeOffset_5.setToolTip(_translate("mainWindow", "<html><head/><body><p>Home Offset can be used to back off of the home switch</p></body></html>"))
self.label_755.setText(_translate("mainWindow", "Home Latch Velocity"))
self.homeSwitchShared_5.setText(_translate("mainWindow", "Home Switch is Shared"))
self.jointAxisGroup_5.setTitle(_translate("mainWindow", "Axis"))
self.label_293.setText(_translate("mainWindow", "<html><head/><body><p>Minimum<br/>Limit</p></body></html>"))
self.label_419.setText(_translate("mainWindow", "Axis"))
self.label_747.setText(_translate("mainWindow", "Maximum Limit"))
self.label_748.setText(_translate("mainWindow", "Maximum Velocity"))
self.label_749.setText(_translate("mainWindow", "Scale"))
self.label_750.setText(_translate("mainWindow", "Maximum Acceleration"))
self.label_33.setText(_translate("mainWindow", "Axis Type"))
self.reverse_5.setText(_translate("mainWindow", "Reverse Dir"))
self.analogGB_5.setTitle(_translate("mainWindow", "Analog Output"))
self.label_46.setText(_translate("mainWindow", "Analog Max Limit"))
self.label_47.setText(_translate("mainWindow", "Analog Scale Max"))
self.analogDefault_5.setText(_translate("mainWindow", "Default Values"))
self.label_48.setText(_translate("mainWindow", "Analog Min Limit"))
self.groupBox_64.setTitle(_translate("mainWindow", "Encoder"))
self.label_60.setText(_translate("mainWindow", "Encoder Scale"))
self.jointType_3.setTabText(self.jointType_3.indexOf(self.tab_3), _translate("mainWindow", "Joint 5"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.axisTab), _translate("mainWindow", "Axis"))
self.label_142.setText(_translate("mainWindow", "<html><head/><body><p>Spindle PWM requires the 4 axis plus PWM configuration.<br/>For Spindle On, Spindle CW/CCW use an output.</p></body></html>"))
self.spindlepidGB.setTitle(_translate("mainWindow", "PID Settings"))
self.label_264.setText(_translate("mainWindow", "P"))
self.label_265.setText(_translate("mainWindow", "Deadband"))
self.label_266.setText(_translate("mainWindow", "I"))
self.label_267.setText(_translate("mainWindow", "Bias"))
self.label_268.setText(_translate("mainWindow", "D"))
self.label_269.setText(_translate("mainWindow", "Max Output"))
self.label_270.setText(_translate("mainWindow", "FF0"))
self.label_271.setText(_translate("mainWindow", "Max Error"))
self.label_272.setText(_translate("mainWindow", "FF1"))
self.label_273.setText(_translate("mainWindow", "FF2"))
self.pidDefault_s.setText(_translate("mainWindow", "Default Values"))
self.encoderGB.setTitle(_translate("mainWindow", "Encoder Settings"))
self.label_178.setText(_translate("mainWindow", "Encoder Scale"))
self.label_193.setText(_translate("mainWindow", "Spindle Type"))
self.spindleGB.setTitle(_translate("mainWindow", "Spindle Settings"))
self.label_180.setText(_translate("mainWindow", "Max RPM"))
self.label_192.setText(_translate("mainWindow", "Min RPM"))
self.label_194.setText(_translate("mainWindow", "PWM Frequency"))
self.label_198.setText(_translate("mainWindow", "Hz"))
self.spindleInfoGB.setTitle(_translate("mainWindow", "Spindle Information"))
self.spindleInfo1Lbl.setText(_translate("mainWindow", "No Spindle"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.spindle), _translate("mainWindow", "Spindle"))
self.groupBox_59.setTitle(_translate("mainWindow", "Outputs"))
self.label_481.setText(_translate("mainWindow", "Output 1"))
self.label_746.setText(_translate("mainWindow", "Output 3"))
self.label_482.setText(_translate("mainWindow", "Output 4"))
self.label_541.setText(_translate("mainWindow", "Output 5"))
self.label_483.setText(_translate("mainWindow", "Output 2"))
self.label_521.setText(_translate("mainWindow", "Output 0"))
self.outputPB_0.setText(_translate("mainWindow", "Select"))
self.outputPB_1.setText(_translate("mainWindow", "Select"))
self.outputPB_2.setText(_translate("mainWindow", "Select"))
self.outputPB_3.setText(_translate("mainWindow", "Select"))
self.outputPB_4.setText(_translate("mainWindow", "Select"))
self.outputPB_5.setText(_translate("mainWindow", "Select"))
self.groupBox.setTitle(_translate("mainWindow", "Inputs"))
self.inputInvertCB_7.setText(_translate("mainWindow", "Invert"))
self.inputPB_6.setText(_translate("mainWindow", "Select"))
self.label_472.setText(_translate("mainWindow", "Input 3"))
self.label_478.setText(_translate("mainWindow", "Input 4"))
self.inputPB_4.setText(_translate("mainWindow", "Select"))
self.label_470.setText(_translate("mainWindow", "Input 1"))
self.inputInvertCB_9.setText(_translate("mainWindow", "Invert"))
self.inputPB_14.setText(_translate("mainWindow", "Select"))
self.inputInvertCB_2.setText(_translate("mainWindow", "Invert"))
self.label_770.setText(_translate("mainWindow", "Input 12"))
self.inputInvertCB_3.setText(_translate("mainWindow", "Invert"))
self.label_480.setText(_translate("mainWindow", "Input 9"))
self.inputInvertCB_1.setText(_translate("mainWindow", "Invert"))
self.inputPB_5.setText(_translate("mainWindow", "Select"))
self.label_475.setText(_translate("mainWindow", "Input 8"))
self.inputInvertCB_11.setText(_translate("mainWindow", "Invert"))
self.inputPB_11.setText(_translate("mainWindow", "Select"))
self.inputPB_3.setText(_translate("mainWindow", "Select"))
self.inputPB_8.setText(_translate("mainWindow", "Select"))
self.inputInvertCB_0.setText(_translate("mainWindow", "Invert"))
self.inputInvertCB_4.setText(_translate("mainWindow", "Invert"))
self.inputInvertCB_14.setText(_translate("mainWindow", "Invert"))
self.inputPB_15.setText(_translate("mainWindow", "Select"))
self.label_473.setText(_translate("mainWindow", "Input 0"))
self.label_773.setText(_translate("mainWindow", "Input 15"))
self.inputPB_10.setText(_translate("mainWindow", "Select"))
self.inputInvertCB_10.setText(_translate("mainWindow", "Invert"))
self.label_476.setText(_translate("mainWindow", "Input 10"))
self.inputInvertCB_5.setText(_translate("mainWindow", "Invert"))
self.inputInvertCB_15.setText(_translate("mainWindow", "Invert"))
self.label_471.setText(_translate("mainWindow", "Input 7"))
self.inputPB_9.setText(_translate("mainWindow", "Select"))
self.inputPB_7.setText(_translate("mainWindow", "Select"))
self.inputPB_12.setText(_translate("mainWindow", "Select"))
self.inputInvertCB_6.setText(_translate("mainWindow", "Invert"))
self.inputInvertCB_8.setText(_translate("mainWindow", "Invert"))
self.inputPB_13.setText(_translate("mainWindow", "Select"))
self.label_477.setText(_translate("mainWindow", "Input 2"))
self.label_771.setText(_translate("mainWindow", "Input 13"))
self.label_772.setText(_translate("mainWindow", "Input 14"))
self.inputPB_1.setText(_translate("mainWindow", "Select"))
self.label_474.setText(_translate("mainWindow", "Input 5"))
self.label_479.setText(_translate("mainWindow", "Input 6"))
self.inputPB_2.setText(_translate("mainWindow", "Select"))
self.inputPB_0.setText(_translate("mainWindow", "Select"))
self.inputInvertCB_13.setText(_translate("mainWindow", "Invert"))
self.label_769.setText(_translate("mainWindow", "Input 11"))
self.inputInvertCB_12.setText(_translate("mainWindow", "Invert"))
self.inputDebounceCB_0.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_1.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_2.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_3.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_4.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_5.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_6.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_7.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_8.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_9.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_10.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_11.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_12.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_13.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_14.setText(_translate("mainWindow", "Debounce"))
self.inputDebounceCB_15.setText(_translate("mainWindow", "Debounce"))
self.groupBox_65.setTitle(_translate("mainWindow", "Input Scan Time"))
self.fastScanSB.setSuffix(_translate("mainWindow", " ms"))
self.label_102.setText(_translate("mainWindow", "Fast Scan Time"))
self.slowScanSB.setSuffix(_translate("mainWindow", " ms"))
self.label_54.setText(_translate("mainWindow", "Slow Scan Time"))
self.label_104.setText(_translate("mainWindow", "Slow Scan is enabled by selecting Debounce"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.inputs), _translate("mainWindow", "I/O"))
self.groupBox_18.setTitle(_translate("mainWindow", "Tool Changer Type"))
self.label_411.setText(_translate("mainWindow", "TextLabel"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab), _translate("mainWindow", "Tool Changer"))
self.groupBox_21.setTitle(_translate("mainWindow", "Smart Serial Card"))
self.buildSserialCB.setText(_translate("mainWindow", "Build sserial.hal"))
self.label_420.setText(_translate("mainWindow", "No Smart Serial Card Selected"))
self.plainTextEdit.setPlainText(_translate("mainWindow", "The Smart Serial Card Configuration is very new.\n"
"\n"
"At this time the Smart Serial Card\n"
"will create a net with a signal name and you will have to add the input or output pin name or create simple I/O connections.\n"
"\n"
"The 7i83 and 7i87 are not currently supported.\n"
"\n"
"The Smart Serial Card configuration will not load from the ini file at this time."))
self.plainTextEdit_2.setPlainText(_translate("mainWindow", "SSERIAL Wiring using a standard CAT5 Cable\n"
"Pin 0 is at the bottom\n"
"TB2 PIN SIGNAL CAT5 PIN CAT5 568B COLOR\n"
"15 GND 4,5 BLUE, BLUE / WHITE\n"
"16 RX+ 6 GREEN\n"
"17 RX- 3 GREEN / WHITE\n"
"18 TX+ 2 ORANGE\n"
"19 TX- 1 ORANGE / WHITE\n"
"20 +5V 7,8 BROWN / WHITE,BROWN"))
self.groupBox_32.setTitle(_translate("mainWindow", "7i64"))
self.groupBox_31.setTitle(_translate("mainWindow", "Ouputs 12 - 23 P5"))
self.label_528.setText(_translate("mainWindow", "19"))
self.label_529.setText(_translate("mainWindow", "20"))
self.label_527.setText(_translate("mainWindow", "21"))
self.label_532.setText(_translate("mainWindow", "14"))
self.label_526.setText(_translate("mainWindow", "13"))
self.label_525.setText(_translate("mainWindow", "15"))
self.label_522.setText(_translate("mainWindow", "22"))
self.label_523.setText(_translate("mainWindow", "23"))
self.label_524.setText(_translate("mainWindow", "16"))
self.label_530.setText(_translate("mainWindow", "17"))
self.label_531.setText(_translate("mainWindow", "18"))
self.label_486.setText(_translate("mainWindow", "12"))
self.ss7i64out_12.setText(_translate("mainWindow", "Select"))
self.ss7i64out_13.setText(_translate("mainWindow", "Select"))
self.ss7i64out_14.setText(_translate("mainWindow", "Select"))
self.ss7i64out_15.setText(_translate("mainWindow", "Select"))
self.ss7i64out_16.setText(_translate("mainWindow", "Select"))
self.ss7i64out_17.setText(_translate("mainWindow", "Select"))
self.ss7i64out_18.setText(_translate("mainWindow", "Select"))
self.ss7i64out_19.setText(_translate("mainWindow", "Select"))
self.ss7i64out_20.setText(_translate("mainWindow", "Select"))
self.ss7i64out_21.setText(_translate("mainWindow", "Select"))
self.ss7i64out_22.setText(_translate("mainWindow", "Select"))
self.ss7i64out_23.setText(_translate("mainWindow", "Select"))
self.groupBox_29.setTitle(_translate("mainWindow", "Inputs 12 - 23 P4"))
self.label_499.setText(_translate("mainWindow", "14"))
self.label_508.setText(_translate("mainWindow", "23"))
self.label_506.setText(_translate("mainWindow", "21"))
self.label_500.setText(_translate("mainWindow", "15"))
self.label_505.setText(_translate("mainWindow", "20"))
self.label_507.setText(_translate("mainWindow", "22"))
self.label_502.setText(_translate("mainWindow", "17"))
self.label_501.setText(_translate("mainWindow", "16"))
self.label_504.setText(_translate("mainWindow", "19"))
self.label_484.setText(_translate("mainWindow", "12"))
self.label_498.setText(_translate("mainWindow", "13"))
self.label_503.setText(_translate("mainWindow", "18"))
self.ss7i64in_12.setText(_translate("mainWindow", "Select"))
self.ss7i64in_13.setText(_translate("mainWindow", "Select"))
self.ss7i64in_14.setText(_translate("mainWindow", "Select"))
self.ss7i64in_15.setText(_translate("mainWindow", "Select"))
self.ss7i64in_16.setText(_translate("mainWindow", "Select"))
self.ss7i64in_17.setText(_translate("mainWindow", "Select"))
self.ss7i64in_18.setText(_translate("mainWindow", "Select"))
self.ss7i64in_19.setText(_translate("mainWindow", "Select"))
self.ss7i64in_20.setText(_translate("mainWindow", "Select"))
self.ss7i64in_21.setText(_translate("mainWindow", "Select"))
self.ss7i64in_22.setText(_translate("mainWindow", "Select"))
self.ss7i64in_23.setText(_translate("mainWindow", "Select"))
self.groupBox_28.setTitle(_translate("mainWindow", "Inputs 0 - 11 P3"))
self.label_489.setText(_translate("mainWindow", "2"))
self.label_488.setText(_translate("mainWindow", "6"))
self.label_487.setText(_translate("mainWindow", "1"))
self.label_491.setText(_translate("mainWindow", "4"))
self.label_497.setText(_translate("mainWindow", "11"))
self.label_493.setText(_translate("mainWindow", "7"))
self.label_495.setText(_translate("mainWindow", "9"))
self.label_496.setText(_translate("mainWindow", "10"))
self.label_494.setText(_translate("mainWindow", "8"))
self.label_492.setText(_translate("mainWindow", "5"))
self.label_412.setText(_translate("mainWindow", "0"))
self.label_490.setText(_translate("mainWindow", "3"))
self.ss7i64in_0.setText(_translate("mainWindow", "Select"))
self.ss7i64in_1.setText(_translate("mainWindow", "Select"))
self.ss7i64in_2.setText(_translate("mainWindow", "Select"))
self.ss7i64in_3.setText(_translate("mainWindow", "Select"))
self.ss7i64in_4.setText(_translate("mainWindow", "Select"))
self.ss7i64in_5.setText(_translate("mainWindow", "Select"))
self.ss7i64in_6.setText(_translate("mainWindow", "Select"))
self.ss7i64in_7.setText(_translate("mainWindow", "Select"))
self.ss7i64in_8.setText(_translate("mainWindow", "Select"))
self.ss7i64in_9.setText(_translate("mainWindow", "Select"))
self.ss7i64in_10.setText(_translate("mainWindow", "Select"))
self.ss7i64in_11.setText(_translate("mainWindow", "Select"))
self.groupBox_30.setTitle(_translate("mainWindow", "Outputs 0 - 11 P2"))
self.label_485.setText(_translate("mainWindow", "0"))
self.label_513.setText(_translate("mainWindow", "1"))
self.label_514.setText(_translate("mainWindow", "2"))
self.label_519.setText(_translate("mainWindow", "3"))
self.label_517.setText(_translate("mainWindow", "4"))
self.label_515.setText(_translate("mainWindow", "5"))
self.label_516.setText(_translate("mainWindow", "6"))
self.label_511.setText(_translate("mainWindow", "7"))
self.label_520.setText(_translate("mainWindow", "8"))
self.label_512.setText(_translate("mainWindow", "9"))
self.label_518.setText(_translate("mainWindow", "10"))
self.label_510.setText(_translate("mainWindow", "11"))
self.ss7i64out_0.setText(_translate("mainWindow", "Select"))
self.ss7i64out_1.setText(_translate("mainWindow", "Select"))
self.ss7i64out_2.setText(_translate("mainWindow", "Select"))
self.ss7i64out_3.setText(_translate("mainWindow", "Select"))
self.ss7i64out_4.setText(_translate("mainWindow", "Select"))
self.ss7i64out_5.setText(_translate("mainWindow", "Select"))
self.ss7i64out_6.setText(_translate("mainWindow", "Select"))
self.ss7i64out_7.setText(_translate("mainWindow", "Select"))
self.ss7i64out_8.setText(_translate("mainWindow", "Select"))
self.ss7i64out_9.setText(_translate("mainWindow", "Select"))
self.ss7i64out_10.setText(_translate("mainWindow", "Select"))
self.ss7i64out_11.setText(_translate("mainWindow", "Select"))
self.groupBox_33.setTitle(_translate("mainWindow", "7i69"))
self.groupBox_40.setTitle(_translate("mainWindow", "Inputs 0 - 11 P2"))
self.label_546.setText(_translate("mainWindow", "2"))
self.label_550.setText(_translate("mainWindow", "11"))
self.label_548.setText(_translate("mainWindow", "1"))
self.label_547.setText(_translate("mainWindow", "6"))
self.label_556.setText(_translate("mainWindow", "3"))
self.label_413.setText(_translate("mainWindow", "0"))
self.label_551.setText(_translate("mainWindow", "7"))
self.label_554.setText(_translate("mainWindow", "8"))
self.label_555.setText(_translate("mainWindow", "5"))
self.label_549.setText(_translate("mainWindow", "4"))
self.label_552.setText(_translate("mainWindow", "9"))
self.label_553.setText(_translate("mainWindow", "10"))
self.ss7i69in_0.setText(_translate("mainWindow", "Select"))
self.ss7i69in_1.setText(_translate("mainWindow", "Select"))
self.ss7i69in_2.setText(_translate("mainWindow", "Select"))
self.ss7i69in_3.setText(_translate("mainWindow", "Select"))
self.ss7i69in_4.setText(_translate("mainWindow", "Select"))
self.ss7i69in_5.setText(_translate("mainWindow", "Select"))
self.ss7i69in_6.setText(_translate("mainWindow", "Select"))
self.ss7i69in_7.setText(_translate("mainWindow", "Select"))
self.ss7i69in_8.setText(_translate("mainWindow", "Select"))
self.ss7i69in_9.setText(_translate("mainWindow", "Select"))
self.ss7i69in_10.setText(_translate("mainWindow", "Select"))
self.ss7i69in_11.setText(_translate("mainWindow", "Select"))
self.groupBox_42.setTitle(_translate("mainWindow", "Inputs 12 - 23 P2"))
self.label_571.setText(_translate("mainWindow", "21"))
self.label_572.setText(_translate("mainWindow", "15"))
self.label_570.setText(_translate("mainWindow", "23"))
self.label_569.setText(_translate("mainWindow", "14"))
self.label_576.setText(_translate("mainWindow", "17"))
self.label_575.setText(_translate("mainWindow", "22"))
self.label_574.setText(_translate("mainWindow", "20"))
self.label_577.setText(_translate("mainWindow", "16"))
self.label_578.setText(_translate("mainWindow", "19"))
self.label_579.setText(_translate("mainWindow", "12"))
self.label_581.setText(_translate("mainWindow", "18"))
self.label_580.setText(_translate("mainWindow", "13"))
self.ss7i69in_12.setText(_translate("mainWindow", "Select"))
self.ss7i69in_13.setText(_translate("mainWindow", "Select"))
self.ss7i69in_14.setText(_translate("mainWindow", "Select"))
self.ss7i69in_15.setText(_translate("mainWindow", "Select"))
self.ss7i69in_16.setText(_translate("mainWindow", "Select"))
self.ss7i69in_17.setText(_translate("mainWindow", "Select"))
self.ss7i69in_18.setText(_translate("mainWindow", "Select"))
self.ss7i69in_19.setText(_translate("mainWindow", "Select"))
self.ss7i69in_20.setText(_translate("mainWindow", "Select"))
self.ss7i69in_21.setText(_translate("mainWindow", "Select"))
self.ss7i69in_22.setText(_translate("mainWindow", "Select"))
self.ss7i69in_23.setText(_translate("mainWindow", "Select"))
self.groupBox_39.setTitle(_translate("mainWindow", "Ouputs 12 - 23 P3"))
self.label_535.setText(_translate("mainWindow", "21"))
self.label_540.setText(_translate("mainWindow", "23"))
self.label_534.setText(_translate("mainWindow", "20"))
self.label_533.setText(_translate("mainWindow", "19"))
self.label_545.setText(_translate("mainWindow", "12"))
self.label_537.setText(_translate("mainWindow", "13"))
self.label_544.setText(_translate("mainWindow", "18"))
self.label_543.setText(_translate("mainWindow", "17"))
self.label_542.setText(_translate("mainWindow", "16"))
self.label_536.setText(_translate("mainWindow", "14"))
self.label_539.setText(_translate("mainWindow", "22"))
self.label_538.setText(_translate("mainWindow", "15"))
self.ss7i69out_12.setText(_translate("mainWindow", "Select"))
self.ss7i69out_13.setText(_translate("mainWindow", "Select"))
self.ss7i69out_14.setText(_translate("mainWindow", "Select"))
self.ss7i69out_15.setText(_translate("mainWindow", "Select"))
self.ss7i69out_16.setText(_translate("mainWindow", "Select"))
self.ss7i69out_17.setText(_translate("mainWindow", "Select"))
self.ss7i69out_18.setText(_translate("mainWindow", "Select"))
self.ss7i69out_19.setText(_translate("mainWindow", "Select"))
self.ss7i69out_20.setText(_translate("mainWindow", "Select"))
self.ss7i69out_21.setText(_translate("mainWindow", "Select"))
self.ss7i69out_22.setText(_translate("mainWindow", "Select"))
self.ss7i69out_23.setText(_translate("mainWindow", "Select"))
self.groupBox_41.setTitle(_translate("mainWindow", "Outputs 0 - 11 P3"))
self.label_557.setText(_translate("mainWindow", "0"))
self.label_558.setText(_translate("mainWindow", "1"))
self.label_559.setText(_translate("mainWindow", "2"))
self.label_560.setText(_translate("mainWindow", "3"))
self.label_561.setText(_translate("mainWindow", "4"))
self.label_562.setText(_translate("mainWindow", "5"))
self.label_563.setText(_translate("mainWindow", "6"))
self.label_564.setText(_translate("mainWindow", "7"))
self.label_565.setText(_translate("mainWindow", "8"))
self.label_566.setText(_translate("mainWindow", "9"))
self.label_567.setText(_translate("mainWindow", "10"))
self.label_568.setText(_translate("mainWindow", "11"))
self.ss7i69out_0.setText(_translate("mainWindow", "Select"))
self.ss7i69out_1.setText(_translate("mainWindow", "Select"))
self.ss7i69out_2.setText(_translate("mainWindow", "Select"))
self.ss7i69out_3.setText(_translate("mainWindow", "Select"))
self.ss7i69out_4.setText(_translate("mainWindow", "Select"))
self.ss7i69out_5.setText(_translate("mainWindow", "Select"))
self.ss7i69out_6.setText(_translate("mainWindow", "Select"))
self.ss7i69out_7.setText(_translate("mainWindow", "Select"))
self.ss7i69out_8.setText(_translate("mainWindow", "Select"))
self.ss7i69out_9.setText(_translate("mainWindow", "Select"))
self.ss7i69out_10.setText(_translate("mainWindow", "Select"))
self.ss7i69out_11.setText(_translate("mainWindow", "Select"))
self.groupBox_34.setTitle(_translate("mainWindow", "7i70"))
self.groupBox_44.setTitle(_translate("mainWindow", "Inputs 0 - 11 P2"))
self.label_595.setText(_translate("mainWindow", "2"))
self.label_596.setText(_translate("mainWindow", "6"))
self.label_597.setText(_translate("mainWindow", "1"))
self.label_598.setText(_translate("mainWindow", "4"))
self.label_599.setText(_translate("mainWindow", "11"))
self.label_600.setText(_translate("mainWindow", "7"))
self.label_601.setText(_translate("mainWindow", "9"))
self.label_602.setText(_translate("mainWindow", "10"))
self.label_603.setText(_translate("mainWindow", "8"))
self.label_604.setText(_translate("mainWindow", "5"))
self.label_414.setText(_translate("mainWindow", "0"))
self.label_605.setText(_translate("mainWindow", "3"))
self.ss7i70in_0.setText(_translate("mainWindow", "Select"))
self.ss7i70in_1.setText(_translate("mainWindow", "Select"))
self.ss7i70in_2.setText(_translate("mainWindow", "Select"))
self.ss7i70in_3.setText(_translate("mainWindow", "Select"))
self.ss7i70in_4.setText(_translate("mainWindow", "Select"))
self.ss7i70in_5.setText(_translate("mainWindow", "Select"))
self.ss7i70in_6.setText(_translate("mainWindow", "Select"))
self.ss7i70in_7.setText(_translate("mainWindow", "Select"))
self.ss7i70in_8.setText(_translate("mainWindow", "Select"))
self.ss7i70in_9.setText(_translate("mainWindow", "Select"))
self.ss7i70in_10.setText(_translate("mainWindow", "Select"))
self.ss7i70in_11.setText(_translate("mainWindow", "Select"))
self.groupBox_43.setTitle(_translate("mainWindow", "Inputs 12 - 23 P2"))
self.label_585.setText(_translate("mainWindow", "14"))
self.label_584.setText(_translate("mainWindow", "23"))
self.label_582.setText(_translate("mainWindow", "21"))
self.label_583.setText(_translate("mainWindow", "15"))
self.label_589.setText(_translate("mainWindow", "20"))
self.label_592.setText(_translate("mainWindow", "12"))
self.label_590.setText(_translate("mainWindow", "16"))
self.label_588.setText(_translate("mainWindow", "22"))
self.label_587.setText(_translate("mainWindow", "17"))
self.label_591.setText(_translate("mainWindow", "19"))
self.label_593.setText(_translate("mainWindow", "18"))
self.label_594.setText(_translate("mainWindow", "13"))
self.ss7i70in_12.setText(_translate("mainWindow", "Select"))
self.ss7i70in_13.setText(_translate("mainWindow", "Select"))
self.ss7i70in_14.setText(_translate("mainWindow", "Select"))
self.ss7i70in_15.setText(_translate("mainWindow", "Select"))
self.ss7i70in_16.setText(_translate("mainWindow", "Select"))
self.ss7i70in_17.setText(_translate("mainWindow", "Select"))
self.ss7i70in_18.setText(_translate("mainWindow", "Select"))
self.ss7i70in_19.setText(_translate("mainWindow", "Select"))
self.ss7i70in_20.setText(_translate("mainWindow", "Select"))
self.ss7i70in_21.setText(_translate("mainWindow", "Select"))
self.ss7i70in_22.setText(_translate("mainWindow", "Select"))
self.ss7i70in_23.setText(_translate("mainWindow", "Select"))
self.groupBox_45.setTitle(_translate("mainWindow", "Inputs 36 - 47 P3"))
self.label_606.setText(_translate("mainWindow", "46"))
self.label_614.setText(_translate("mainWindow", "41"))
self.label_611.setText(_translate("mainWindow", "38"))
self.label_613.setText(_translate("mainWindow", "42"))
self.label_612.setText(_translate("mainWindow", "43"))
self.label_608.setText(_translate("mainWindow", "45"))
self.label_609.setText(_translate("mainWindow", "44"))
self.label_610.setText(_translate("mainWindow", "37"))
self.label_617.setText(_translate("mainWindow", "47"))
self.label_632.setText(_translate("mainWindow", "36"))
self.label_618.setText(_translate("mainWindow", "40"))
self.label_616.setText(_translate("mainWindow", "39"))
self.ss7i70in_36.setText(_translate("mainWindow", "Select"))
self.ss7i70in_37.setText(_translate("mainWindow", "Select"))
self.ss7i70in_38.setText(_translate("mainWindow", "Select"))
self.ss7i70in_39.setText(_translate("mainWindow", "Select"))
self.ss7i70in_40.setText(_translate("mainWindow", "Select"))
self.ss7i70in_41.setText(_translate("mainWindow", "Select"))
self.ss7i70in_42.setText(_translate("mainWindow", "Select"))
self.ss7i70in_43.setText(_translate("mainWindow", "Select"))
self.ss7i70in_44.setText(_translate("mainWindow", "Select"))
self.ss7i70in_45.setText(_translate("mainWindow", "Select"))
self.ss7i70in_46.setText(_translate("mainWindow", "Select"))
self.ss7i70in_47.setText(_translate("mainWindow", "Select"))
self.groupBox_46.setTitle(_translate("mainWindow", "Inputs 24 - 35 P3"))
self.label_619.setText(_translate("mainWindow", "24"))
self.label_627.setText(_translate("mainWindow", "33"))
self.label_626.setText(_translate("mainWindow", "32"))
self.label_629.setText(_translate("mainWindow", "35"))
self.label_628.setText(_translate("mainWindow", "34"))
self.label_631.setText(_translate("mainWindow", "25"))
self.label_621.setText(_translate("mainWindow", "27"))
self.label_620.setText(_translate("mainWindow", "26"))
self.label_624.setText(_translate("mainWindow", "30"))
self.label_625.setText(_translate("mainWindow", "31"))
self.label_623.setText(_translate("mainWindow", "29"))
self.label_622.setText(_translate("mainWindow", "28"))
self.ss7i70in_24.setText(_translate("mainWindow", "Select"))
self.ss7i70in_25.setText(_translate("mainWindow", "Select"))
self.ss7i70in_26.setText(_translate("mainWindow", "Select"))
self.ss7i70in_27.setText(_translate("mainWindow", "Select"))
self.ss7i70in_28.setText(_translate("mainWindow", "Select"))
self.ss7i70in_29.setText(_translate("mainWindow", "Select"))
self.ss7i70in_30.setText(_translate("mainWindow", "Select"))
self.ss7i70in_31.setText(_translate("mainWindow", "Select"))
self.ss7i70in_32.setText(_translate("mainWindow", "Select"))
self.ss7i70in_33.setText(_translate("mainWindow", "Select"))
self.ss7i70in_34.setText(_translate("mainWindow", "Select"))
self.ss7i70in_35.setText(_translate("mainWindow", "Select"))
self.groupBox_35.setTitle(_translate("mainWindow", "7i71"))
self.groupBox_47.setTitle(_translate("mainWindow", "Outputs 12 - 23 TB3"))
self.label_640.setText(_translate("mainWindow", "13"))
self.label_637.setText(_translate("mainWindow", "17"))
self.label_638.setText(_translate("mainWindow", "19"))
self.label_607.setText(_translate("mainWindow", "23"))
self.label_615.setText(_translate("mainWindow", "21"))
self.label_630.setText(_translate("mainWindow", "15"))
self.label_639.setText(_translate("mainWindow", "18"))
self.label_633.setText(_translate("mainWindow", "20"))
self.label_634.setText(_translate("mainWindow", "12"))
self.label_635.setText(_translate("mainWindow", "16"))
self.label_636.setText(_translate("mainWindow", "22"))
self.label_586.setText(_translate("mainWindow", "14"))
self.ss7i71out_12.setText(_translate("mainWindow", "Select"))
self.ss7i71out_13.setText(_translate("mainWindow", "Select"))
self.ss7i71out_14.setText(_translate("mainWindow", "Select"))
self.ss7i71out_15.setText(_translate("mainWindow", "Select"))
self.ss7i71out_16.setText(_translate("mainWindow", "Select"))
self.ss7i71out_17.setText(_translate("mainWindow", "Select"))
self.ss7i71out_18.setText(_translate("mainWindow", "Select"))
self.ss7i71out_19.setText(_translate("mainWindow", "Select"))
self.ss7i71out_20.setText(_translate("mainWindow", "Select"))
self.ss7i71out_21.setText(_translate("mainWindow", "Select"))
self.ss7i71out_22.setText(_translate("mainWindow", "Select"))
self.ss7i71out_23.setText(_translate("mainWindow", "Select"))
self.groupBox_48.setTitle(_translate("mainWindow", "Outputs 36 - 47 TB2"))
self.label_643.setText(_translate("mainWindow", "38"))
self.label_641.setText(_translate("mainWindow", "46"))
self.label_652.setText(_translate("mainWindow", "39"))
self.label_644.setText(_translate("mainWindow", "42"))
self.label_649.setText(_translate("mainWindow", "47"))
self.label_647.setText(_translate("mainWindow", "44"))
self.label_646.setText(_translate("mainWindow", "45"))
self.label_650.setText(_translate("mainWindow", "36"))
self.label_648.setText(_translate("mainWindow", "37"))
self.label_645.setText(_translate("mainWindow", "43"))
self.label_651.setText(_translate("mainWindow", "40"))
self.label_642.setText(_translate("mainWindow", "41"))
self.ss7i71out_36.setText(_translate("mainWindow", "Select"))
self.ss7i71out_37.setText(_translate("mainWindow", "Select"))
self.ss7i71out_38.setText(_translate("mainWindow", "Select"))
self.ss7i71out_39.setText(_translate("mainWindow", "Select"))
self.ss7i71out_40.setText(_translate("mainWindow", "Select"))
self.ss7i71out_41.setText(_translate("mainWindow", "Select"))
self.ss7i71out_42.setText(_translate("mainWindow", "Select"))
self.ss7i71out_43.setText(_translate("mainWindow", "Select"))
self.ss7i71out_44.setText(_translate("mainWindow", "Select"))
self.ss7i71out_45.setText(_translate("mainWindow", "Select"))
self.ss7i71out_46.setText(_translate("mainWindow", "Select"))
self.ss7i71out_47.setText(_translate("mainWindow", "Select"))
self.groupBox_49.setTitle(_translate("mainWindow", "Outputs 24 - 35 TB2"))
self.label_656.setText(_translate("mainWindow", "35"))
self.label_654.setText(_translate("mainWindow", "33"))
self.label_653.setText(_translate("mainWindow", "24"))
self.label_655.setText(_translate("mainWindow", "32"))
self.label_660.setText(_translate("mainWindow", "26"))
self.label_657.setText(_translate("mainWindow", "34"))
self.label_659.setText(_translate("mainWindow", "27"))
self.label_662.setText(_translate("mainWindow", "31"))
self.label_663.setText(_translate("mainWindow", "29"))
self.label_658.setText(_translate("mainWindow", "25"))
self.label_664.setText(_translate("mainWindow", "28"))
self.label_661.setText(_translate("mainWindow", "30"))
self.ss7i71out_24.setText(_translate("mainWindow", "Select"))
self.ss7i71out_25.setText(_translate("mainWindow", "Select"))
self.ss7i71out_26.setText(_translate("mainWindow", "Select"))
self.ss7i71out_27.setText(_translate("mainWindow", "Select"))
self.ss7i71out_28.setText(_translate("mainWindow", "Select"))
self.ss7i71out_29.setText(_translate("mainWindow", "Select"))
self.ss7i71out_30.setText(_translate("mainWindow", "Select"))
self.ss7i71out_31.setText(_translate("mainWindow", "Select"))
self.ss7i71out_32.setText(_translate("mainWindow", "Select"))
self.ss7i71out_33.setText(_translate("mainWindow", "Select"))
self.ss7i71out_34.setText(_translate("mainWindow", "Select"))
self.ss7i71out_35.setText(_translate("mainWindow", "Select"))
self.groupBox_50.setTitle(_translate("mainWindow", "Outputs 0 - 11 TB3"))
self.label_665.setText(_translate("mainWindow", "2"))
self.label_666.setText(_translate("mainWindow", "6"))
self.label_667.setText(_translate("mainWindow", "1"))
self.label_668.setText(_translate("mainWindow", "4"))
self.label_669.setText(_translate("mainWindow", "11"))
self.label_670.setText(_translate("mainWindow", "7"))
self.label_671.setText(_translate("mainWindow", "9"))
self.label_672.setText(_translate("mainWindow", "10"))
self.label_673.setText(_translate("mainWindow", "8"))
self.label_674.setText(_translate("mainWindow", "5"))
self.label_415.setText(_translate("mainWindow", "0"))
self.label_675.setText(_translate("mainWindow", "3"))
self.ss7i71out_0.setText(_translate("mainWindow", "Select"))
self.ss7i71out_1.setText(_translate("mainWindow", "Select"))
self.ss7i71out_2.setText(_translate("mainWindow", "Select"))
self.ss7i71out_3.setText(_translate("mainWindow", "Select"))
self.ss7i71out_4.setText(_translate("mainWindow", "Select"))
self.ss7i71out_5.setText(_translate("mainWindow", "Select"))
self.ss7i71out_6.setText(_translate("mainWindow", "Select"))
self.ss7i71out_7.setText(_translate("mainWindow", "Select"))
self.ss7i71out_8.setText(_translate("mainWindow", "Select"))
self.ss7i71out_9.setText(_translate("mainWindow", "Select"))
self.ss7i71out_10.setText(_translate("mainWindow", "Select"))
self.ss7i71out_11.setText(_translate("mainWindow", "Select"))
self.groupBox_36.setTitle(_translate("mainWindow", "7i72"))
self.groupBox_51.setTitle(_translate("mainWindow", "Outputs 0 - 11 TB3"))
self.label_676.setText(_translate("mainWindow", "2"))
self.label_677.setText(_translate("mainWindow", "6"))
self.label_678.setText(_translate("mainWindow", "1"))
self.label_679.setText(_translate("mainWindow", "4"))
self.label_680.setText(_translate("mainWindow", "11"))
self.label_681.setText(_translate("mainWindow", "7"))
self.label_682.setText(_translate("mainWindow", "9"))
self.label_683.setText(_translate("mainWindow", "10"))
self.label_684.setText(_translate("mainWindow", "8"))
self.label_685.setText(_translate("mainWindow", "5"))
self.label_416.setText(_translate("mainWindow", "0"))
self.label_686.setText(_translate("mainWindow", "3"))
self.ss7i72out_0.setText(_translate("mainWindow", "Select"))
self.ss7i72out_1.setText(_translate("mainWindow", "Select"))
self.ss7i72out_2.setText(_translate("mainWindow", "Select"))
self.ss7i72out_3.setText(_translate("mainWindow", "Select"))
self.ss7i72out_4.setText(_translate("mainWindow", "Select"))
self.ss7i72out_5.setText(_translate("mainWindow", "Select"))
self.ss7i72out_6.setText(_translate("mainWindow", "Select"))
self.ss7i72out_7.setText(_translate("mainWindow", "Select"))
self.ss7i72out_8.setText(_translate("mainWindow", "Select"))
self.ss7i72out_9.setText(_translate("mainWindow", "Select"))
self.ss7i72out_10.setText(_translate("mainWindow", "Select"))
self.ss7i72out_11.setText(_translate("mainWindow", "Select"))
self.groupBox_52.setTitle(_translate("mainWindow", "Outputs 12 - 23 TB3"))
self.label_687.setText(_translate("mainWindow", "14"))
self.label_690.setText(_translate("mainWindow", "15"))
self.label_689.setText(_translate("mainWindow", "21"))
self.label_692.setText(_translate("mainWindow", "12"))
self.label_694.setText(_translate("mainWindow", "22"))
self.label_693.setText(_translate("mainWindow", "16"))
self.label_688.setText(_translate("mainWindow", "23"))
self.label_697.setText(_translate("mainWindow", "18"))
self.label_698.setText(_translate("mainWindow", "13"))
self.label_696.setText(_translate("mainWindow", "19"))
self.label_695.setText(_translate("mainWindow", "17"))
self.label_691.setText(_translate("mainWindow", "20"))
self.ss7i72out_12.setText(_translate("mainWindow", "Select"))
self.ss7i72out_13.setText(_translate("mainWindow", "Select"))
self.ss7i72out_14.setText(_translate("mainWindow", "Select"))
self.ss7i72out_15.setText(_translate("mainWindow", "Select"))
self.ss7i72out_16.setText(_translate("mainWindow", "Select"))
self.ss7i72out_17.setText(_translate("mainWindow", "Select"))
self.ss7i72out_18.setText(_translate("mainWindow", "Select"))
self.ss7i72out_19.setText(_translate("mainWindow", "Select"))
self.ss7i72out_20.setText(_translate("mainWindow", "Select"))
self.ss7i72out_21.setText(_translate("mainWindow", "Select"))
self.ss7i72out_22.setText(_translate("mainWindow", "Select"))
self.ss7i72out_23.setText(_translate("mainWindow", "Select"))
self.groupBox_54.setTitle(_translate("mainWindow", "Outputs 36 - 47 TB2"))
self.label_712.setText(_translate("mainWindow", "41"))
self.label_716.setText(_translate("mainWindow", "45"))
self.label_717.setText(_translate("mainWindow", "44"))
self.label_718.setText(_translate("mainWindow", "37"))
self.label_715.setText(_translate("mainWindow", "43"))
self.label_721.setText(_translate("mainWindow", "40"))
self.label_714.setText(_translate("mainWindow", "42"))
self.label_722.setText(_translate("mainWindow", "39"))
self.label_720.setText(_translate("mainWindow", "36"))
self.label_719.setText(_translate("mainWindow", "47"))
self.label_711.setText(_translate("mainWindow", "46"))
self.label_713.setText(_translate("mainWindow", "38"))
self.ss7i72out_36.setText(_translate("mainWindow", "Select"))
self.ss7i72out_37.setText(_translate("mainWindow", "Select"))
self.ss7i72out_38.setText(_translate("mainWindow", "Select"))
self.ss7i72out_39.setText(_translate("mainWindow", "Select"))
self.ss7i72out_40.setText(_translate("mainWindow", "Select"))
self.ss7i72out_41.setText(_translate("mainWindow", "Select"))
self.ss7i72out_42.setText(_translate("mainWindow", "Select"))
self.ss7i72out_43.setText(_translate("mainWindow", "Select"))
self.ss7i72out_44.setText(_translate("mainWindow", "Select"))
self.ss7i72out_45.setText(_translate("mainWindow", "Select"))
self.ss7i72out_46.setText(_translate("mainWindow", "Select"))
self.ss7i72out_47.setText(_translate("mainWindow", "Select"))
self.groupBox_53.setTitle(_translate("mainWindow", "Outputs 24 - 35 TB2"))
self.label_702.setText(_translate("mainWindow", "35"))
self.label_701.setText(_translate("mainWindow", "32"))
self.label_707.setText(_translate("mainWindow", "30"))
self.label_706.setText(_translate("mainWindow", "26"))
self.label_700.setText(_translate("mainWindow", "33"))
self.label_699.setText(_translate("mainWindow", "24"))
self.label_704.setText(_translate("mainWindow", "25"))
self.label_709.setText(_translate("mainWindow", "29"))
self.label_710.setText(_translate("mainWindow", "28"))
self.label_703.setText(_translate("mainWindow", "34"))
self.label_705.setText(_translate("mainWindow", "27"))
self.label_708.setText(_translate("mainWindow", "31"))
self.ss7i72out_24.setText(_translate("mainWindow", "Select"))
self.ss7i72out_25.setText(_translate("mainWindow", "Select"))
self.ss7i72out_26.setText(_translate("mainWindow", "Select"))
self.ss7i72out_27.setText(_translate("mainWindow", "Select"))
self.ss7i72out_28.setText(_translate("mainWindow", "Select"))
self.ss7i72out_29.setText(_translate("mainWindow", "Select"))
self.ss7i72out_30.setText(_translate("mainWindow", "Select"))
self.ss7i72out_31.setText(_translate("mainWindow", "Select"))
self.ss7i72out_32.setText(_translate("mainWindow", "Select"))
self.ss7i72out_33.setText(_translate("mainWindow", "Select"))
self.ss7i72out_34.setText(_translate("mainWindow", "Select"))
self.ss7i72out_35.setText(_translate("mainWindow", "Select"))
self.groupBox_37.setTitle(_translate("mainWindow", "7i73"))
self.groupBox_56.setTitle(_translate("mainWindow", "Jumpers"))
self.label_509.setText(_translate("mainWindow", "KeyPad"))
self.ss7i73w5Lbl.setText(_translate("mainWindow", "W5 Down"))
self.ss7i73w6Lbl.setText(_translate("mainWindow", "W6 Down"))
self.label_728.setText(_translate("mainWindow", "LCD"))
self.ss7i97w7Lbl.setText(_translate("mainWindow", "W7 Down"))
self.groupBox_58.setTitle(_translate("mainWindow", "I/O P2"))
self.label_726.setText(_translate("mainWindow", "In 0"))
self.label_730.setText(_translate("mainWindow", "In 2"))
self.label_468.setText(_translate("mainWindow", "Out 0"))
self.label_736.setText(_translate("mainWindow", "In 6"))
self.label_743.setText(_translate("mainWindow", "In 13"))
self.label_738.setText(_translate("mainWindow", "In 8"))
self.label_734.setText(_translate("mainWindow", "In 4"))
self.label_735.setText(_translate("mainWindow", "In 5"))
self.label_729.setText(_translate("mainWindow", "In 1"))
self.label_741.setText(_translate("mainWindow", "In 11"))
self.label_737.setText(_translate("mainWindow", "In 7"))
self.label_733.setText(_translate("mainWindow", "In 3"))
self.label_739.setText(_translate("mainWindow", "In 9"))
self.label_742.setText(_translate("mainWindow", "In 12"))
self.label_740.setText(_translate("mainWindow", "In 10"))
self.label_744.setText(_translate("mainWindow", "In 14"))
self.label_745.setText(_translate("mainWindow", "In 15"))
self.label_469.setText(_translate("mainWindow", "Out 1"))
self.ss7i73in_0.setText(_translate("mainWindow", "Select"))
self.ss7i73in_1.setText(_translate("mainWindow", "Select"))
self.ss7i73in_2.setText(_translate("mainWindow", "Select"))
self.ss7i73in_3.setText(_translate("mainWindow", "Select"))
self.ss7i73in_4.setText(_translate("mainWindow", "Select"))
self.ss7i73in_5.setText(_translate("mainWindow", "Select"))
self.ss7i73in_6.setText(_translate("mainWindow", "Select"))
self.ss7i73in_7.setText(_translate("mainWindow", "Select"))
self.ss7i73in_8.setText(_translate("mainWindow", "Select"))
self.ss7i73in_9.setText(_translate("mainWindow", "Select"))
self.ss7i73in_10.setText(_translate("mainWindow", "Select"))
self.ss7i73in_11.setText(_translate("mainWindow", "Select"))
self.ss7i73in_12.setText(_translate("mainWindow", "Select"))
self.ss7i73in_13.setText(_translate("mainWindow", "Select"))
self.ss7i73in_14.setText(_translate("mainWindow", "Select"))
self.ss7i73in_15.setText(_translate("mainWindow", "Select"))
self.ss7i73out_0.setText(_translate("mainWindow", "Select"))
self.ss7i73out_1.setText(_translate("mainWindow", "Select"))
self.groupBox_57.setTitle(_translate("mainWindow", "Keypad-LCD P1"))
self.ss7i73keylbl_0.setText(_translate("mainWindow", "Key 0"))
self.ss7i73lcdlbl_0.setText(_translate("mainWindow", "LCD 0"))
self.ss7i73keylbl_1.setText(_translate("mainWindow", "Key 1"))
self.ss7i73keylbl_2.setText(_translate("mainWindow", "Key 2"))
self.ss7i73keylbl_3.setText(_translate("mainWindow", "Key 3"))
self.ss7i73keylbl_4.setText(_translate("mainWindow", "Key 4"))
self.ss7i73keylbl_5.setText(_translate("mainWindow", "Key 5"))
self.ss7i73keylbl_6.setText(_translate("mainWindow", "Key 6"))
self.ss7i73keylbl_7.setText(_translate("mainWindow", "Key 7"))
self.ss7i73keylbl_8.setText(_translate("mainWindow", "Key 8"))
self.ss7i73keylbl_9.setText(_translate("mainWindow", "Key 9"))
self.ss7i73keylbl_10.setText(_translate("mainWindow", "Key 10"))
self.ss7i73keylbl_11.setText(_translate("mainWindow", "Key 11"))
self.ss7i73keylbl_12.setText(_translate("mainWindow", "Key 12"))
self.ss7i73keylbl_13.setText(_translate("mainWindow", "Key 13"))
self.ss7i73keylbl_14.setText(_translate("mainWindow", "Key 14"))
self.ss7i73keylbl_15.setText(_translate("mainWindow", "Key 15"))
self.ss7i73lcdlbl_1.setText(_translate("mainWindow", "LCD 1"))
self.ss7i73lcdlbl_2.setText(_translate("mainWindow", "LCD 2"))
self.ss7i73lcdlbl_3.setText(_translate("mainWindow", "LCD 3"))
self.ss7i73lcdlbl_4.setText(_translate("mainWindow", "LCD 4"))
self.ss7i73lcdlbl_5.setText(_translate("mainWindow", "LCD 5"))
self.ss7i73lcdlbl_6.setText(_translate("mainWindow", "LCD 6"))
self.ss7i73lcdlbl_7.setText(_translate("mainWindow", "LCD 7"))
self.ss7i73lcdlbl_8.setText(_translate("mainWindow", "LCD 8"))
self.ss7i73lcdlbl_9.setText(_translate("mainWindow", "LCD 9"))
self.ss7i73lcdlbl_10.setText(_translate("mainWindow", "LCD 10"))
self.ss7i73lcdlbl_11.setText(_translate("mainWindow", "LCD 11"))
self.ss7i73key_0.setText(_translate("mainWindow", "Select"))
self.ss7i73key_1.setText(_translate("mainWindow", "Select"))
self.ss7i73key_2.setText(_translate("mainWindow", "Select"))
self.ss7i73key_3.setText(_translate("mainWindow", "Select"))
self.ss7i73key_4.setText(_translate("mainWindow", "Select"))
self.ss7i73key_5.setText(_translate("mainWindow", "Select"))
self.ss7i73key_6.setText(_translate("mainWindow", "Select"))
self.ss7i73key_7.setText(_translate("mainWindow", "Select"))
self.ss7i73key_8.setText(_translate("mainWindow", "Select"))
self.ss7i73key_9.setText(_translate("mainWindow", "Select"))
self.ss7i73key_10.setText(_translate("mainWindow", "Select"))
self.ss7i73key_11.setText(_translate("mainWindow", "Select"))
self.ss7i73key_12.setText(_translate("mainWindow", "Select"))
self.ss7i73key_13.setText(_translate("mainWindow", "Select"))
self.ss7i73key_14.setText(_translate("mainWindow", "Select"))
self.ss7i73key_15.setText(_translate("mainWindow", "Select"))
self.ss7i73lcd_0.setText(_translate("mainWindow", "Select"))
self.ss7i73lcd_1.setText(_translate("mainWindow", "Select"))
self.ss7i73lcd_2.setText(_translate("mainWindow", "Select"))
self.ss7i73lcd_3.setText(_translate("mainWindow", "Select"))
self.ss7i73lcd_4.setText(_translate("mainWindow", "Select"))
self.ss7i73lcd_5.setText(_translate("mainWindow", "Select"))
self.ss7i73lcd_6.setText(_translate("mainWindow", "Select"))
self.ss7i73lcd_7.setText(_translate("mainWindow", "Select"))
self.ss7i73lcd_8.setText(_translate("mainWindow", "Select"))
self.ss7i73lcd_9.setText(_translate("mainWindow", "Select"))
self.ss7i73lcd_10.setText(_translate("mainWindow", "Select"))
self.ss7i73lcd_11.setText(_translate("mainWindow", "Select"))
self.groupBox_22.setTitle(_translate("mainWindow", "7i84"))
self.groupBox_26.setTitle(_translate("mainWindow", "Outputs 8 - 15 TB2"))
self.label_460.setText(_translate("mainWindow", "10"))
self.label_466.setText(_translate("mainWindow", "9"))
self.label_465.setText(_translate("mainWindow", "15"))
self.label_467.setText(_translate("mainWindow", "8"))
self.label_463.setText(_translate("mainWindow", "13"))
self.label_464.setText(_translate("mainWindow", "14"))
self.label_462.setText(_translate("mainWindow", "12"))
self.label_461.setText(_translate("mainWindow", "11"))
self.ss7i84out_8.setText(_translate("mainWindow", "Select"))
self.ss7i84out_9.setText(_translate("mainWindow", "Select"))
self.ss7i84out_10.setText(_translate("mainWindow", "Select"))
self.ss7i84out_11.setText(_translate("mainWindow", "Select"))
self.ss7i84out_12.setText(_translate("mainWindow", "Select"))
self.ss7i84out_13.setText(_translate("mainWindow", "Select"))
self.ss7i84out_14.setText(_translate("mainWindow", "Select"))
self.ss7i84out_15.setText(_translate("mainWindow", "Select"))
self.groupBox_23.setTitle(_translate("mainWindow", "Outputs 0 - 7 TB3"))
self.label_454.setText(_translate("mainWindow", "2"))
self.label_455.setText(_translate("mainWindow", "3"))
self.label_456.setText(_translate("mainWindow", "4"))
self.label_457.setText(_translate("mainWindow", "5"))
self.label_458.setText(_translate("mainWindow", "6"))
self.label_459.setText(_translate("mainWindow", "7"))
self.label_453.setText(_translate("mainWindow", "1"))
self.label_452.setText(_translate("mainWindow", "0"))
self.ss7i84out_0.setText(_translate("mainWindow", "Select"))
self.ss7i84out_1.setText(_translate("mainWindow", "Select"))
self.ss7i84out_2.setText(_translate("mainWindow", "Select"))
self.ss7i84out_3.setText(_translate("mainWindow", "Select"))
self.ss7i84out_4.setText(_translate("mainWindow", "Select"))
self.ss7i84out_5.setText(_translate("mainWindow", "Select"))
self.ss7i84out_6.setText(_translate("mainWindow", "Select"))
self.ss7i84out_7.setText(_translate("mainWindow", "Select"))
self.groupBox_24.setTitle(_translate("mainWindow", "Inputs 0 - 15 TB3"))
self.label_434.setText(_translate("mainWindow", "14"))
self.label_422.setText(_translate("mainWindow", "2"))
self.label_431.setText(_translate("mainWindow", "11"))
self.label_421.setText(_translate("mainWindow", "1"))
self.label_427.setText(_translate("mainWindow", "7"))
self.label_430.setText(_translate("mainWindow", "10"))
self.label_425.setText(_translate("mainWindow", "5"))
self.label_426.setText(_translate("mainWindow", "6"))
self.label_429.setText(_translate("mainWindow", "9"))
self.label_435.setText(_translate("mainWindow", "15"))
self.label_428.setText(_translate("mainWindow", "8"))
self.label_418.setText(_translate("mainWindow", "0"))
self.label_423.setText(_translate("mainWindow", "3"))
self.label_424.setText(_translate("mainWindow", "4"))
self.label_433.setText(_translate("mainWindow", "13"))
self.label_432.setText(_translate("mainWindow", "12"))
self.ss7i84in_0.setText(_translate("mainWindow", "Select"))
self.ss7i84in_1.setText(_translate("mainWindow", "Select"))
self.ss7i84in_2.setText(_translate("mainWindow", "Select"))
self.ss7i84in_3.setText(_translate("mainWindow", "Select"))
self.ss7i84in_4.setText(_translate("mainWindow", "Select"))
self.ss7i84in_5.setText(_translate("mainWindow", "Select"))
self.ss7i84in_6.setText(_translate("mainWindow", "Select"))
self.ss7i84in_7.setText(_translate("mainWindow", "Select"))
self.ss7i84in_8.setText(_translate("mainWindow", "Select"))
self.ss7i84in_9.setText(_translate("mainWindow", "Select"))
self.ss7i84in_10.setText(_translate("mainWindow", "Select"))
self.ss7i84in_11.setText(_translate("mainWindow", "Select"))
self.ss7i84in_12.setText(_translate("mainWindow", "Select"))
self.ss7i84in_13.setText(_translate("mainWindow", "Select"))
self.ss7i84in_14.setText(_translate("mainWindow", "Select"))
self.ss7i84in_15.setText(_translate("mainWindow", "Select"))
self.groupBox_25.setTitle(_translate("mainWindow", "Inputs 16 - 31 TB2"))
self.label_449.setText(_translate("mainWindow", "29"))
self.label_444.setText(_translate("mainWindow", "24"))
self.label_448.setText(_translate("mainWindow", "28"))
self.label_441.setText(_translate("mainWindow", "21"))
self.label_450.setText(_translate("mainWindow", "30"))
self.label_438.setText(_translate("mainWindow", "18"))
self.label_439.setText(_translate("mainWindow", "19"))
self.label_440.setText(_translate("mainWindow", "20"))
self.label_442.setText(_translate("mainWindow", "22"))
self.label_447.setText(_translate("mainWindow", "27"))
self.label_436.setText(_translate("mainWindow", "16"))
self.label_437.setText(_translate("mainWindow", "17"))
self.label_451.setText(_translate("mainWindow", "31"))
self.label_446.setText(_translate("mainWindow", "26"))
self.label_443.setText(_translate("mainWindow", "23"))
self.label_445.setText(_translate("mainWindow", "25"))
self.ss7i84in_16.setText(_translate("mainWindow", "Select"))
self.ss7i84in_17.setText(_translate("mainWindow", "Select"))
self.ss7i84in_18.setText(_translate("mainWindow", "Select"))
self.ss7i84in_19.setText(_translate("mainWindow", "Select"))
self.ss7i84in_20.setText(_translate("mainWindow", "Select"))
self.ss7i84in_21.setText(_translate("mainWindow", "Select"))
self.ss7i84in_22.setText(_translate("mainWindow", "Select"))
self.ss7i84in_23.setText(_translate("mainWindow", "Select"))
self.ss7i84in_24.setText(_translate("mainWindow", "Select"))
self.ss7i84in_25.setText(_translate("mainWindow", "Select"))
self.ss7i84in_26.setText(_translate("mainWindow", "Select"))
self.ss7i84in_27.setText(_translate("mainWindow", "Select"))
self.ss7i84in_28.setText(_translate("mainWindow", "Select"))
self.ss7i84in_29.setText(_translate("mainWindow", "Select"))
self.ss7i84in_30.setText(_translate("mainWindow", "Select"))
self.ss7i84in_31.setText(_translate("mainWindow", "Select"))
self.groupBox_38.setTitle(_translate("mainWindow", "7i87"))
self.groupBox_55.setTitle(_translate("mainWindow", "Analog Inputs 0 - 7 TB2"))
self.label_573.setText(_translate("mainWindow", "2"))
self.label_723.setText(_translate("mainWindow", "6"))
self.label_731.setText(_translate("mainWindow", "5"))
self.label_417.setText(_translate("mainWindow", "0"))
self.label_732.setText(_translate("mainWindow", "3"))
self.label_725.setText(_translate("mainWindow", "4"))
self.label_727.setText(_translate("mainWindow", "7"))
self.label_724.setText(_translate("mainWindow", "1"))
self.ss7i87in_0.setText(_translate("mainWindow", "Select"))
self.ss7i87in_1.setText(_translate("mainWindow", "Select"))
self.ss7i87in_2.setText(_translate("mainWindow", "Select"))
self.ss7i87in_3.setText(_translate("mainWindow", "Select"))
self.ss7i87in_4.setText(_translate("mainWindow", "Select"))
self.ss7i87in_5.setText(_translate("mainWindow", "Select"))
self.ss7i87in_6.setText(_translate("mainWindow", "Select"))
self.ss7i87in_7.setText(_translate("mainWindow", "Select"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2), _translate("mainWindow", "SS Cards"))
self.manualToolChangeCB.setText(_translate("mainWindow", "On Screen Prompt for Manual Tool Change"))
self.label_107.setText(_translate("mainWindow", "Debug Options"))
self.servoPeriodSB.setSuffix(_translate("mainWindow", "us"))
self.label_211.setText(_translate("mainWindow", "Thread Period"))
self.groupBox_6.setTitle(_translate("mainWindow", "HAL Options"))
self.shutdownCB.setText(_translate("mainWindow", "Shutdown HAL File"))
self.customhalCB.setText(_translate("mainWindow", "Custom HAL File"))
self.postguiCB.setText(_translate("mainWindow", "Post GUI HAL File"))
self.haluiCB.setText(_translate("mainWindow", "Halui User Interface"))
self.groupBox_10.setTitle(_translate("mainWindow", "VCP Panels"))
self.pyvcpCB.setText(_translate("mainWindow", "PyVCP Panel"))
self.gladevcpCB.setText(_translate("mainWindow", "GladeVCP Panel"))
self.label_359.setText(_translate("mainWindow", "If you change the Thread Period reload PID values"))
self.groupBox_14.setTitle(_translate("mainWindow", "Splash Screen"))
self.label_360.setText(_translate("mainWindow", "Display Seconds"))
self.label_361.setText(_translate("mainWindow", "Intro Graphic"))
self.introGraphicLE.setText(_translate("mainWindow", "emc2.gif"))
self.label_358.setText(_translate("mainWindow", "0 for no Intro Graphic"))
self.groupBox1.setTitle(_translate("mainWindow", "Homing Options"))
self.noforcehomingCB.setText(_translate("mainWindow", "No Force Homing"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.options), _translate("mainWindow", "Options"))
self.ladderGB.setTitle(_translate("mainWindow", "ClassicLadder PLC"))
self.label_155.setText(_translate("mainWindow", "20"))
self.label_143.setText(_translate("mainWindow", "Rungs"))
self.label_147.setText(_translate("mainWindow", "Monostables"))
self.ladderWordsSB.setProperty("option", _translate("mainWindow", "numWords"))
self.ladderWordsSB.setProperty("item", _translate("mainWindow", "LADDER_WORDS"))
self.label_153.setText(_translate("mainWindow", "100"))
self.label_148.setText(_translate("mainWindow", "HAL Inputs"))
self.ladderTimersSB.setProperty("option", _translate("mainWindow", "numTimers"))
self.ladderTimersSB.setProperty("item", _translate("mainWindow", "LADDER_TIMERS"))
self.ladderRungsSB.setProperty("option", _translate("mainWindow", "numRungs"))
self.ladderRungsSB.setProperty("item", _translate("mainWindow", "LADDER_RUNGS"))
self.label_146.setText(_translate("mainWindow", "Timers"))
self.ladderInputsSB.setProperty("option", _translate("mainWindow", "numPhysInputs"))
self.ladderInputsSB.setProperty("item", _translate("mainWindow", "LADDER_HAL_INPUTS"))
self.label_154.setText(_translate("mainWindow", "Default"))
self.label_157.setText(_translate("mainWindow", "10"))
self.iecTimerSB.setProperty("option", _translate("mainWindow", "numTimersIec"))
self.iecTimerSB.setProperty("item", _translate("mainWindow", "LADDER_IEC_TIMERS"))
self.label_149.setText(_translate("mainWindow", "HAL Outputs"))
self.label_144.setText(_translate("mainWindow", "Bits"))
self.ladderOutputsSB.setProperty("option", _translate("mainWindow", "numPhysOutputs"))
self.ladderOutputsSB.setProperty("item", _translate("mainWindow", "LADDER_HAL_OUTPUTS"))
self.label_159.setText(_translate("mainWindow", "10"))
self.ladderSectionsSB.setProperty("option", _translate("mainWindow", "numSections"))
self.ladderSectionsSB.setProperty("item", _translate("mainWindow", "LADDER_SECTIONS"))
self.label_165.setText(_translate("mainWindow", "Counters"))
self.label_166.setText(_translate("mainWindow", "10"))
self.label_151.setText(_translate("mainWindow", "Sections"))
self.label_145.setText(_translate("mainWindow", "Words"))
self.ladderExpresionsSB.setProperty("option", _translate("mainWindow", "numArithmExpr"))
self.ladderExpresionsSB.setProperty("item", _translate("mainWindow", "LADDER_EXPRESSIONS"))
self.label_161.setText(_translate("mainWindow", "15"))
self.label_160.setText(_translate("mainWindow", "10"))
self.ladderBitsSB.setProperty("option", _translate("mainWindow", "numBits"))
self.ladderBitsSB.setProperty("item", _translate("mainWindow", "LADDER_BITS"))
self.ladderMonostablesSB.setProperty("option", _translate("mainWindow", "numMonostables"))
self.ladderMonostablesSB.setProperty("item", _translate("mainWindow", "LADDER_MONOSTABLES"))
self.label_150.setText(_translate("mainWindow", "Arithmatic Expresions"))
self.label_163.setText(_translate("mainWindow", "50"))
self.label_162.setText(_translate("mainWindow", "15"))
self.ladderCountersSB.setProperty("option", _translate("mainWindow", "numCounters"))
self.ladderCountersSB.setProperty("item", _translate("mainWindow", "LADDER_COUNTERS"))
self.label_164.setText(_translate("mainWindow", "10"))
self.label_168.setText(_translate("mainWindow", "S32 Inputs"))
self.label_170.setText(_translate("mainWindow", "Float Inputs"))
self.label_158.setText(_translate("mainWindow", "IEC Timers"))
self.label_156.setText(_translate("mainWindow", "20"))
self.label_167.setText(_translate("mainWindow", "Symbols"))
self.label_169.setText(_translate("mainWindow", "S32 Outputs"))
self.label_171.setText(_translate("mainWindow", "Float Outputs"))
self.ladderSymbolsSB.setProperty("option", _translate("mainWindow", "numSymbols"))
self.ladderSymbolsSB.setProperty("item", _translate("mainWindow", "LADDER_SYMBOLS"))
self.ladderS32InputsSB.setProperty("option", _translate("mainWindow", "numS32in"))
self.ladderS32InputsSB.setProperty("item", _translate("mainWindow", "LADDER_S32_INPUTS"))
self.ladderS32OuputsSB.setProperty("option", _translate("mainWindow", "numS32out"))
self.ladderS32OuputsSB.setProperty("item", _translate("mainWindow", "LADDER_S32_OUTPUTS"))
self.ladderFloatInputsSB.setProperty("option", _translate("mainWindow", "numFloatIn"))
self.ladderFloatInputsSB.setProperty("item", _translate("mainWindow", "LADDER_FLOAT_INPUTS"))
self.ladderFloatOutputsSB.setProperty("option", _translate("mainWindow", "numFloatOut"))
self.ladderFloatOutputsSB.setProperty("item", _translate("mainWindow", "LADDER_FLOAT_OUTPUTS"))
self.label_172.setText(_translate("mainWindow", "Auto"))
self.label_173.setText(_translate("mainWindow", "10"))
self.label_174.setText(_translate("mainWindow", "10"))
self.label_175.setText(_translate("mainWindow", "10"))
self.label_176.setText(_translate("mainWindow", "10"))
self.label_177.setText(_translate("mainWindow", "Optional Settings"))
self.label_152.setText(_translate("mainWindow", "Leave at 0 for default settings to be used"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.plc), _translate("mainWindow", "PLC"))
self.gridGroupBox_3.setTitle(_translate("mainWindow", "TB3 Analog Drive Interface"))
self.label_363.setText(_translate("mainWindow", "Pin 22"))
self.label_364.setText(_translate("mainWindow", "Pin 24"))
self.label_365.setText(_translate("mainWindow", "Pin 16"))
self.label_366.setText(_translate("mainWindow", "Pin 19"))
self.label_367.setText(_translate("mainWindow", "Pin 9"))
self.label_368.setText(_translate("mainWindow", "Pin 20"))
self.label_369.setText(_translate("mainWindow", "Pin 13"))
self.label_370.setText(_translate("mainWindow", "Pin 15"))
self.label_371.setText(_translate("mainWindow", "Pin 11"))
self.label_372.setText(_translate("mainWindow", "Pin 8"))
self.label_373.setText(_translate("mainWindow", "Pin 18"))
self.label_374.setText(_translate("mainWindow", "Pin 12"))
self.label_375.setText(_translate("mainWindow", "Pin 23"))
self.label_376.setText(_translate("mainWindow", "Pin 14"))
self.label_377.setText(_translate("mainWindow", "Pin 21"))
self.label_378.setText(_translate("mainWindow", "Pin 7"))
self.label_379.setText(_translate("mainWindow", "Pin 6"))
self.label_380.setText(_translate("mainWindow", "Pin 5"))
self.label_381.setText(_translate("mainWindow", "Pin 4"))
self.label_382.setText(_translate("mainWindow", "Pin 3"))
self.label_383.setText(_translate("mainWindow", "Pin 2"))
self.label_384.setText(_translate("mainWindow", "Pin 1"))
self.label_385.setText(_translate("mainWindow", "Pin 10"))
self.label_386.setText(_translate("mainWindow", "Pin 17"))
self.label_387.setText(_translate("mainWindow", "AOUT5"))
self.label_388.setText(_translate("mainWindow", "Ground"))
self.label_389.setText(_translate("mainWindow", "ENA5+"))
self.label_390.setText(_translate("mainWindow", "ENA5-"))
self.label_391.setText(_translate("mainWindow", "AOUT4"))
self.label_392.setText(_translate("mainWindow", "Ground"))
self.label_393.setText(_translate("mainWindow", "ENA4+"))
self.label_394.setText(_translate("mainWindow", "ENA4-"))
self.label_395.setText(_translate("mainWindow", "AOUT3"))
self.label_396.setText(_translate("mainWindow", "Ground"))
self.label_397.setText(_translate("mainWindow", "ENA3+"))
self.label_398.setText(_translate("mainWindow", "ENA3-"))
self.label_399.setText(_translate("mainWindow", "AOUT2"))
self.label_400.setText(_translate("mainWindow", "Ground"))
self.label_401.setText(_translate("mainWindow", "ENA2+"))
self.label_402.setText(_translate("mainWindow", "ENA2-"))
self.label_403.setText(_translate("mainWindow", "AOUT1"))
self.label_404.setText(_translate("mainWindow", "Ground"))
self.label_405.setText(_translate("mainWindow", "ENA6+"))
self.label_406.setText(_translate("mainWindow", "ENA1-"))
self.label_407.setText(_translate("mainWindow", "AOUT0"))
self.label_408.setText(_translate("mainWindow", "Ground"))
self.label_409.setText(_translate("mainWindow", "ENA0+"))
self.label_410.setText(_translate("mainWindow", "ENA0-"))
self.gridGroupBox_5.setTitle(_translate("mainWindow", "TB4 Inputs, RS422, 5V"))
self.label_774.setText(_translate("mainWindow", "Pin 22"))
self.label_775.setText(_translate("mainWindow", "Pin 24"))
self.label_776.setText(_translate("mainWindow", "Pin 16"))
self.label_777.setText(_translate("mainWindow", "Pin 19"))
self.label_778.setText(_translate("mainWindow", "Pin 9"))
self.label_779.setText(_translate("mainWindow", "Pin 20"))
self.label_780.setText(_translate("mainWindow", "Pin 13"))
self.label_781.setText(_translate("mainWindow", "Pin 15"))
self.label_782.setText(_translate("mainWindow", "Pin 11"))
self.label_783.setText(_translate("mainWindow", "Pin 8"))
self.label_784.setText(_translate("mainWindow", "Pin 18"))
self.label_785.setText(_translate("mainWindow", "Pin 12"))
self.label_786.setText(_translate("mainWindow", "Pin 23"))
self.label_787.setText(_translate("mainWindow", "Pin 14"))
self.label_788.setText(_translate("mainWindow", "Pin 21"))
self.label_789.setText(_translate("mainWindow", "Pin 7"))
self.label_790.setText(_translate("mainWindow", "Pin 6"))
self.label_791.setText(_translate("mainWindow", "Pin 5"))
self.label_792.setText(_translate("mainWindow", "Pin 4"))
self.label_793.setText(_translate("mainWindow", "Pin 3"))
self.label_794.setText(_translate("mainWindow", "Pin 2"))
self.label_795.setText(_translate("mainWindow", "Pin 1"))
self.label_796.setText(_translate("mainWindow", "Pin 10"))
self.label_797.setText(_translate("mainWindow", "Pin 17"))
self.label_798.setText(_translate("mainWindow", "Ground"))
self.label_799.setText(_translate("mainWindow", "Ground"))
self.label_800.setText(_translate("mainWindow", "+5V"))
self.label_801.setText(_translate("mainWindow", "+5V"))
self.label_802.setText(_translate("mainWindow", "+5VP"))
self.label_803.setText(_translate("mainWindow", "+5VP"))
self.label_804.setText(_translate("mainWindow", "RX-422/485 TX-"))
self.label_805.setText(_translate("mainWindow", "RX-422/485 TX+"))
self.label_806.setText(_translate("mainWindow", "RX-422/485 RX-"))
self.label_807.setText(_translate("mainWindow", "RX-422/485 RX+"))
self.label_808.setText(_translate("mainWindow", "Ground"))
self.label_809.setText(_translate("mainWindow", "Ground"))
self.label_810.setText(_translate("mainWindow", "IN COMMON 6.7"))
self.label_811.setText(_translate("mainWindow", "IN7"))
self.label_812.setText(_translate("mainWindow", "IN6"))
self.label_813.setText(_translate("mainWindow", "IN COMMON 4,5"))
self.label_814.setText(_translate("mainWindow", "IN5"))
self.label_815.setText(_translate("mainWindow", "IN4"))
self.label_816.setText(_translate("mainWindow", "IN COMMON 2.3"))
self.label_817.setText(_translate("mainWindow", "IN3"))
self.label_818.setText(_translate("mainWindow", "IN2"))
self.label_819.setText(_translate("mainWindow", "IN COMMON 0,1"))
self.label_820.setText(_translate("mainWindow", "IN1"))
self.label_821.setText(_translate("mainWindow", "IN0"))
self.gridGroupBox_2.setTitle(_translate("mainWindow", "TB2 Encoders 3 - 5"))
self.label_329.setText(_translate("mainWindow", "Pin 21"))
self.label_319.setText(_translate("mainWindow", "Pin 9"))
self.label_351.setText(_translate("mainWindow", "QB4"))
self.label_355.setText(_translate("mainWindow", "/IDX3"))
self.label_341.setText(_translate("mainWindow", "+5v"))
self.label_350.setText(_translate("mainWindow", "/QB4"))
self.label_362.setText(_translate("mainWindow", "QA3"))
self.label_336.setText(_translate("mainWindow", "Pin 1"))
self.label_345.setText(_translate("mainWindow", "/QA5"))
self.label_315.setText(_translate("mainWindow", "Pin 22"))
self.label_340.setText(_translate("mainWindow", "IDX5"))
self.tb2p5LB.setText(_translate("mainWindow", "/QB3"))
self.label_357.setText(_translate("mainWindow", "+5v"))
self.label_325.setText(_translate("mainWindow", "Pin 18"))
self.label_346.setText(_translate("mainWindow", "QA5"))
self.label_337.setText(_translate("mainWindow", "Pin 10"))
self.label_316.setText(_translate("mainWindow", "Pin 24"))
self.label_354.setText(_translate("mainWindow", "Ground"))
self.label_353.setText(_translate("mainWindow", "QA4"))
self.label_352.setText(_translate("mainWindow", "/QA4"))
self.label_335.setText(_translate("mainWindow", "Pin 2"))
self.label_317.setText(_translate("mainWindow", "Pin 16"))
self.label_321.setText(_translate("mainWindow", "Pin 13"))
self.label_342.setText(_translate("mainWindow", "/QB5"))
self.label_327.setText(_translate("mainWindow", "Pin 23"))
self.label_330.setText(_translate("mainWindow", "Pin 7"))
self.label_320.setText(_translate("mainWindow", "Pin 20"))
self.label_332.setText(_translate("mainWindow", "Pin 5"))
self.label_349.setText(_translate("mainWindow", "+5v"))
self.label_324.setText(_translate("mainWindow", "Pin 8"))
self.label_331.setText(_translate("mainWindow", "Pin 6"))
self.label_339.setText(_translate("mainWindow", "/IDX5"))
self.label_348.setText(_translate("mainWindow", "IDX4"))
self.label_343.setText(_translate("mainWindow", "QB5"))
self.label_322.setText(_translate("mainWindow", "Pin 15"))
self.label_318.setText(_translate("mainWindow", "Pin 19"))
self.label_323.setText(_translate("mainWindow", "Pin 11"))
self.tb2p2LB.setText(_translate("mainWindow", "/QA3"))
self.tb2p3LB.setText(_translate("mainWindow", "Ground"))
self.tb2p4LB.setText(_translate("mainWindow", "QB3"))
self.label_344.setText(_translate("mainWindow", "Ground"))
self.label_338.setText(_translate("mainWindow", "Pin 17"))
self.label_334.setText(_translate("mainWindow", "Pin 3"))
self.label_333.setText(_translate("mainWindow", "Pin 4"))
self.label_356.setText(_translate("mainWindow", "IDX3"))
self.label_328.setText(_translate("mainWindow", "Pin 14"))
self.label_326.setText(_translate("mainWindow", "Pin 12"))
self.label_347.setText(_translate("mainWindow", "/IDX4"))
self.gridGroupBox10.setTitle(_translate("mainWindow", "TB1 Encoders 0 - 2"))
self.label_223.setText(_translate("mainWindow", "Pin 22"))
self.label_212.setText(_translate("mainWindow", "Pin 24"))
self.label_275.setText(_translate("mainWindow", "Pin 16"))
self.label_251.setText(_translate("mainWindow", "Pin 19"))
self.label_282.setText(_translate("mainWindow", "Pin 9"))
self.label_241.setText(_translate("mainWindow", "Pin 20"))
self.label_278.setText(_translate("mainWindow", "Pin 13"))
self.label_276.setText(_translate("mainWindow", "Pin 15"))
self.label_280.setText(_translate("mainWindow", "Pin 11"))
self.label_283.setText(_translate("mainWindow", "Pin 8"))
self.label_261.setText(_translate("mainWindow", "Pin 18"))
self.label_279.setText(_translate("mainWindow", "Pin 12"))
self.label_213.setText(_translate("mainWindow", "Pin 23"))
self.label_277.setText(_translate("mainWindow", "Pin 14"))
self.label_231.setText(_translate("mainWindow", "Pin 21"))
self.label_284.setText(_translate("mainWindow", "Pin 7"))
self.label_285.setText(_translate("mainWindow", "Pin 6"))
self.label_286.setText(_translate("mainWindow", "Pin 5"))
self.label_287.setText(_translate("mainWindow", "Pin 4"))
self.label_288.setText(_translate("mainWindow", "Pin 3"))
self.label_289.setText(_translate("mainWindow", "Pin 2"))
self.label_290.setText(_translate("mainWindow", "Pin 1"))
self.label_281.setText(_translate("mainWindow", "Pin 10"))
self.label_274.setText(_translate("mainWindow", "Pin 17"))
self.label_291.setText(_translate("mainWindow", "/IDX2"))
self.tb1p23LB.setText(_translate("mainWindow", "IDX2"))
self.tb1p22LB.setText(_translate("mainWindow", "+5v"))
self.tb1p21LB.setText(_translate("mainWindow", "/QB2"))
self.tb1p20LB.setText(_translate("mainWindow", "QB2"))
self.label_296.setText(_translate("mainWindow", "Ground"))
self.label_297.setText(_translate("mainWindow", "/QA2"))
self.label_298.setText(_translate("mainWindow", "QA2"))
self.label_299.setText(_translate("mainWindow", "/IDX1"))
self.label_300.setText(_translate("mainWindow", "IDX1"))
self.label_301.setText(_translate("mainWindow", "+5v"))
self.label_302.setText(_translate("mainWindow", "/QB1"))
self.label_303.setText(_translate("mainWindow", "QB1"))
self.label_304.setText(_translate("mainWindow", "Ground"))
self.label_305.setText(_translate("mainWindow", "/QA1"))
self.label_306.setText(_translate("mainWindow", "QA1"))
self.label_307.setText(_translate("mainWindow", "/IDX0"))
self.label_308.setText(_translate("mainWindow", "IDX0"))
self.label_309.setText(_translate("mainWindow", "+5v"))
self.label_310.setText(_translate("mainWindow", "/QB0"))
self.label_311.setText(_translate("mainWindow", "QB0"))
self.label_312.setText(_translate("mainWindow", "Ground"))
self.label_313.setText(_translate("mainWindow", "/QA0"))
self.label_314.setText(_translate("mainWindow", "QA0"))
self.gridGroupBox_6.setTitle(_translate("mainWindow", "TB5 inputs/Outputs"))
self.label_822.setText(_translate("mainWindow", "Pin 22"))
self.label_823.setText(_translate("mainWindow", "Pin 24"))
self.label_824.setText(_translate("mainWindow", "Pin 16"))
self.label_825.setText(_translate("mainWindow", "Pin 19"))
self.label_826.setText(_translate("mainWindow", "Pin 9"))
self.label_827.setText(_translate("mainWindow", "Pin 20"))
self.label_828.setText(_translate("mainWindow", "Pin 13"))
self.label_829.setText(_translate("mainWindow", "Pin 15"))
self.label_830.setText(_translate("mainWindow", "Pin 11"))
self.label_831.setText(_translate("mainWindow", "Pin 8"))
self.label_832.setText(_translate("mainWindow", "Pin 18"))
self.label_833.setText(_translate("mainWindow", "Pin 12"))
self.label_834.setText(_translate("mainWindow", "Pin 23"))
self.label_835.setText(_translate("mainWindow", "Pin 14"))
self.label_836.setText(_translate("mainWindow", "Pin 21"))
self.label_837.setText(_translate("mainWindow", "Pin 7"))
self.label_838.setText(_translate("mainWindow", "Pin 6"))
self.label_839.setText(_translate("mainWindow", "Pin 5"))
self.label_840.setText(_translate("mainWindow", "Pin 4"))
self.label_841.setText(_translate("mainWindow", "Pin 3"))
self.label_842.setText(_translate("mainWindow", "Pin 2"))
self.label_843.setText(_translate("mainWindow", "Pin 1"))
self.label_844.setText(_translate("mainWindow", "Pin 10"))
self.label_845.setText(_translate("mainWindow", "Pin 17"))
self.label_846.setText(_translate("mainWindow", "OUT5+"))
self.tb1p23LB_2.setText(_translate("mainWindow", "OUT5-"))
self.tb1p22LB_2.setText(_translate("mainWindow", "OUT4+"))
self.tb1p21LB_2.setText(_translate("mainWindow", "OUT4-"))
self.tb1p20LB_2.setText(_translate("mainWindow", "OUT3+"))
self.label_847.setText(_translate("mainWindow", "OUT3-"))
self.label_848.setText(_translate("mainWindow", "OUT2+"))
self.label_849.setText(_translate("mainWindow", "OUT2-"))
self.label_850.setText(_translate("mainWindow", "OUT1+"))
self.label_851.setText(_translate("mainWindow", "OUT1-"))
self.label_852.setText(_translate("mainWindow", "OUT0+"))
self.label_853.setText(_translate("mainWindow", "OUT0-"))
self.label_854.setText(_translate("mainWindow", "IN COMMON 14,15"))
self.label_855.setText(_translate("mainWindow", "IN15"))
self.label_856.setText(_translate("mainWindow", "IN14"))
self.label_857.setText(_translate("mainWindow", "IN COMMON 12,13"))
self.label_858.setText(_translate("mainWindow", "IN13"))
self.label_859.setText(_translate("mainWindow", "IN12"))
self.label_860.setText(_translate("mainWindow", "IN COMMON 10.11"))
self.label_861.setText(_translate("mainWindow", "IN11"))
self.label_862.setText(_translate("mainWindow", "IN10"))
self.label_863.setText(_translate("mainWindow", "IN COMMON 8,9"))
self.label_864.setText(_translate("mainWindow", "IN9"))
self.label_865.setText(_translate("mainWindow", "IN8"))
self.tabWidget_2.setTabText(self.tabWidget_2.indexOf(self.tab_4), _translate("mainWindow", "Terminals"))
self.cardPinsPB.setText(_translate("mainWindow", "Get Card Pinout"))
self.tabWidget_2.setTabText(self.tabWidget_2.indexOf(self.tab_5), _translate("mainWindow", "Card Output"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.pins), _translate("mainWindow", "Pins"))
self.label_103.setText(_translate("mainWindow", "TextLabel"))
self.tabWidget_3.setTabText(self.tabWidget_3.indexOf(self.tab_6), _translate("mainWindow", "7i76e"))
self.cpuPB.setToolTip(_translate("mainWindow", "Central Processing Unit"))
self.cpuPB.setText(_translate("mainWindow", "CPU"))
self.nicPB.setToolTip(_translate("mainWindow", "<html><head/><body><p>Network Interface Card</p></body></html>"))
self.nicPB.setText(_translate("mainWindow", "NIC"))
self.copyInfoPB.setText(_translate("mainWindow", "Copy"))
self.tabWidget_3.setTabText(self.tabWidget_3.indexOf(self.tab_7), _translate("mainWindow", "PC"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.info), _translate("mainWindow", "Info"))
self.gridGroupBox11.setTitle(_translate("mainWindow", "NIC Test"))
self.label_199.setText(_translate("mainWindow", "CPU Speed"))
self.label_200.setText(_translate("mainWindow", "tMax"))
self.calcNicPB.setText(_translate("mainWindow", "Calculate"))
self.label_206.setText(_translate("mainWindow", "Threshold"))
self.label_203.setText(_translate("mainWindow", "Packet Time"))
self.label_204.setText(_translate("mainWindow", "Packet Time must be less than Threshold"))
self.label_51.setText(_translate("mainWindow", "sudo dmidecode | grep MHz"))
self.label_295.setText(_translate("mainWindow", "<html><head/><body><p>In a terminal run this to get CPU speed</p></body></html>"))
self.readTmaxPB.setToolTip(_translate("mainWindow", "<html><head/><body><p>LinuxCNC must be running</p><p>the configuration</p></body></html>"))
self.readTmaxPB.setText(_translate("mainWindow", "Read tMax"))
self.label_210.setText(_translate("mainWindow", "<html><head/><body><p>Packet Time and Threshold are<br/>are in units of servo thread period.<br/>If the Packet Time is greater than 50%<br/>try increasing the thread period.</p></body></html>"))
self.label_294.setText(_translate("mainWindow", "<html><head/><body><p>The 7i97 must be connected and LinuxCNC running a<br/>7i97 configuration before trying to read tMax.</p></body></html>"))
self.testMePB.setText(_translate("mainWindow", "Test Me"))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.pc), _translate("mainWindow", "PC"))
self.menuFile.setTitle(_translate("mainWindow", "Fi&le"))
self.menuTools.setTitle(_translate("mainWindow", "&Tools"))
self.menuHelp.setTitle(_translate("mainWindow", "Help"))
self.menuEdit.setTitle(_translate("mainWindow", "Edit"))
self.menuLanguage.setTitle(_translate("mainWindow", "Language"))
self.toolBar.setWindowTitle(_translate("mainWindow", "toolBar"))
self.actionNew.setText(_translate("mainWindow", "&New"))
self.actionOpen.setText(_translate("mainWindow", "&Open an INI File"))
self.actionSave.setText(_translate("mainWindow", "&Save"))
self.actionSaveAs.setText(_translate("mainWindow", "Sa&ve As"))
self.actionExit.setText(_translate("mainWindow", "&Exit"))
self.actionCheck.setText(_translate("mainWindow", "&Check Configuration"))
self.actionAbout.setText(_translate("mainWindow", "&About"))
self.actionBuild.setText(_translate("mainWindow", "&Build Configuration"))
self.actionTabHelp.setText(_translate("mainWindow", "&Tab Help"))
self.actionTabHelp.setShortcut(_translate("mainWindow", "F1"))
self.actionBuildHelp.setText(_translate("mainWindow", "&Build Help"))
self.actionPCHelp.setText(_translate("mainWindow", "&PC Help"))
self.actionSavePins.setText(_translate("mainWindow", "Save Pins"))
self.actionSavePins.setToolTip(_translate("mainWindow", "Save HAL Pins to a File"))
self.actionSaveSignals.setText(_translate("mainWindow", "Save Signals"))
self.actionSaveSignals.setToolTip(_translate("mainWindow", "Save HAL Signals to a File"))
self.actionSaveParameters.setText(_translate("mainWindow", "Save Parameters"))
self.actionOpen7i97.setText(_translate("mainWindow", "Open 7i97"))
self.actionEnglish.setText(_translate("mainWindow", "English"))
self.actionGerman.setText(_translate("mainWindow", "Deutsch"))
```
|
{
"source": "jethornton/bp_touch",
"score": 3
}
|
#### File: bp_touch/bp_touch/mainwindow.py
```python
from qtpyvcp.widgets.form_widgets.main_window import VCPMainWindow
# Setup logging
from qtpyvcp.utilities import logger
LOG = logger.getLogger('qtpyvcp.' + __name__)
class MyMainWindow(VCPMainWindow):
"""Main window class for the VCP."""
def __init__(self, *args, **kwargs):
super(MyMainWindow, self).__init__(*args, **kwargs)
self.offsetButtonGroup.buttonClicked.connect(self.offsetHandleKeys)
self.mdiButtonGroup.buttonClicked.connect(self.mdiHandleKeys)
self.mdiBackSpaceKey.clicked.connect(self.mdiBackSpace)
self.toolOffsetGroup.buttonClicked.connect(self.toolHandleKeys)
self.toolOffsetBackspace.clicked.connect(self.toolBackSpace)
def on_exitButton_clicked(self):
self.app.quit()
def offsetHandleKeys(self, button):
char = str(button.text())
text = self.offsetLabel.text() or '0'
if text != '0':
text += char
else:
text = char
self.offsetLabel.setText(text)
def mdiHandleKeys(self, button):
char = str(button.text())
text = self.mdiEntry.text() or '0'
if text != '0':
text += char
else:
text = char
self.mdiEntry.setText(text)
def mdiBackSpace(self):
if len(self.mdiEntry.text()) > 0:
text = self.mdiEntry.text()[:-1]
self.mdiEntry.setText(text)
def toolHandleKeys(self, button):
text = self.toolOffsetLabel.text()
if len(text) > 0:
self.toolOffsetLabel.setText(text + button.text())
else:
self.toolOffsetLabel.setText(button.text())
def toolBackSpace(self):
text = self.toolOffsetLabel.text()[:-1]
self.toolOffsetLabel.setText(text)
```
|
{
"source": "jethornton/chicken-automation",
"score": 3
}
|
#### File: coop2/bin/thread.py
```python
import RPi.GPIO as GPIO
from time import sleep
import threading
# basackwards relay setup
RUN = False
STOP = True
# setup I/O Constants
DOOR_UP = 4
DOOR_DOWN = 5
DOOR_LOCK = 6
LIGHTS = 7
MAN_UP = 22
MAN_DOWN = 23
MAN_LIGHT = 24
UP_PROX = 26
DOWN_PROX = 27
# setup I/O
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(DOOR_UP, GPIO.OUT) # Motor FWD
GPIO.output(DOOR_UP, STOP)
GPIO.setup(DOOR_DOWN, GPIO.OUT) # Motor REV
GPIO.output(DOOR_DOWN, STOP)
GPIO.setup(DOOR_LOCK, GPIO.OUT) # Door Lock
GPIO.output(DOOR_LOCK, STOP)
GPIO.setup(LIGHTS, GPIO.OUT) # Lights
GPIO.output(LIGHTS, STOP)
GPIO.setup(MAN_UP, GPIO.IN,pull_up_down=GPIO.PUD_DOWN) # Manual Up Switch
GPIO.setup(MAN_DOWN, GPIO.IN,pull_up_down=GPIO.PUD_DOWN) # Manual Down Switch
GPIO.setup(MAN_LIGHT, GPIO.IN,pull_up_down=GPIO.PUD_DOWN) # Manual Light Switch
GPIO.setup(UP_PROX, GPIO.IN,pull_up_down=GPIO.PUD_DOWN) # Door Up Switch
GPIO.setup(DOWN_PROX, GPIO.IN,pull_up_down=GPIO.PUD_DOWN) # Door Down Switch
def open():
print('open')
try:
to = threading.Timer(1.0, open)
while True:
if GPIO.input(DOOR_UP):
to.start()
else:
to.stop()
sleep(0.1)
except KeyboardInterrupt:
# here you put any code you want to run before the program
# exits when you press CTRL+C
print('\nKeyBoard Interrupt')
except Exception as e:
# this covers all other exceptions
print(str(e))
finally:
GPIO.cleanup() # this ensures a clean exit
```
|
{
"source": "jethornton/coop4",
"score": 3
}
|
#### File: jethornton/coop4/libcoop.py
```python
class Ledfade:
def __init__(self, *args, **kwargs):
if 'start' in kwargs:
self.start = kwargs.get('start')
if 'end' in kwargs:
self.end = kwargs.get('end')
if 'action' in kwargs:
self.action = kwargs.get('action')
self.transit = self.end - self.start
def ledpwm(self, p):
c = 0.181+(0.0482*p)+(0.00323*p*p)+(0.0000629*p*p*p)
if c < 0.0:
return 0
if c > 0.0 and c <= 100.0:
return c
elif c > 100.0:
return 100
def update(self, now):
if self.action == 'sunrise':
return self.ledpwm(((now - self.start) / self.transit) * 100)
elif self.action == 'sunset':
return self.ledpwm(100 - ((now - self.start) / self.transit) * 100)
```
|
{
"source": "jethornton/dxf2plasma",
"score": 2
}
|
#### File: src/lib/stuff.py
```python
def test():
return 'This is a test'
def title():
return 'PyQt5 Simple Example'
```
#### File: dxf2plasma/src/ogl5.py
```python
import sys
from OpenGL.GL import *
from OpenGL.GLU import *
from PyQt5 import QtGui
from PyQt5.QtOpenGL import *
from PyQt5 import QtCore, QtWidgets, QtOpenGL
class Ui_MainWindow(QtOpenGL.QGLWidget):
def __init__(self, parent=None):
super(Ui_MainWindow, self).__init__()
self.widget = QtWidgets.QOpenGLWidget(self)
self.button = QtWidgets.QPushButton('Test', self)
mainLayout = QtWidgets.QHBoxLayout()
mainLayout.addWidget(self.widget)
mainLayout.addWidget(self.button)
self.setLayout(mainLayout)
class glWidget(QGLWidget):
def __init__(self, parent=None):
QGLWidget.__init__(self, parent)
self.setMinimumSize(640, 480)
def paintGL(self):
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
glTranslatef(-2.5, 0.5, -6.0)
glColor3f( 1.0, 1.5, 0.0 );
glPolygonMode(GL_FRONT, GL_FILL);
glBegin(GL_TRIANGLES)
glVertex3f(2.0,-1.2,0.0)
glVertex3f(2.6,0.0,0.0)
glVertex3f(2.9,-1.2,0.0)
glEnd()
glFlush()
def initializeGL(self):
glClearDepth(1.0)
glDepthFunc(GL_LESS)
glEnable(GL_DEPTH_TEST)
glShadeModel(GL_SMOOTH)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(45.0,1.33,0.1, 100.0)
glMatrixMode(GL_MODELVIEW)
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
Form = QtWidgets.QMainWindow()
ui = Ui_MainWindow(Form)
viewer = Ui_MainWindow()
viewer.show()
sys.exit(app.exec_())
```
#### File: dxf2plasma/src/test2.py
```python
from OpenGL.GL import *
from OpenGL.GLU import *
from PyQt4 import QtGui
from PyQt4.QtOpenGL import *
class MainWindow(QtGui.QWidget):
def __init__(self):
super(MainWindow, self).__init__()
self.widget = glWidget(self)
self.button = QtGui.QPushButton('Test', self)
mainLayout = QtGui.QHBoxLayout()
mainLayout.addWidget(self.widget)
mainLayout.addWidget(self.button)
self.setLayout(mainLayout)
class glWidget(QGLWidget):
def __init__(self, parent):
QGLWidget.__init__(self, parent)
self.setMinimumSize(640, 480)
def paintGL(self):
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
glTranslatef(-2.5, 0.5, -6.0)
glColor3f( 1.0, 1.5, 0.0 )
glPolygonMode(GL_FRONT, GL_FILL)
glBegin(GL_TRIANGLES)
glVertex3f(2.0,-1.2,0.0)
glVertex3f(2.6,0.0,0.0)
glVertex3f(2.9,-1.2,0.0)
glEnd()
glFlush()
def initializeGL(self):
glClearDepth(1.0)
glDepthFunc(GL_LESS)
glEnable(GL_DEPTH_TEST)
glShadeModel(GL_SMOOTH)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(45.0,1.33,0.1, 100.0)
glMatrixMode(GL_MODELVIEW)
if __name__ == '__main__':
app = QtGui.QApplication(['Yo'])
window = MainWindow()
window.show()
app.exec_()
```
|
{
"source": "jethornton/gcode",
"score": 2
}
|
#### File: src/libgcode/develop.py
```python
def face(parent):
parent.tabWidget.setCurrentIndex(1)
parent.faceWidthX.setText('10')
parent.faceDepthY.setText('5')
parent.faceLeft.setText('0')
parent.faceRear.setText('0')
parent.faceTop.setText('0')
parent.faceTool.setText('6')
parent.faceToolDia.setText('1.0')
parent.faceRPM.setText('1800')
parent.faceFeed.setText('50')
parent.faceStep.setText('75')
parent.faceSafeZ.setText('0.75')
parent.faceLeadIn.setText('.5')
parent.faceFullDepth.setText('-.5')
parent.faceStepDepth.setText('.125')
def pocket(parent):
parent.tabWidget.setCurrentIndex(2)
parent.pocketWidthX.setText('10')
parent.pocketDepthY.setText('5')
parent.pocketRadius.setText('1.0')
parent.pocketLeft.setText('0')
parent.pocketRear.setText('0')
parent.pocketTop.setText('0')
parent.pocketTool.setText('4')
parent.pocketToolDia.setText('0.5')
parent.pocketRPM.setText('1800')
parent.pocketFeed.setText('50')
parent.pocketStep.setText('50')
parent.pocketSafeZ.setText('0.75')
parent.pocketLeadIn.setText('.5')
parent.pocketCutDepth.setText('-.250')
parent.pocketStepDepth.setText('.125')
def canned(parent):
parent.tabWidget.setCurrentIndex(3)
parent.canToolLE.setText('1')
parent.canRetractLE.setText('0.250')
parent.canRpmLE.setText('675')
parent.canZdepthLE.setText('-1.250')
parent.canFeedLE.setText('5')
parent.canCoordPTE.appendPlainText('X1.0 Y-1.0')
parent.canCoordPTE.appendPlainText('X2.0 Y-1.0')
parent.canCoordPTE.appendPlainText('X3.0 Y-1.0')
```
#### File: src/libgcode/helptext.py
```python
def descriptions(index):
if index == 0: # Setup Tab
return text_0
elif index == 1: # Facing Tab
return text_1
elif index == 2: # Pocket Tab
return text_2
elif index == 30: # Canned Cycles Tab
return text_30
elif index == 31: # G81
return text_31
elif index == 32: # G82
return text_32
elif index == 33: # G83
return text_33
elif index == 34: # G84
return text_34
elif index == 35: # G85
return text_35
elif index == 36: # G86
return text_36
elif index == 39: # G89
return text_39
elif index == 4: # Inputs Tab
return text_4
elif index == 5: # Outputs Tab
return text_5
elif index == 6: # Tool Changer Tab
return text_6
elif index == 8: # Options Tab
return text_8
elif index == 9: # PLC Tab
return text_9
elif index == 10: # Pins Tab
return text_10
elif index == 11: # Info Tab
return text_11
elif index == 12: # PC Tab
return text_12
elif index == 20:
return text_20
elif index == 30:
return text_30
else:
return text_no
text_0 = """
Help Text for Setup Tab
Set default units and Preamble. Setup up to 3 machines with maximum
spindle speed. After setting up Save Settings and they will load up
the next time you open up G code Generator
"""
text_1 = """
Help Text for Facing Tab
"""
text_2 = """
Help Text for Pocket Tab
"""
text_30 = """
Help Text for Canned Cycles Tab
Select a Canned Cycle then press F1 for help on that cycle
"""
text_31 = """
Help Text for G81 Drilling Cycle
The L (repetitions) must be 2 or more.
To use the L (repetitions) function the incremental mode (G91) must be
selected. Only one hole location must be specified. Set the start
location the distance and angle from the hole. The repeted holes will
be parallel to the path from start to the hole and the distance from
the start postion to the hole.
"""
text_32 = """
Help Text for G82 Drilling Cycle, Dwell
G82 Cycle is drilling with a dwell at the bottom of the hole.
Dwell must be specified.
The L (repetitions) must be 2 or more.
To use the L (repetitions) function the incremental mode (G91) must be
selected. Only one hole location must be specified. Set the start
location the distance and angle from the hole. The repeted holes will
be parallel to the path from start to the hole and the distance from
the start postion to the hole.
"""
text_33 = """
Help Text for G83 Peck Drilling Cycle
G83 Cycle is peck drilling with full retract to the retract position (R)
for each peck cycle.
The L (repetitions) must be 2 or more.
To use the L (repetitions) function the incremental mode (G91) must be
selected. Only one hole location must be specified. Set the start
location the distance and angle from the hole. The repeted holes will
be parallel to the path from start to the hole and the distance from
the start postion to the hole.
It is an error if:
• the Q number is negative or zero.
"""
text_34 = """
Help Text for G84 Right-hand Tapping Cycle, Dwell
G84 cycle is tapping with floating chuck and dwell at the bottom of
the hole.
The Feed rate and RPM must match the pitch of the thread.
Spindle and Dwell must be specified.
The L (repetitions) must be 2 or more.
To use the L (repetitions) function the incremental mode (G91) must be
selected. Only one hole location must be specified. Set the start
location the distance and angle from the hole. The repeted holes will
be parallel to the path from start to the hole and the distance from
the start postion to the hole.
"""
text_35 = """
Help Text for G85 Boring Cycle, Feed Out
G85 cycle is for boring or reaming
The L (repetitions) must be 2 or more.
To use the L (repetitions) function the incremental mode (G91) must be
selected. Only one hole location must be specified. Set the start
location the distance and angle from the hole. The repeted holes will
be parallel to the path from start to the hole and the distance from
the start postion to the hole.
"""
text_36 = """
Help Text for G86 Boring Cycle, Spindle Stop, Rapid Move Out
G85 cycle is for boring or reaming with spindle stopped on retract.
Spindle must be specified.
The L (repetitions) must be 2 or more.
To use the L (repetitions) function the incremental mode (G91) must be
selected. Only one hole location must be specified. Set the start
location the distance and angle from the hole. The repeted holes will
be parallel to the path from start to the hole and the distance from
the start postion to the hole.
It is an error if:
• the spindle is not turning before this cycle is executed.
"""
text_39 = """
Help Text for G89 Boring Cycle, Dwell, Feed Out
G89 cycle is for boring with a dwell at the bottom of the hole and
retract at the current feed rate.
Dwell must be specified.
The L (repetitions) must be 2 or more.
To use the L (repetitions) function the incremental mode (G91) must be
selected. Only one hole location must be specified. Set the start
location the distance and angle from the hole. The repeted holes will
be parallel to the path from start to the hole and the distance from
the start postion to the hole.
"""
text_4 = """
Help Text for Inputs Tab
Inputs are optional
If the input is a type that is associated with an axis the axis must be
specified.
"""
text_5 = """
Help Text for Outputs Tab
Outputs are optional.
"""
text_6 = """
Help Text for Tool Changer Tab
"""
text_8 = """
Help Text for Options Tab
On Screen Prompt for Manual Tool Change
This option is if you run G code with more than one tool and the tools can be
preset like BT and Cat holders. If you have collet type like ER and R8 you
should not check this and you should only one tool per G code program and
touch it off before running the program.
Hal User Interface
This option enables halui which exports hal pins so they can be connected to
physical or VCP or used in your hal configuration. These include pins related
to abort, tool, spindle, program, mode, mdi, coolant, max velocity, machine,
lube, joint, jog, feed override, rapid override, e stop, axis and home.
PyVCP Panel
This option adds the connections and a basic PyVCP panel.
GladeVCP Panel
Not functioning at this point.
Debug Options
This sets the debug level that is used when an error happens. When an error
occours the error information is sent to dmesg. Open a terminal and clear
dmesg with sudo dmesg -c then run your configuration and to view the error
in a terminal type dmesg.
"""
text_9 = """
Help Text for PLC Tab
Classicladder PLC will add a basic PLC to the configuration. You can also set
the number of components that Classicladder starts with.
"""
text_10 = """
Help Text for Pins Tab
If you have the 7i96 connected press get pins to get the current pinout
"""
text_11 = """
Help Text for Info Tab
Get CPU information and NIC information
"""
text_12 = """
Help Text for PC Tab
To check if the network packet time is ok get the CPU speed from the Info Tab.
Then get the tmax time and put those values into the boxes then hit calculate.
Make sure you select if the CPU speed is gHz or mHz.
To get tMax you must have the 7i96 connected to the PC and be running the
configuration with LinuxCNC.
"""
text_20 = """
Help Text for Building the Configuration
Opening the sample ini file and modifying is the fastest way to get a working configuration.
Check Configuration will scan the configuration for errors
Build Configuration will build all the configuration files needed.
The ini file is always overwritten.
The configName.hal file will always be overwritten.
The tool table, variable file, postgui.hal, custom.hal, configName.clp,
configName.xml files are never overwritten if present. To get a new one delete
the file and a new one will be created when you build the configuration.
"""
text_no = """
No Help is found for this tab
"""
```
#### File: src/libgcode/utilities.py
```python
import os, configparser
from PyQt5.QtWidgets import (QLineEdit, QSpinBox, QCheckBox, QComboBox,
QLabel, QGroupBox, QDoubleSpinBox)
ini_options = [
['SETTINGS', 'UNITS', 'unitsBG'],
['SETTINGS', 'PREAMBLE', 'preambleLE'],
['SETTINGS', 'NAME_0', 'machineLE_0'],
['SETTINGS', 'MAX_RPM_0', 'machineMaxSB_0'],
['SETTINGS', 'NAME_1', 'machineLE_1'],
['SETTINGS', 'MAX_RPM_1', 'machineMaxSB_1'],
['SETTINGS', 'NAME_2', 'machineLE_2'],
['SETTINGS', 'MAX_RPM_2', 'machineMaxSB_2'],
]
def saveSettings(parent):
settings = ['[SETTINGS]\n']
settings.append(f'UNITS = {parent.unitsBG.checkedButton().property("units")}\n')
settings.append(f'PREAMBLE = {parent.preambleLE.text().strip()}\n')
settings.append(f'NAME_0 = {parent.machineLE_0.text().strip()}\n')
settings.append(f'MAX_RPM_0 = {parent.machineMaxSB_0.value()}\n')
settings.append(f'NAME_1 = {parent.machineLE_1.text().strip()}\n')
settings.append(f'MAX_RPM_1 = {parent.machineMaxSB_1.value()}\n')
settings.append(f'NAME_2 = {parent.machineLE_2.text().strip()}\n')
settings.append(f'MAX_RPM_2 = {parent.machineMaxSB_2.value()}\n')
sf = os.path.expanduser('~/.gcode_settings')
with open(sf, 'w') as f:
f.writelines(settings)
def getSettings(parent):
sf = os.path.expanduser('~/.gcode_settings')
if os.path.isfile(sf):
config = configparser.ConfigParser(strict=False)
config.optionxform = str
config.read(sf)
for item in ini_options:
if config.has_option(item[0], item[1]):
if isinstance(getattr(parent, item[2]), QLabel):
getattr(parent, item[2]).setText(config[item[0]][item[1]])
if isinstance(getattr(parent, item[2]), QLineEdit):
getattr(parent, item[2]).setText(config[item[0]][item[1]])
if isinstance(getattr(parent, item[2]), QSpinBox):
getattr(parent, item[2]).setValue(abs(int(config[item[0]][item[1]])))
if isinstance(getattr(parent, item[2]), QDoubleSpinBox):
getattr(parent, item[2]).setValue(float(config[item[0]][item[1]]))
if isinstance(getattr(parent, item[2]), QCheckBox):
getattr(parent, item[2]).setChecked(eval(config[item[0]][item[1]]))
if isinstance(getattr(parent, item[2]), QGroupBox):
getattr(parent, item[2]).setChecked(eval(config[item[0]][item[1]]))
#print(self.config[item[0]][item[1]])
if isinstance(getattr(parent, item[2]), QComboBox):
index = getattr(v, item[2]).findData(config[item[0]][item[1]])
if index >= 0:
getattr(parent, item[2]).setCurrentIndex(index)
for i in range(3):
#print(parent.machineLE_0.text())
#print(getattr(parent, 'machineLE_' + str(i)).text())
# getattr(self, 'minLimit_' + str(i)).setToolTip('inches')
#print(getattr(parent, 'machineLE_') + str(i)).text()
machine = getattr(parent, 'machineLE_' + str(i)).text()
rpm = getattr(parent, 'machineMaxSB_' + str(i)).text()
getattr(parent, 'drillMachineCB').addItem(machine, rpm)
getattr(parent, 'millMachineCB').addItem(machine, rpm)
#parent.drillMachineCB.addItem
'''
if config.has_section('SETTINGS'):
for i in items:
if config.has_option(i[0], i[1]):
print(i)
if config['SETTINGS']['UNITS'] == 'G20':
parent.inchRB.setChecked(True)
else:
parent.mmRB.setChecked(True)
parent.preambleLE.setText(config['SETTINGS']['PREAMBLE'])
parent.machine1LE.setText(config['SETTINGS']['NAME_1'])
parent.machine1MaxSB.setValue(int(config['SETTINGS']['MAX_RPM_1']))
parent.machine2LE.setText(config['SETTINGS']['NAME_2'])
parent.machine2MaxSB.setValue(int(config['SETTINGS']['MAX_RPM_2']))
parent.machine3LE.setText(config['SETTINGS']['NAME_3'])
parent.machine3MaxSB.setValue(int(config['SETTINGS']['MAX_RPM_3']))
parent.drillMachineCB.addItem(config['SETTINGS']['NAME_1'], config['SETTINGS']['MAX_RPM_1'])
parent.drillMachineCB.addItem(config['SETTINGS']['NAME_2'], config['SETTINGS']['MAX_RPM_2'])
parent.drillMachineCB.addItem(config['SETTINGS']['NAME_3'], config['SETTINGS']['MAX_RPM_3'])
parent.millMachineCB.addItem(config['SETTINGS']['NAME_1'], config['SETTINGS']['MAX_RPM_1'])
parent.millMachineCB.addItem(config['SETTINGS']['NAME_2'], config['SETTINGS']['MAX_RPM_2'])
parent.millMachineCB.addItem(config['SETTINGS']['NAME_3'], config['SETTINGS']['MAX_RPM_3'])
# drillMachineCB
# millMachineCB
'''
```
|
{
"source": "jethornton/mill-gcode",
"score": 2
}
|
#### File: mill-gcode/mgcode/mgcode.py
```python
version = '1.7.7'
# Copyright <NAME> 2014
import os, sys
if sys.platform.startswith('linux'):
current_path = os.path.dirname(os.path.realpath(__file__)) + '/'
sys.path.append(current_path + '/data')
elif sys.platform.startswith('win'):
print os.getcwd()
print 'windoze'
IN_AXIS = os.environ.has_key("AXIS_PROGRESS_BAR")
try:
import pygtk
pygtk.require('2.0')
except:
pass
try:
import gtk
except:
print('GTK not available')
sys.exit(1)
import database as db
import face as face
import pocket as pocket
import files as files
import math
from decimal import *
import pango
import ConfigParser
import webbrowser
class mill:
def __init__(self):
self.builder = gtk.Builder()
self.builder.add_from_file(current_path + "data/mill.glade")
self.builder.connect_signals(self)
self.aboutdialog = self.builder.get_object("aboutdialog")
self.aboutdialog.set_version(version)
self.message_dialog = self.builder.get_object("messagedialog")
self.clipboard = gtk.clipboard_get()
self.db = db.database()
self.face = face.face()
self.pocket = pocket.pocket()
self.save = files.save()
self.open = files.open()
# debugging
self.in_axis = self.builder.get_object('in_axis')
self.in_axis.set_text('In Axis = ' + str(IN_AXIS))
# setup prefrences page
self.cp = ConfigParser.ConfigParser()
self.cfgfile = current_path + 'data/mill.ini'
self.cp.read(self.cfgfile)
self.drill_point_preference = self.builder.get_object('drill_point_preference')
self.drill_point_preference.set_text(self.cp.get('Tools','drill_point'))
self.spot_point_preference = self.builder.get_object('spot_point_preference')
self.spot_point_preference.set_text(self.cp.get('Tools','spot_point'))
self.inch = self.builder.get_object('inch_preference')
self.metric = self.builder.get_object('metric_preference')
if self.cp.get('Measure', 'units') == 'Inch':
self.inch.set_active(True)
self.units = ' "'
elif self.cp.get('Measure', 'units') == 'Metric':
self.metric.set_active(True)
self.units = ' mm'
self.min_spindle_rpm =self.builder.get_object('min_spindle_rpm')
self.max_spindle_rpm = self.builder.get_object('max_spindle_rpm')
self.preamble = self.builder.get_object('preamble')
self.precision_preference = self.builder.get_object('precision_preference')
self.precision_preference.set_text(self.cp.get('Measure', 'precision'))
self.precision = int(self.precision_preference.get_text())
self.max_spindle_rpm = self.builder.get_object('max_spindle_rpm')
self.max_spindle_rpm.set_text(self.cp.get('Machine', 'max_spindle_rpm'))
self.min_spindle_rpm = self.builder.get_object('min_spindle_rpm')
self.min_spindle_rpm.set_text(self.cp.get('Machine', 'min_spindle_rpm'))
self.preamble = self.builder.get_object('preamble')
self.preamble.set_text(self.cp.get('Machine', 'preamble'))
self.return_x = self.builder.get_object('return_x')
self.return_x.set_text(self.cp.get('Presets', 'return_x'))
self.return_y = self.builder.get_object('return_y')
self.return_y.set_text(self.cp.get('Presets', 'return_y'))
self.return_z = self.builder.get_object('return_z')
self.return_z.set_text(self.cp.get('Presets', 'return_z'))
# setup hole ops
# setup tapping page
self.tap_formlist = gtk.ListStore(str)
self.tap_formlist.append(["Select a Form"])
self.tap_itemlist = self.db.tap_forms()
for i in self.tap_itemlist:
self.tap_formlist.append([i["form"]])
self.tap_form_combo = self.builder.get_object("tap_form_combo")
self.tap_form_combo.set_model(self.tap_formlist)
self.tap_form_cell = gtk.CellRendererText()
self.tap_form_combo.pack_start(self.tap_form_cell)
self.tap_form_combo.add_attribute(self.tap_form_cell, 'text', 0)
self.tap_form_combo.set_active(0)
self.tap_form = ''
self.tap_size_list = gtk.ListStore(str)
self.tap_size_combo = self.builder.get_object("tap_size_combo")
self.tap_size_combo.set_model(self.tap_size_list)
self.tap_size_cell = gtk.CellRendererText()
self.tap_size_combo.pack_start(self.tap_size_cell)
self.tap_size_combo.add_attribute(self.tap_size_cell, 'text', 0)
self.tap_size = ''
self.tap_drill_diameter_info = self.builder.get_object("tap_drill_diameter_info")
self.tap_enable = False
self.tap_coolant = False
self.tap_depth = self.builder.get_object('tap_depth')
self.tap_rpm = self.builder.get_object('tap_rpm')
self.tap_tool_number = self.builder.get_object('tap_tool_number')
# setup the drilling page
self.spot_enable = False
self.spot_coolant = False
self.spot_tool_number = self.builder.get_object('spot_tool_number')
self.spot_angle = self.builder.get_object('spot_angle')
self.spot_angle.set_text(self.spot_point_preference.get_text())
self.spot_depth = self.builder.get_object('spot_depth')
self.spot_diameter = self.builder.get_object('spot_diameter')
self.spot_rpm = self.builder.get_object('spot_rpm')
self.spot_feed = self.builder.get_object('spot_feed')
self.drill_enable = False
self.drill_coolant = False
self.drill_tool_number = self.builder.get_object('drill_tool_number')
self.drill_hole_depth = self.builder.get_object('drill_hole_depth')
self.drill_diameter = self.builder.get_object('drill_diameter')
self.drill_point_angle = self.builder.get_object('drill_point_angle')
self.drill_point_angle.set_text(self.drill_point_preference.get_text())
self.drill_total_depth = self.builder.get_object('drill_total_depth')
self.drill_rpm = self.builder.get_object('drill_rpm')
self.drill_feed = self.builder.get_object('drill_feed')
self.drill_peck = self.builder.get_object('drill_peck')
self.ream_enable = False
self.ream_coolant = False
self.ream_tool_number = self.builder.get_object('ream_tool_number')
self.ream_hole_depth = self.builder.get_object('ream_hole_depth')
self.ream_rpm = self.builder.get_object('ream_rpm')
self.ream_feed = self.builder.get_object('ream_feed')
# set up the 2nd Ops page
self.counterbore_enable = False
self.counterbore_coolant = False
self.counterbore_finish = False
self.counterbore_tool_number = self.builder.get_object('counterbore_tool_number')
self.counterbore_diameter = self.builder.get_object('counterbore_diameter')
self.counterbore_tool_diameter = self.builder.get_object('counterbore_tool_diameter')
self.counterbore_depth = self.builder.get_object('counterbore_depth')
self.counterbore_rpm = self.builder.get_object('counterbore_rpm')
self.counterbore_stepover = self.builder.get_object('counterbore_stepover')
self.counterbore_feed = self.builder.get_object('counterbore_feed')
self.counterbore_doc = self.builder.get_object('counterbore_doc')
self.o_word = 100
self.restart_o_word = True
self.chamfer_enable = False
self.chamfer_coolant = False
self.chamfer_tool_number = self.builder.get_object('chamfer_tool_number')
self.chamfer_rpm = self.builder.get_object('chamfer_rpm')
self.chamfer_feed = self.builder.get_object('chamfer_feed')
self.chamfer_hole_diameter = self.builder.get_object('chamfer_hole_diameter')
self.chamfer_tip_angle = self.builder.get_object('chamfer_tip_angle')
self.chamfer_tip_width = self.builder.get_object('chamfer_tip_width')
self.chamfer_depth = self.builder.get_object('chamfer_depth')
# setup the XY locations tab
self.xy_liststore = gtk.ListStore(str, str)
self.xy_treeview = self.builder.get_object('xy-treeview')
self.xy_treeview.set_model(self.xy_liststore)
self.x_column = gtk.TreeViewColumn("X Coordinate")
self.x_column.set_expand(True)
self.x_column.set_alignment(0.5)
self.y_column = gtk.TreeViewColumn("Y Coordinate")
self.y_column.set_expand(True)
self.y_column.set_alignment(0.5)
self.xy_treeview.append_column(self.x_column)
self.xy_treeview.append_column(self.y_column)
self.x_cell = gtk.CellRendererText()
self.x_cell.set_property("editable", True)
self.x_cell.connect("edited", self.text_edited, self.xy_liststore, 0)
self.x_cell.set_property("alignment",pango.ALIGN_CENTER)
self.x_column.pack_start(self.x_cell, False)
self.x_column.add_attribute(self.x_cell, "text", 0)
self.y_cell = gtk.CellRendererText()
self.y_cell.set_property("editable", True)
self.y_cell.connect("edited", self.text_edited, self.xy_liststore,1)
self.y_cell.set_alignment(0.5,0)
self.y_column.pack_start(self.y_cell, False)
self.y_column.add_attribute(self.y_cell, "text", 1)
self.x_entry = self.builder.get_object('x-entry')
self.x_entry.connect('activate', self.goto_y_entry)
self.y_entry = self.builder.get_object('y-entry')
self.y_entry.connect('activate', self.addto_xy)
self.locations = []
self.xy_list = []
# setup the setup tab
self.hole_preamble = True
self.hole_preamble_cb = self.builder.get_object('hole_preamble_cb')
self.hole_preamble_cb.set_active(True)
self.retract_z = self.builder.get_object('retract_z')
self.retract_z.set_text('0.1')
self.rapid_z = self.builder.get_object('rapid_z')
self.rapid_z.set_text('0.5')
self.hole_return_enable = True
self.hole_return_enable_cb = self.builder.get_object('hole_return_enable_cb')
self.hole_return_enable_cb.set_active(True)
self.hole_eof_enable = True
self.hole_eof_enable_cb = self.builder.get_object('hole_eof_enable_cb')
self.hole_eof_enable_cb.set_active(True)
# setup the Drill Tap G code page
self.ops_label = self.builder.get_object('ops_label')
self.gcode_textbuffer = self.builder.get_object('gcode_textbuffer')
self.drill_copy = self.builder.get_object('drill_copy')
self.drill_send = self.builder.get_object('drill_send')
self.hole_save = self.builder.get_object('hole_save')
# setup the hole ops save tab
self.save_tap_cb = self.builder.get_object('save_tap_cb')
self.save_spot_cb = self.builder.get_object('save_spot_cb')
self.save_drill_cb = self.builder.get_object('save_drill_cb')
self.save_ream_cb = self.builder.get_object('save_ream_cb')
self.save_counterbore_cb = self.builder.get_object('save_counterbore_cb')
self.save_chamfer_cb = self.builder.get_object('save_chamfer_cb')
# setup the facing page
self.facing_coolant = False
self.facing_tool_number = self.builder.get_object('facing_tool_number')
self.facing_tool_diameter = self.builder.get_object('facing_tool_diameter')
self.facing_stepover = self.builder.get_object('facing_stepover')
self.facing_rpm = self.builder.get_object('facing_rpm')
self.facing_feed = self.builder.get_object('facing_feed')
self.facing_doc = self.builder.get_object('facing_doc')
self.facing_doc.set_tooltip_text('Depth of Cut')
self.facing_z_safe = self.builder.get_object('facing_z_safe')
self.facing_z_top = self.builder.get_object('facing_z_top')
self.facing_z_depth = self.builder.get_object('facing_z_depth')
self.facing_z_final = self.builder.get_object('facing_z_final')
self.facing_x_length = self.builder.get_object('facing_x_length')
self.facing_y_length = self.builder.get_object('facing_y_length')
self.facing_x_reference = self.builder.get_object('facing_x_reference')
self.facing_x_reference.set_text('0')
self.facing_y_reference = self.builder.get_object('facing_y_reference')
self.facing_y_reference.set_text('0')
self.facing_x_start = self.builder.get_object('facing_x_start')
self.facing_y_start = self.builder.get_object('facing_y_start')
self.facing_reference_point = '1'
self.facing_spiral_in = True
self.facing_zig_zag = False
# set some presets
self.facing_z_top.set_text('0.000')
self.facing_tool_diameter.set_text('1.000')
if self.inch.get_active():self.facing_z_safe.set_text('0.100')
if self.metric.get_active():self.facing_z_safe.set_text('2.5')
# setup the Facing G code tab
self.facing_textbuffer = self.builder.get_object('facing_textbuffer')
self.facing_copy = self.builder.get_object('facing_copy')
self.facing_send = self.builder.get_object('facing_send')
self.facing_save = self.builder.get_object('facing_save')
# for testing only
self.facing_feed.set_text('50')
self.facing_z_depth.set_text('0.250')
self.facing_x_length.set_text('8')
self.facing_y_length.set_text('5')
# setup the Pocket page
self.pocket_shape = 'retangle'
self.pocket_path = 'parallel'
self.pocket_direction = 'cw'
self.pocket_start = 'center'
self.pocket_entry = 'ramp'
self.pocket_coolant = False
self.pocket_tool_number = self.builder.get_object('pocket_tool_number')
self.pocket_tool_diameter = self.builder.get_object('pocket_tool_diameter')
self.pocket_stepover = self.builder.get_object('pocket_stepover')
self.pocket_rpm = self.builder.get_object('pocket_rpm')
self.pocket_feed = self.builder.get_object('pocket_feed')
self.pocket_doc = self.builder.get_object('pocket_doc')
self.pocket_doc.set_tooltip_text('Depth of Cut')
self.pocket_z_safe = self.builder.get_object('pocket_z_safe')
self.pocket_z_top = self.builder.get_object('pocket_z_top')
self.pocket_z_depth = self.builder.get_object('pocket_z_depth')
self.pocket_z_final = self.builder.get_object('pocket_z_final')
self.pocket_x_length = self.builder.get_object('pocket_x_length')
self.pocket_y_length = self.builder.get_object('pocket_y_length')
self.pocket_x_length = self.builder.get_object('pocket_x_length')
self.pocket_y_length = self.builder.get_object('pocket_y_length')
self.pocket_x_reference = self.builder.get_object('pocket_x_reference')
self.pocket_x_reference.set_text('0')
self.pocket_y_reference = self.builder.get_object('pocket_y_reference')
self.pocket_y_reference.set_text('0')
#self.pocket_x_start = self.builder.get_object('pocket_x_start')
#self.pocket_y_start = self.builder.get_object('pocket_y_start')
self.pocket_rectangle_hbox = self.builder.get_object('pocket_rectangle_hbox')
self.pocket_diameter_hbox = self.builder.get_object('pocket_diameter_hbox')
self.pocket_reference = 'center'
self.pocket_strategy = 'center_out'
# set some presets
self.pocket_z_top.set_text('0.000')
if self.inch.get_active():self.pocket_z_safe.set_text('0.100')
if self.metric.get_active():self.pocket_z_safe.set_text('2.5')
# set some presets for testing
self.pocket_tool_number.set_text('1')
self.pocket_tool_diameter.set_text('1.250')
self.pocket_rpm.set_text('1500')
self.pocket_feed.set_text('20')
self.pocket_z_depth.set_text('0.25')
self.pocket_x_length.set_text('6')
self.pocket_y_length.set_text('4')
# setup the Pocket G code tab
self.pocket_textbuffer = self.builder.get_object('pocket_textbuffer')
self.pocket_copy = self.builder.get_object('pocket_copy')
self.pocket_send = self.builder.get_object('pocket_send')
self.pocket_save = self.builder.get_object('pocket_save')
# setup the calculators page
self.tool_diameter = self.builder.get_object('tool_diameter')
self.tool_teeth = self.builder.get_object('tool_teeth')
self.feed_per_tooth = self.builder.get_object('feed_per_tooth')
self.ipr_label = self.builder.get_object('ipr_label')
self.cutting_speed = self.builder.get_object('cutting_speed')
self.rpm_label = self.builder.get_object('rpm_label')
self.ipm_label = self.builder.get_object('ipm_label')
self.drill_diameter_calc = self.builder.get_object('drill_diameter_calc')
self.drill_sfm = self.builder.get_object('drill_sfm')
self.drill_ipr = self.builder.get_object('drill_ipr')
self.drill_rpm_label = self.builder.get_object('drill_rpm_label')
self.drill_ipm_label = self.builder.get_object('drill_ipm_label')
# setup the main window
self.window = self.builder.get_object("window1")
self.window.set_title("Mill G code Generator")
self.window.show_all()
self.pocket_diameter_hbox.hide()
# Tapping Page
def on_tap_form_combo_changed(self, widget, data=None):
self.index = widget.get_active()
if self.index > 0:
self.model = widget.get_model()
self.item = [self.model[self.index][0]]
self.tap_form = self.item
self.tap_size_list.clear()
self.itemlist = self.db.tap_size(self.item)
self.tap_size_list.append(['Select a Size'])
for i in self.itemlist:
self.tap_size_list.append([i["size"]])
self.tap_size_combo.set_active(0)
self.clear_tap_info()
def on_tap_size_combo_changed(self, widget, data=None):
self.index = widget.get_active()
if self.index > 0:
self.model = widget.get_model()
self.item = [self.model[self.index][0]]
self.tap_size = self.item
self.tap_info = self.db.tap_info(self.tap_form, self.tap_size)
for i in self.tap_info:
self.tpi = i['pitch']
if self.tap_form[0] == 'ISO':
self.tap_pitch = str(round(self.tpi * 0.03937, self.precision))
else:
self.tap_pitch = str(round(1.0/self.tpi, self.precision))
self.tap_major_dia = i['major_dia']
self.tap_drill = i['tap_drill']
self.clearance_drill_close = i['clearance_drill_close']
self.clearance_drill_free = i['clearance_drill_free']
self.builder.get_object("tap_pitch_label").set_text(self.tap_pitch + self.units)
self.builder.get_object("tap_major_dia").set_text(str(round(self.tap_major_dia,self.precision)) + self.units)
self.builder.get_object("tap_drill_75").set_text(self.tap_drill)
self.builder.get_object("clearance_drill_close").set_text(self.clearance_drill_close)
self.builder.get_object("clearance_drill_free").set_text(self.clearance_drill_free)
self.tap_drill_info = self.db.drill_info(self.tap_drill)
self.tap_drill_diameter_info.set_text(str(self.tap_drill_info[0][2]) + self.units)
self.spot_diameter.set_text(str(self.tap_drill_info[0][2]))
self.drill_diameter.set_text(str(self.tap_drill_info[0][2]))
self.close_drill_info = self.db.drill_info(self.clearance_drill_close)
self.builder.get_object("close_drill_diameter").set_text(str(self.close_drill_info[0][2]) + self.units)
self.free_drill_info = self.db.drill_info(self.clearance_drill_free)
self.builder.get_object("free_drill_diameter").set_text(str(self.free_drill_info[0][2]) + self.units)
def clear_tap_info(self):
# move the builder to the top and use self.name here
self.builder.get_object("tap_pitch_label").set_text('')
self.builder.get_object("tap_major_dia").set_text('')
self.builder.get_object("tap_drill_75").set_text('')
def goto_y_entry(self,var):
self.y_entry.grab_focus()
def addto_xy(self, var):
if not self.is_number(self.x_entry.get_text(),'X coordinate '):
self.x_entry.grab_focus()
return
if not self.is_number(self.y_entry.get_text(),'Y coordinate '):
self.y_entry.grab_focus()
return
self.iter = self.xy_liststore.append([self.x_entry.get_text(),self.y_entry.get_text()])
self.x_entry.set_text('')
self.y_entry.set_text('')
self.rebuild_xy_list()
self.x_entry.grab_focus()
def rebuild_xy_list(self):
self.xy_list = []
for i in range(len(self.xy_liststore)):
self.iter = self.xy_liststore.get_iter(i)
self.xy_list.append("X" + self.xy_liststore[self.iter][0] + " Y" + self.xy_liststore[self.iter][1])
def on_spot_calculate_depth_clicked(self, var):
if self.is_number(self.spot_diameter.get_text(),'Spot Diameter '):
self.diameter = float(self.spot_diameter.get_text())
self.angle = float(self.spot_angle.get_text())
self.depth = (self.diameter/2)/math.tan(math.radians(self.angle/2))
self.spot_depth.set_text(str(round(self.depth, self.precision)))
def on_drill_calculate_depth_clicked(self, var):
if not self.is_number(self.drill_hole_depth.get_text(),'Tap Hole Depth '):return
if not self.is_number(self.drill_diameter.get_text(),'Tap Drill Diameter '):return
if not self.is_number(self.drill_point_angle.get_text(),'Tap Drill Tip Angle '):return
self.diameter = float(self.drill_diameter.get_text())
self.angle = float(self.drill_point_angle.get_text())
self.depth = float(self.drill_hole_depth.get_text())
self.tip_depth = (self.diameter/2)/math.tan(math.radians(self.angle/2))
self.drill_total_depth.set_text(str(round(self.tip_depth + self.depth, self.precision)))
def on_chamfer_calculate_depth_clicked(self, var):
if not self.is_number(self.chamfer_hole_diameter.get_text(),'Chamfer Hole Diameter '):return
if not self.is_number(self.chamfer_tip_angle.get_text(),'Chamfer Tip Angle '):return
if not self.is_number(self.chamfer_tip_width.get_text(),'Chamfer Tip Width '):return
self.diameter = float(self.chamfer_hole_diameter.get_text())
self.angle = float(self.chamfer_tip_angle.get_text())
self.tip_width = float(self.chamfer_tip_width.get_text())
self.depth = ((self.diameter-self.tip_width)/2)/math.tan(math.radians(self.angle/2))
self.chamfer_depth.set_text(str(round(self.depth, self.precision)))
def on_spot_enable_toggled(self, widget):
self.spot_enable = widget.get_active()
self.update_ops()
def on_spot_coolant_toggled(self, widget):
self.spot_coolant = widget.get_active()
def on_drill_enable_toggled(self, widget):
self.drill_enable = widget.get_active()
self.update_ops()
def on_drill_coolant_toggled(self, widget):
self.drill_coolant = widget.get_active()
def on_ream_enable_toggled(self, widget):
self.ream_enable = widget.get_active()
self.update_ops()
def on_ream_coolant_toggled(self, widget):
self.ream_coolant = widget.get_active()
def on_counterbore_enable_toggled(self, widget):
self.counterbore_enable = widget.get_active()
self.update_ops()
def on_counterbore_coolant_toggled(self, widget):
self.counterbore_coolant = widget.get_active()
def on_counterbore_finish_cb_toggled(self, widget):
self.counterbore_finish = widget.get_active()
def on_chamfer_enable_toggled(self, widget):
self.chamfer_enable = widget.get_active()
self.update_ops()
def on_chamfer_coolant_toggled(self, widget):
self.chamfer_coolant = widget.get_active()
def on_tap_enable_toggled(self, widget):
self.tap_enable = widget.get_active()
self.update_ops()
def on_tap_coolant_toggled(self, widget):
self.tap_coolant = widget.get_active()
def on_hole_preamble_cb_toggled(self, widget):
self.hole_preamble = widget.get_active()
def on_hole_return_enable_cb_toggled(self, widget):
self.hole_return_enable = widget.get_active()
def on_hole_eof_enable_cb_toggled(self, widget):
self.hole_eof_enable = widget.get_active()
def on_facing_coolant_toggled(self, widget):
self.facing_coolant = widget.get_active()
def on_facing_spiral_in_toggled(self, widget):
self.facing_spiral_in = widget.get_active()
def on_facing_zig_zag_toggled(self, widget):
self.facing_zig_zag = widget.get_active()
# not used I think
#def on_facing_reference_toggled(self, widget):
#if widget.get_active():
#self.facing_reference_point = widget.get_label()
# Pocket Tab
def on_pocket_rectangle_rb_toggled(self, widget):
if widget.get_active():
self.pocket_diameter_hbox.hide()
self.pocket_rectangle_hbox.show()
self.pocket_shape = 'retangle'
def on_pocket_round_rb_toggled(self, widget):
if widget.get_active():
self.pocket_diameter_hbox.show()
self.pocket_rectangle_hbox.hide()
self.pocket_shape = 'round'
def on_pocket_path_rb_toggled(self, widget):
if widget.get_active():
self.pocket_path = gtk.Buildable.get_name(widget)[12:]
def on_pocket_direction_toggled(self, widget):
if widget.get_active():
self.pocket_direction = gtk.Buildable.get_name(widget)[17:]
def on_pocket_start_toggled(self, widget):
if widget.get_active():
self.pocket_start = gtk.Buildable.get_name(widget)[13:]
def on_pocket_entry_toggled(self, widget):
if widget.get_active():
self.pocket_entry = gtk.Buildable.get_name(widget)[7:]
def on_pocket_coolant_toggled(self, widget):
self.pocket_coolant = widget.get_active()
def on_pocket_reference_toggled(self, widget):
if widget.get_active():
self.pocket_reference = gtk.Buildable.get_name(widget)[7:]
def update_ops(self):
self.ops_label.set_text('')
self.ops_list = []
self.hole_ops = 0
if self.spot_enable:
self.ops_list.append('Spot')
self.hole_ops += 1
if self.drill_enable:
self.ops_list.append('Drill')
self.hole_ops += 1
if self.ream_enable:
self.ops_list.append('Ream')
self.hole_ops += 1
if self.chamfer_enable:
self.ops_list.append('Chamfer')
self.hole_ops += 1
if self.tap_enable:
self.ops_list.append('Tap')
self.hole_ops += 1
if self.counterbore_enable:
self.ops_list.append('Counterbore')
self.hole_ops += 1
self.ops_label.set_text('\n'.join(self.ops_list))
def text_edited(self, widget, path, text, model, column):
model[path][column] = text
self.rebuild_xy_list()
def on_clear_xy_list_clicked(self, var):
self.xy_liststore.clear()
def on_delete_row_xy_list_clicked(self, var):
selection = self.xy_treeview.get_selection()
result = selection.get_selected()
if result[1]: #result could be None
model, iter = result
model.remove(iter)
# Drilling and Tapping
def on_generate_gcode_clicked(self, widget):
if len(self.xy_list) == 0:
self.error_msg('Can not Generate G code without XY Coordinates!')
return
self.gcode = []
if self.hole_preamble:
if len(self.preamble.get_text()) > 0:
self.gcode.append(self.preamble.get_text() + '\n')
else:
self.gcode.append('Warning No Preamble, Machine can start in an unknown state\n')
if self.spot_enable:
if not self.is_number(self.spot_depth.get_text(), 'Spot Depth '):return
if not self.is_number(self.retract_z.get_text(), 'Retract Z '):return
if not self.is_number(self.rapid_z.get_text(), 'Rapid Z '):return
#if not self.is_number(self.spot_rpm.get_text(), 'Spot RPM '):return
if not self.is_number(self.spot_feed.get_text(), 'Spot Feed '):return
self.gcode.append(';Spot Drill Op ' + self.spot_diameter.get_text() + ' Diameter\n')
if len(self.spot_tool_number.get_text()) > 0:
if self.is_number(self.spot_tool_number.get_text(), 'Spot Tool Number '):
self.gcode.append('T' + self.spot_tool_number.get_text() + ' M6 G43 \n')
else:
if self.hole_ops > 1:
self.error_msg('A tool number must be used with multiple Ops!')
return
self.gcode.append(';No Tool Number Used! \n')
if len(self.spot_rpm.get_text()) > 0:
if self.is_number(self.spot_rpm.get_text(), 'Spot Spindle RPM '):
self.gcode.append('M3 S' + self.spot_rpm.get_text() + '\n')
else:
self.gcode.append(';No Spindle RPM Used! \n')
self.gcode.append('F' + self.spot_feed.get_text() + '\n')
if self.spot_coolant: self.gcode.append('M8 \n')
self.gcode.append('G0 Z' + self.rapid_z.get_text() + '\n')
self.gcode.append('G0 ' + self.xy_list[0] + '\n')
self.gcode.append('G81 '+self.xy_list[0]+' Z-'+self.spot_depth.get_text() \
+' R'+self.retract_z.get_text() + '\n')
if len(self.xy_list) > 1:
self.xy_modified = self.xy_list[1:]
for item in self.xy_modified:
self.gcode.append(item + '\n')
self.gcode.append('G80 M5 M9\n')
if self.drill_enable:
if not self.is_number(self.drill_total_depth.get_text(), 'Drill Depth '):return
if not self.is_number(self.retract_z.get_text(), 'Retract Z '):return
if not self.is_number(self.rapid_z.get_text(), 'Rapid Z '):return
if not self.is_number(self.drill_feed.get_text(), 'Drill Feed '):return
self.gcode.append(';Drill Op \n')
if len(self.drill_tool_number.get_text()) > 0:
if self.is_number(self.drill_tool_number.get_text(), 'Drill Tool Number '):
self.gcode.append('T' + self.drill_tool_number.get_text() + ' M6 G43 \n')
else:
if self.hole_ops > 1:
self.error_msg('A tool number must be used with multiple Ops!')
return
self.gcode.append(';No Tool Number Used! \n')
if len(self.drill_rpm.get_text()) > 0:
if self.is_number(self.drill_rpm.get_text(), 'Drill Spindle RPM '):
self.gcode.append('M3 S' + self.drill_rpm.get_text() + '\n')
else:
self.gcode.append(';No Spindle RPM Used! \n')
self.gcode.append('F' + self.drill_feed.get_text() + '\n')
if self.drill_coolant: self.gcode.append('M8 \n')
self.gcode.append('G0 Z' + self.rapid_z.get_text() + '\n')
self.gcode.append('G0 ' + self.xy_list[0] + '\n')
if self.drill_peck.get_text() != '':
if not self.is_number(self.drill_peck.get_text(), 'Peck Depth '):return
self.drill_cycle = 'G83 '+self.xy_list[0]+' Z'+self.drill_total_depth.get_text() \
+' R'+self.retract_z.get_text() +' Q'+self.drill_peck.get_text()+'\n'
else:
self.drill_cycle = 'G81 '+self.xy_list[0]+' Z-'+self.drill_total_depth.get_text() \
+' R'+self.retract_z.get_text() + '\n'
self.gcode.append(self.drill_cycle)
if len(self.xy_list) > 1:
self.xy_modified = self.xy_list[1:]
for item in self.xy_modified:
self.gcode.append(item + '\n')
self.gcode.append('G80 M5 M9 \n')
if self.ream_enable:
if not self.is_number(self.ream_hole_depth.get_text(), 'Ream Hole Depth '):return
if not self.is_number(self.ream_feed.get_text(), 'Ream Feed '):return
self.gcode.append(';Ream Op \n')
if len(self.ream_tool_number.get_text()) > 0:
if self.is_number(self.ream_tool_number.get_text(), 'Ream Tool Number '):
self.gcode.append('T' + self.ream_tool_number.get_text() + ' M6 G43 \n')
else:
if self.hole_ops > 1:
self.error_msg('A tool number must be used with multiple Ops!')
return
self.gcode.append(';No Tool Number Used! \n')
if len(self.ream_rpm.get_text()) > 0:
if self.is_number(self.ream_rpm.get_text(), 'Ream Spindle RPM '):
self.gcode.append('M3 S' + self.ream_rpm.get_text() + '\n')
else:
self.gcode.append(';No Spindle RPM Used! \n')
self.gcode.append('F' + self.ream_feed.get_text() + '\n')
if self.ream_coolant: self.gcode.append('M8 \n')
self.gcode.append('G0 Z' + self.rapid_z.get_text() + '\n')
self.gcode.append('G0 ' + self.xy_list[0] + '\n')
self.gcode.append('G81 '+self.xy_list[0]+' Z-'+self.ream_hole_depth.get_text() \
+' R'+self.retract_z.get_text() + '\n')
if len(self.xy_list) > 1:
self.xy_modified = self.xy_list[1:]
for item in self.xy_modified:
self.gcode.append(item + '\n')
self.gcode.append('G80 M5 M9 \n')
if self.chamfer_enable:
if not self.is_number(self.chamfer_depth.get_text(), 'Chamfer Depth '):return
if not self.is_number(self.chamfer_feed.get_text(), 'Chamfer Feed '):return
self.gcode.append(';Chamfer Op \n')
if len(self.chamfer_tool_number.get_text()) > 0:
if self.is_number(self.chamfer_tool_number.get_text(), 'Chamfer Tool Number '):
self.gcode.append('T' + self.chamfer_tool_number.get_text() + ' M6 G43 \n')
else:
if self.hole_ops > 1:
self.error_msg('A tool number must be used with multiple Ops!')
return
self.gcode.append(';No Tool Number Used! \n')
if len(self.chamfer_rpm.get_text()) > 0:
if self.is_number(self.chamfer_rpm.get_text(), 'Chamfer Spindle RPM '):
self.gcode.append('M3 S' + self.chamfer_rpm.get_text() + '\n')
else:
self.gcode.append(';No Spindle RPM Used! \n')
self.gcode.append('F' + self.chamfer_feed.get_text() + '\n')
if self.chamfer_coolant: self.gcode.append('M8 \n')
self.gcode.append('G0 Z' + self.rapid_z.get_text() + '\n')
self.gcode.append('G0 ' + self.xy_list[0] + '\n')
self.gcode.append('G81 '+self.xy_list[0]+' Z-'+self.chamfer_depth.get_text() \
+' R'+self.retract_z.get_text() + '\n')
if len(self.xy_list) > 1:
self.xy_modified = self.xy_list[1:]
for item in self.xy_modified:
self.gcode.append(item + '\n')
self.gcode.append('G80 M5 M9 \n')
if self.tap_enable:
self.gcode.append(';Tap Op \n')
if len(self.tap_tool_number.get_text()) > 0:
if self.is_number(self.tap_tool_number.get_text(), 'Tap Tool Number '):
self.gcode.append('T' + self.tap_tool_number.get_text() + ' M6 G43 \n')
else:
if self.hole_ops > 1:
self.error_msg('A tool number must be used with multiple Ops!')
return
self.gcode.append(';No Tool Number Used! \n')
self.gcode.append('M3 S' + self.tap_rpm.get_text() + '\n')
if self.tap_coolant: self.gcode.append('M8 \n')
self.gcode.append('G0 Z' + self.rapid_z.get_text() + '\n')
self.gcode.append('G0 ' + self.xy_list[0] + '\n')
self.gcode.append('G0 Z' + self.retract_z.get_text() + '\n')
self.gcode.append('G33.1 '+self.xy_list[0]+' Z-'+self.tap_depth.get_text()+' K'+self.tap_pitch+'\n')
if len(self.xy_list) > 1:
self.xy_modified = self.xy_list[1:]
for item in self.xy_modified:
self.gcode.append('G0 ' + item + '\n')
self.gcode.append('G33.1 '+ item +' Z-'+self.tap_depth.get_text()+' K'+self.tap_pitch+'\n')
if self.tap_coolant:self.gcode.append('M9 ')
self.gcode.append('M5 \n')
if self.counterbore_enable:
if not self.is_number(self.counterbore_diameter.get_text(), 'Counterbore Diameter '):return
self.hole_dia = Decimal(self.counterbore_diameter.get_text())
if not self.is_number(self.counterbore_depth.get_text(), 'Counterbore Depth '):return
self.z_depth = -Decimal(self.counterbore_depth.get_text())
if not self.is_number(self.counterbore_tool_diameter.get_text(), 'Counterbore Tool Diameter '):return
self.tool_dia = Decimal(self.counterbore_tool_diameter.get_text())
if not self.is_number(self.counterbore_feed.get_text(), 'Counterbore Feed '):return
self.tool_dia = Decimal(self.counterbore_tool_diameter.get_text())
self.path_dia = self.hole_dia - self.tool_dia
if len(self.counterbore_stepover.get_text()) > 0:
if self.is_number(self.counterbore_stepover.get_text(), 'Counterbore Step Over % '):
self.stepover_percent = Decimal(self.counterbore_stepover.get_text())*Decimal('0.01')
self.stepover = self.tool_dia * self.stepover_percent
else:
self.stepover_percent = Decimal('0.50')
self.stepover = self.tool_dia * self.stepover_percent
if len(self.counterbore_doc.get_text()) > 0:
self.z_step = Decimal(self.counterbore_doc.get_text())
else:
self.z_step = Decimal(self.counterbore_depth.get_text())
self.circles = (self.path_dia / self.stepover) - 1
self.polar_increment = self.stepover / Decimal('100')
self.offset = Decimal('0.000') + self.stepover
self.gcode.append(';Counterbore Op \n')
if len(self.counterbore_tool_number.get_text()) > 0:
if self.is_number(self.counterbore_tool_number.get_text(), 'Counterbore Tool Number '):
self.gcode.append('T' + self.counterbore_tool_number.get_text() + ' M6 G43 \n')
else:
if self.hole_ops > 1:
self.error_msg('A tool number must be used with multiple Ops!')
return
self.gcode.append(';No Tool Number Used! \n')
if len(self.counterbore_rpm.get_text()) > 0:
if self.is_number(self.counterbore_rpm.get_text(), 'Counterbore RPM '):
self.gcode.append('M3 S' + self.counterbore_rpm.get_text() + '\n')
else:
self.gcode.append(';No Spindle Control Used! \n')
self.gcode.append('F' + self.counterbore_feed.get_text() + '\n')
if self.restart_o_word:self.o_word = 100
for item in self.xy_list:
self.gcode.append('G0 ' + item + '\n')
self.gcode.append('G0 Z' + self.retract_z.get_text() + '\n')
self.gcode.append('G92 X0 Y0\n')
self.repeats = self.circles * 100
self.z_current = Decimal('0.000')
while self.z_current > self.z_depth:
self.z_current -= self.z_step
self.gcode += 'G1 Z%.4f\n' % self.z_current
if not self.counterbore_finish:
self.gcode += 'G1 Y%.4f\n' % self.stepover
self.gcode += 'o%d repeat [%d]\n' % (self.o_word, self.repeats)
self.gcode += 'G91 G1 @%.6f ^3.6\n' % self.polar_increment
self.gcode += 'o%d endrepeat\n' % self.o_word
else:
self.gcode += 'G1 Y%.4f\n' % self.path_dia
self.gcode += 'G3 J-%.4f\n' % self.path_dia
self.gcode += 'G90\n'
self.gcode += 'G1 X0 Y0\n'
self.gcode += '\n'
self.o_word += 1
self.gcode.append('G0 Z' + self.rapid_z.get_text() + '\n')
self.gcode.append('G92.1')
self.gcode.append('\n')
if self.hole_return_enable:
self.gcode.append('G53 G0 Z' + self.return_z.get_text() + '\n')
self.gcode.append('G0 X' + self.return_x.get_text() + ' Y' + self.return_y.get_text() + '\n')
if self.hole_eof_enable:
self.gcode.append('M2')
else:
self.restart_o_word = False
self.gcode_textbuffer.set_text(''.join(self.gcode))
if IN_AXIS:self.drill_send.set_sensitive(True)
self.drill_copy.set_sensitive(True)
self.hole_save.set_sensitive(True)
def on_button1_clicked(self, widget):
print self.xy_list
print self.xy_list[1:]
def on_drill_copy_clicked(self, widget):
try:
self.clipboard.set_text(''.join(self.gcode))
self.clipboard.store()
except AttributeError:
self.error_msg('Nothing to Copy')
def on_drill_send_clicked(self, widget):
sys.stdout.write(''.join(self.gcode))
gtk.main_quit()
def on_hole_save_clicked(self, widget):
self.fcd = gtk.FileChooserDialog("Save As...",
None,
gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE_AS, gtk.RESPONSE_OK))
self.response = self.fcd.run()
if self.response == gtk.RESPONSE_OK:
self.filename = self.fcd.get_filename()
if not self.filename.endswith('.ngc'):
fn += '.ngc'
self.file = open(self.filename, 'w')
self.file.write(''.join(self.gcode))
self.file.close()
self.fcd.destroy()
# Counterbore
def on_counterbore_generate_clicked(self, widget):
pass
# Facing
def on_generate_facing_clicked(self, widget):
# check validity of items that have to be filled in
if not self.is_number(self.facing_tool_diameter.get_text(), 'Facing Tool Diameter '):return
if not self.is_number(self.facing_feed.get_text(), 'Facing Feed '):return
if not self.is_number(self.facing_z_safe.get_text(), 'Facing Safe Z '):return
if not self.is_number(self.facing_z_top.get_text(), 'Facing Z Top '):return
if not self.is_number(self.facing_z_depth.get_text(), 'Facing Z Depth '):return
if not self.is_number(self.facing_x_length.get_text(), 'Facing X Length '):return
if not self.is_number(self.facing_y_length.get_text(), 'Facing Y Length '):return
if not self.is_number(self.facing_x_reference.get_text(), 'Facing X Reference '):return
if not self.is_number(self.facing_y_reference.get_text(), 'Facing Y Reference '):return
self.facing = []
# create an empty dictionary
self.face_info={}
# add facing info to dictionary
if self.facing_spiral_in:
self.face_info['method'] = 'spiral'
else:
self.face_info['method'] = 'zigzag'
if len(self.preamble.get_text()) > 0:
self.face_info['preamble'] = self.preamble.get_text()
else:
self.face_info['preamble'] = 'Warning No Preamble, Machine can start in an unknown state'
if len(self.facing_tool_number.get_text()) > 0:
if self.is_number(self.facing_tool_number.get_text(), 'Facing Tool Number '):
self.face_info['tool'] = self.facing_tool_number.get_text()
else:
self.face_info['tool'] = 'NaN'
self.face_info['diameter'] = self.facing_tool_diameter.get_text()
if len(self.facing_rpm.get_text()) > 0:
if self.is_number(self.facing_rpm.get_text(), 'Facing RPM '):
self.face_info['rpm'] = self.facing_rpm.get_text()
else:
self.face_info['rpm'] = 'NaN'
if len(self.facing_stepover.get_text()) > 0:
if self.is_number(self.facing_stepover.get_text(), 'Facing Step Over % '):
self.face_info['step'] = self.facing_stepover.get_text()
else:
self.face_info['step'] = 'NaN'
if self.facing_coolant:
self.face_info['coolant'] = True
else:
self.face_info['coolant'] = False
self.face_info['feed'] = self.facing_feed.get_text()
if len(self.facing_doc.get_text()) > 0:
if not self.is_number(self.facing_doc.get_text(), 'Facing DOC '):return
self.face_info['doc'] = self.facing_doc.get_text()
else:
self.face_info['doc'] = 'NaN'
self.face_info['safe-z'] = self.facing_z_safe.get_text()
self.face_info['z-top'] = self.facing_z_top.get_text()
self.face_info['z-depth'] = self.facing_z_depth.get_text()
self.face_info['x-length'] = self.facing_x_length.get_text()
if len(self.facing_z_final.get_text()) > 0:
if not self.is_number(self.facing_z_final.get_text(), 'Facing Z Final '):return
self.face_info['z-final'] = self.facing_z_final.get_text()
else:
self.face_info['z-final'] = 'NaN'
self.face_info['y-length'] = self.facing_y_length.get_text()
self.face_info['reference'] = self.facing_reference_point
self.face_info['x-ref'] = self.facing_x_reference.get_text()
self.face_info['y-ref'] = self.facing_y_reference.get_text()
if len(self.facing_x_start.get_text()) > 0:
if not self.is_number(self.facing_x_start.get_text(), 'Facing X Start '):return
self.face_info['x-start'] = self.facing_x_start.get_text()
else:
self.face_info['x-start'] = 'NaN'
if len(self.facing_y_start.get_text()) > 0:
if not self.is_number(self.facing_y_start.get_text(), 'Facing Y Start '):return
self.face_info['y-start'] = self.facing_y_start.get_text()
else:
self.face_info['y-start'] = 'NaN'
# call the facing G code generator
self.facing_code = self.face.get_gcode(self.face_info)
print self.facing_code
self.facing_textbuffer.set_text(''.join(self.facing_code))
# turn on buttons
self.facing_copy.set_sensitive(True)
if IN_AXIS:self.facing_send.set_sensitive(True)
self.facing_save.set_sensitive(True)
def on_facing_copy_clicked(self, widget):
try:
self.clipboard.set_text(''.join(self.facing))
self.clipboard.store()
except AttributeError:
self.error_msg('Nothing to Copy')
def on_facing_send_clicked(self, widget):
sys.stdout.write(''.join(self.facing))
gtk.main_quit()
def on_facing_save_clicked(self, widget):
self.fcd = gtk.FileChooserDialog("Save As...",
None,
gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE_AS, gtk.RESPONSE_OK))
self.response = self.fcd.run()
if self.response == gtk.RESPONSE_OK:
self.filename = self.fcd.get_filename()
if not self.filename.endswith('.ngc'):
self.filename += '.ngc'
self.file = open(self.filename, 'w')
self.file.write(''.join(self.facing))
self.file.close()
self.fcd.destroy()
# Generate Pocket G code
def on_generate_pocket_clicked(self, var):
self.pocket_code = []
# create an empty dictionary
self.pocket_info={}
# add pocket info to dictionary
self.pocket_info['shape'] = self.pocket_shape
self.pocket_info['path'] = self.pocket_path
self.pocket_info['direction'] = self.pocket_direction
self.pocket_info['start'] = self.pocket_start
self.pocket_info['entry'] = self.pocket_entry
self.pocket_info['tool_number'] = self.pocket_tool_number.get_text()
self.pocket_info['tool_diameter'] = self.pocket_tool_diameter.get_text()
self.pocket_info['coolant'] = self.pocket_coolant
self.pocket_info['rpm'] = self.pocket_rpm.get_text()
if self.pocket_stepover.get_text() == '':
self.pocket_info['stepover'] = '75'
else:
self.pocket_info['stepover'] = self.pocket_stepover.get_text()
self.pocket_info['feed'] = self.pocket_feed.get_text()
if self.pocket_doc.get_text() == '':
self.pocket_info['doc'] = self.pocket_z_depth.get_text()
else:
self.pocket_info['doc'] = self.pocket_doc.get_text()
self.pocket_info['z_safe'] = self.pocket_z_safe.get_text()
self.pocket_info['z_top'] = self.pocket_z_top.get_text()
self.pocket_info['z_final'] = self.pocket_z_final.get_text()
self.pocket_info['z_depth'] = self.pocket_z_depth.get_text()
self.pocket_info['x_length'] = self.pocket_x_length.get_text()
self.pocket_info['y_length'] = self.pocket_y_length.get_text()
self.pocket_info['x_reference'] = self.pocket_x_reference.get_text()
self.pocket_info['y_reference'] = self.pocket_y_reference.get_text()
self.pocket_info['reference'] = self.pocket_reference
# call the pocket G code generator
self.pocket_code = self.pocket.get_gcode(self.pocket_info)
self.pocket_textbuffer.set_text(''.join(self.pocket_code))
# turn on copy to clipboard button
self.pocket_copy.set_sensitive(True)
if IN_AXIS:self.pocket_send.set_sensitive(True)
self.pocket_save.set_sensitive(True)
# Copy Pocket G code to Clipboard
def on_pocket_copy_clicked(self, var):
try:
self.clipboard.set_text(''.join(self.pocket))
self.clipboard.store()
except AttributeError:
self.error_msg('Nothing to Copy')
def on_pocket_send_clicked(self, widget):
sys.stdout.write(''.join(self.pocket))
gtk.main_quit()
def on_pocket_save_clicked(self, widget):
self.fcd = gtk.FileChooserDialog("Save As...",
None,
gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE_AS, gtk.RESPONSE_OK))
self.response = self.fcd.run()
if self.response == gtk.RESPONSE_OK:
self.filename = self.fcd.get_filename()
if not self.filename.endswith('.ngc'):
fn += '.ngc'
self.file = open(self.filename, 'w')
self.file.write(''.join(self.pocket))
self.file.close()
self.fcd.destroy()
def is_number(self, s, t):
try:
float(s)
return True
except ValueError:
if s == '':
msg = t + 'is blank!'
else:
msg = t + '"' + s + '"' + ' is not a number'
self.error_msg(msg)
return False
def on_save_preferences_clicked(self, var):
self.cp.set('A Notice', '; Do Not Edit this File!', '')
if self.inch.get_active():
self.cp.set('Measure','units', 'Inch')
elif self.metric.get_active():
self.cp.set('Measure','units', 'Metric')
self.cp.set('Measure','precision',self.precision_preference.get_text())
self.cp.set('Tools','drill_point',self.drill_point_preference.get_text())
self.cp.set('Tools','spot_point',self.spot_point_preference.get_text())
self.cp.set('Machine','min_spindle_rpm',self.min_spindle_rpm.get_text())
self.cp.set('Machine','max_spindle_rpm',self.max_spindle_rpm.get_text())
self.cp.set('Machine','preamble',self.preamble.get_text())
self.cp.set('Presets','return_x',self.return_x.get_text())
self.cp.set('Presets','return_y',self.return_y.get_text())
self.cp.set('Presets','return_z',self.return_z.get_text())
with open(self.cfgfile, 'w') as configfile:
self.cp.write(configfile)
def save_ops(self, fn):
if not fn.endswith('.ops'):
fn += '.ops'
self.count = 0
self.save_op = ConfigParser.RawConfigParser()
if self.save_tap_cb.get_active():
self.save_op.add_section('Tap')
self.save_op.set('Tap','tap_form',self.tap_form)
self.save_op.set('Tap','tap_size',self.tap_size)
self.save_op.set('Tap','tap_tool_number',self.tap_tool_number.get_text())
self.save_op.set('Tap','tap_depth',self.tap_depth.get_text())
self.save_op.set('Tap','tap_rpm',self.tap_rpm.get_text())
self.count += 1
if self.save_spot_cb.get_active():
self.save_op.add_section('Spot')
self.save_op.set('Spot','spot_tool_number',self.spot_tool_number.get_text())
self.save_op.set('Spot','spot_rpm',self.spot_rpm.get_text())
self.save_op.set('Spot','spot_feed',self.spot_feed.get_text())
self.save_op.set('Spot','spot_diameter',self.spot_diameter.get_text())
self.save_op.set('Spot','spot_angle',self.spot_angle.get_text())
self.save_op.set('Spot','spot_depth',self.spot_depth.get_text())
self.count += 1
if self.save_drill_cb.get_active():
self.save_op.add_section('Drill')
self.save_op.set('Drill','drill_tool_number',self.drill_tool_number.get_text())
self.save_op.set('Drill','drill_rpm',self.drill_rpm.get_text())
self.save_op.set('Drill','drill_feed',self.drill_feed.get_text())
self.save_op.set('Drill','drill_peck',self.drill_peck.get_text())
self.save_op.set('Drill','drill_hole_depth',self.drill_hole_depth.get_text())
self.save_op.set('Drill','drill_diameter',self.drill_diameter.get_text())
self.save_op.set('Drill','drill_point_angle',self.drill_point_angle.get_text())
self.save_op.set('Drill','drill_total_depth',self.drill_total_depth.get_text())
self.count += 1
if self.save_ream_cb.get_active():
self.save_op.add_section('Ream')
self.save_op.set('Ream','ream_tool_number',self.ream_tool_number.get_text())
self.save_op.set('Ream','ream_feed',self.ream_feed.get_text())
self.save_op.set('Ream','ream_hole_depth',self.ream_hole_depth.get_text())
self.save_op.set('Ream','ream_rpm',self.ream_rpm.get_text())
self.count += 1
if self.save_counterbore_cb.get_active():
self.save_op.add_section('Counterbore')
self.save_op.set('Counterbore','counterbore_tool_number',self.counterbore_tool_number.get_text())
self.save_op.set('Counterbore','counterbore_depth',self.counterbore_depth.get_text())
self.save_op.set('Counterbore','counterbore_stepover',self.counterbore_stepover.get_text())
self.save_op.set('Counterbore','counterbore_doc',self.counterbore_doc.get_text())
self.save_op.set('Counterbore','counterbore_diameter',self.counterbore_diameter.get_text())
self.save_op.set('Counterbore','counterbore_tool_diameter',self.counterbore_tool_diameter.get_text())
self.save_op.set('Counterbore','counterbore_rpm',self.counterbore_rpm.get_text())
self.save_op.set('Counterbore','counterbore_feed',self.counterbore_feed.get_text())
self.count += 1
if self.save_chamfer_cb.get_active():
self.save_op.add_section('Chamfer')
self.save_op.set('Chamfer','chamfer_tool_number',self.chamfer_tool_number.get_text())
self.save_op.set('Chamfer','chamfer_rpm',self.chamfer_rpm.get_text())
self.save_op.set('Chamfer','chamfer_feed',self.chamfer_feed.get_text())
self.save_op.set('Chamfer','chamfer_hole_diameter',self.chamfer_hole_diameter.get_text())
self.save_op.set('Chamfer','chamfer_tip_angle',self.chamfer_tip_angle.get_text())
self.save_op.set('Chamfer','chamfer_tip_width',self.chamfer_tip_width.get_text())
self.save_op.set('Chamfer','chamfer_depth',self.chamfer_depth.get_text())
self.count += 1
if self.count > 0:
with open(fn, 'w') as configfile:
self.save_op.write(configfile)
else:
self.error_msg('Nothing selected to Save!')
def restore_ops(self, fn):
self.restore_op = ConfigParser.ConfigParser()
self.restore_op.read(fn)
# add tap here
if self.restore_op.has_section('Spot'):
self.spot_tool_number.set_text(self.restore_op.get('Spot','spot_tool_number'))
self.spot_rpm.set_text(self.restore_op.get('Spot','spot_rpm'))
self.spot_feed.set_text(self.restore_op.get('Spot','spot_feed'))
self.spot_diameter.set_text(self.restore_op.get('Spot','spot_diameter'))
self.spot_angle.set_text(self.restore_op.get('Spot','spot_angle'))
self.spot_depth.set_text(self.restore_op.get('Spot','spot_depth'))
if self.restore_op.has_section('Drill'):
self.drill_tool_number.set_text(self.restore_op.get('Drill','drill_tool_number'))
self.drill_rpm.set_text(self.restore_op.get('Drill','drill_rpm'))
self.drill_feed.set_text(self.restore_op.get('Drill','drill_feed'))
self.drill_peck.set_text(self.restore_op.get('Drill','drill_peck'))
self.drill_hole_depth.set_text(self.restore_op.get('Drill','drill_hole_depth'))
self.drill_diameter.set_text(self.restore_op.get('Drill','drill_diameter'))
self.drill_point_angle.set_text(self.restore_op.get('Drill','drill_point_angle'))
self.drill_total_depth.set_text(self.restore_op.get('Drill','drill_total_depth'))
if self.restore_op.has_section('Ream'):
self.ream_tool_number.set_text(self.restore_op.get('Ream','ream_tool_number'))
self.ream_feed.set_text(self.restore_op.get('Ream','ream_feed'))
self.ream_hole_depth.set_text(self.restore_op.get('Ream','ream_hole_depth'))
self.ream_rpm.set_text(self.restore_op.get('Ream','ream_rpm'))
if self.restore_op.has_section('Counterbore'):
self.counterbore_tool_number.set_text(self.restore_op.get('Counterbore','counterbore_tool_number'))
self.counterbore_depth.set_text(self.restore_op.get('Counterbore','counterbore_depth'))
self.counterbore_stepover.set_text(self.restore_op.get('Counterbore','counterbore_stepover'))
self.counterbore_doc.set_text(self.restore_op.get('Counterbore','counterbore_doc'))
self.counterbore_diameter.set_text(self.restore_op.get('Counterbore','counterbore_diameter'))
self.counterbore_tool_diameter.set_text(self.restore_op.get('Counterbore','counterbore_tool_diameter'))
self.counterbore_rpm.set_text(self.restore_op.get('Counterbore','counterbore_rpm'))
self.counterbore_feed.set_text(self.restore_op.get('Counterbore','counterbore_feed'))
if self.restore_op.has_section('Chamfer'):
self.chamfer_tool_number.set_text(self.restore_op.get('Chamfer','chamfer_tool_number'))
self.chamfer_rpm.set_text(self.restore_op.get('Chamfer','chamfer_rpm'))
self.chamfer_feed.set_text(self.restore_op.get('Chamfer','chamfer_feed'))
self.chamfer_hole_diameter.set_text(self.restore_op.get('Chamfer','chamfer_hole_diameter'))
self.chamfer_tip_angle.set_text(self.restore_op.get('Chamfer','chamfer_tip_angle'))
self.chamfer_tip_width.set_text(self.restore_op.get('Chamfer','chamfer_tip_width'))
self.chamfer_depth.set_text(self.restore_op.get('Chamfer','chamfer_depth'))
def on_window1_destroy(self, object, data=None):
gtk.main_quit()
def error_msg(self, msg):
self.message_dialog.format_secondary_text(msg)
self.response = self.message_dialog.run()
self.message_dialog.hide()
# menu items
def on_file_open_activate(self, menuitem, data=None):
self.fcd = gtk.FileChooserDialog("Open...",
None,
gtk.FILE_CHOOSER_ACTION_OPEN,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
self.filter = gtk.FileFilter()
self.filter.set_name("Ops Files")
self.filter.add_pattern("*.ops")
self.fcd.add_filter(self.filter)
self.filter = gtk.FileFilter()
self.filter.set_name("All Files")
self.filter.add_pattern("*")
self.fcd.add_filter(self.filter)
self.response = self.fcd.run()
if self.response == gtk.RESPONSE_OK:
self.restore_ops(self.fcd.get_filename())
self.fcd.destroy()
def on_file_save_activate(self, menuitem, data=None):
self.fcd = gtk.FileChooserDialog("Save...",
None,
gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE, gtk.RESPONSE_OK))
self.response = self.fcd.run()
if self.response == gtk.RESPONSE_OK:
self.save_ops(self.fcd.get_filename())
self.fcd.destroy()
def on_file_save_as_activate(self, menuitem, data=None):
self.fcd = gtk.FileChooserDialog("Save As...",
None,
gtk.FILE_CHOOSER_ACTION_SAVE,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE_AS, gtk.RESPONSE_OK))
self.response = self.fcd.run()
if self.response == gtk.RESPONSE_OK:
print "Selected filepath: %s" % self.fcd.get_filename()
self.fcd.destroy()
def on_file_quit_activate(self, menuitem, data=None):
gtk.main_quit()
def on_help_about_activate(self, menuitem, data=None):
self.response = self.aboutdialog.run()
self.aboutdialog.hide()
def on_help_contents_activate(self, menuitem, data=None):
webbrowser.open_new('file://' + current_path + '/contents/index.html')
# calculators
def on_calc_speed_feed_clicked(self, widget):
if not self.is_number(self.feed_per_tooth.get_text(), 'Feed/Tooth '):return
if not self.is_number(self.tool_teeth.get_text(), 'Feed/Tooth '):return
if not self.is_number(self.tool_diameter.get_text(), 'Tool Diameter '):return
if not self.is_number(self.cutting_speed.get_text(), 'SFM '):return
self.ipr = float(self.feed_per_tooth.get_text()) * int(self.tool_teeth.get_text())
self.ipr_label.set_text(str('IPR\n%.3f' % self.ipr))
self.rpm = (float(self.cutting_speed.get_text()) * 12) / (float(self.tool_diameter.get_text())*math.pi)
self.rpm_label.set_text('Spindle RPM\n%.0f' % self.rpm)
self.ipm_label.set_text('Feed IPM\n%.1f' %(self.ipr * self.rpm))
def on_calc_drill_clicked(self, widget):
if not self.is_number(self.drill_diameter_calc.get_text(), 'Drill Diameter '):return
if not self.is_number(self.drill_sfm.get_text(), 'Drill SFM '):return
if not self.is_number(self.drill_ipr.get_text(), 'Drill IPM '):return
self.calc_drill_rpm = (float(self.drill_sfm.get_text()) * 12)/(float(self.drill_diameter_calc.get_text())*math.pi)
self.calc_drill_rpm_label.set_text('Spindle RPM\n%.0f' % self.calc_drill_rpm)
self.drill_ipm = float(self.drill_ipr.get_text()) * self.calc_drill_rpm
self.drill_ipm_label.set_text('Drill IPM\n%.1f' % self.drill_ipm)
def on_entry_activate(self,widget):
widget.get_toplevel().child_focus(gtk.DIR_TAB_FORWARD)
def main():
main = mill()
gtk.main()
if __name__ == "__main__":
main()
```
|
{
"source": "jethornton/music",
"score": 3
}
|
#### File: jethornton/music/music.py
```python
import sys, os
from PyQt5 import uic
from PyQt5.QtCore import (QDir, QStandardPaths, QDirIterator, QFileInfo,
QUrl)
from PyQt5.QtWidgets import QApplication, QMainWindow, QFileDialog
from PyQt5.QtMultimedia import (QMediaPlayer, QMediaPlaylist,
QMediaContent)
class Music(QMainWindow):
def __init__(self, parent=None):
super().__init__()
uic.loadUi(QDir.current().absoluteFilePath('music.ui'), self)
#print(QDir.current().absoluteFilePath('music.ui'))
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.player.setPlaylist(self.playlist)
self.playMusicBtn.clicked.connect(self.player.play)
self.pauseMusicBtn.clicked.connect(self.player.pause)
self.stopMusicBtn.clicked.connect(self.player.stop)
self.nextMusicBtn.clicked.connect(self.playlist.next)
self.previousMusicButton.clicked.connect(self.playlist.previous)
self.openFilesBtn.clicked.connect(self.openFiles)
self.openDirectoryBtn.clicked.connect(self.openDir)
self.playlist.currentMediaChanged.connect(self.updateLabels)
self.show()
def buildPlayList(self, fileNames):
for name in fileNames:
print(name)
url = QUrl.fromLocalFile(name)
self.playlist.addMedia(QMediaContent(url))
#self.playlist.setPlaybackMode(QMediaPlaylist.Loop)
def openFiles(self):
#fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Files")
music = QStandardPaths.writableLocation(QStandardPaths.MusicLocation)
path, _ = QFileDialog.getOpenFileName(self, "Open file", directory=music,
options=QFileDialog.DontUseNativeDialog)
print(type(path))
print(path)
self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(path)))
print(type(path))
print(path)
def openDir(self):
#dir _ = QtGui.QFileDialog.getExistingDirectory(None, 'Select a directory:', 'C:\\', QtGui.QFileDialog.ShowDirsOnly)
home = QStandardPaths.writableLocation(QStandardPaths.HomeLocation)
d = QFileDialog.getExistingDirectory(caption="Choose Directory", directory=home,
options=QFileDialog.DontUseNativeDialog)
#print(x)
files = os.listdir(d)
#print(type(files))
for i in files:
path = os.path.join(d, i)
self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(path)))
#print('{} {}'.format(path, type(i)))
#print(os.listdir(path=x))
#self.buildPlayList(os.listdir(path=x))
songCount = self.playlist.mediaCount()
self.songsLoadedLbl.setText('Songs Loaded = {}'.format(songCount))
def updateLabels(self, media=None):
#print(media)
self.statusBar().showMessage(str(media.canonicalUrl().fileName()))
if __name__ == '__main__':
app = QApplication(sys.argv)
window = Music()
sys.exit(app.exec_())
```
|
{
"source": "jethornton/paraport",
"score": 2
}
|
#### File: src/libpport/buildcombos.py
```python
import subprocess
import shutil
#command = 'ls'
#print(shutil.which(command) is not None)
#cmd_exists = lambda x: shutil.which(x) is not None
#editors = ['gedit', 'geany', 'pyroom', 'pluma', 'scite', 'kwrite',
# 'kate', 'mousepad', 'jedit']
'''
rc = subprocess.check_output(['which', 'wget'], encoding='UTF-8')
print(rc)
if rc:
print('wget installed!')
else:
print('wget missing in path!')
'''
def build(parent):
linearUnits = [
['Select', False],
['Imperial', 'inch'],
['Metric', 'metric']
]
for item in linearUnits:
parent.linearUnitsCB.addItem(item[0], item[1])
gui = [
['Select', False],
['Axis', 'axis'],
['Touchy', 'touchy']
]
for item in gui:
parent.guiCB.addItem(item[0], item[1])
positionOffset = [
['Select', False],
['Relative', 'RELATIVE'],
['Machine', 'MACHINE']
]
for item in positionOffset:
parent.positionOffsetCB.addItem(item[0], item[1])
positionFeedback = [
['Select', False],
['Commanded', 'COMMANDED'],
['Actual', 'ACTUAL']
]
for item in positionFeedback:
parent.positionFeedbackCB.addItem(item[0], item[1])
drives = [
['Custom', False],
['Gecko 201', ['500', '4000', '20000', '1000']],
['Gecko 202', ['500', '4500', '20000', '1000']],
['Gecko 203v', ['1000', '2000', '200', '200']],
['Gecko 210', ['500', '4000', '20000', '1000']],
['Gecko 212', ['500', '4000', '20000', '1000']],
['Gecko 320', ['3500', '500', '200', '200']],
['Gecko 540', ['1000', '2000', '200', '200']],
['L297', ['500', '4000', '4000', '1000']],
['PMDX 150', ['1000', '2000', '1000', '1000']],
['Sherline', ['22000', '22000', '100000', '100000']],
['Xylotex BS-3', ['2000', '1000', '200', '200']],
['Parker 750', ['1000', '1000', '1000', '200000']],
['JVL SMD41/42', ['500', '500', '2500', '2500']],
['Hobbycnc', ['2000', '2000', '2000', '2000']],
['Keling 4030', ['5000', '5000', '20000', '20000']]
]
for item in drives:
parent.driveCB.addItem(item[0], item[1])
editors = {'Gedit':'gedit', 'Geany':'geany', 'Pyroom':'pyroom',
'Pluma':'pluma', 'Scite':'scite', 'Kwrite':'kwrite',
'Kate':'kate', 'Mousepad':'mousepad', 'Jedit':'jedit',
'XED':'xed'}
installed = False
for key, value in editors.items():
if shutil.which(value) is not None:
if not installed:
parent.editorCB.addItem('Select', False)
installed = True
parent.editorCB.addItem(key, value)
if not installed:
parent.editorCB.addItem('None', False)
parent.machinePTE.appendPlainText('No Editors were found!')
debug = [
['Debug Off', '0x00000000'],
['Debug Configuration', '0x00000002'],
['Debug Task Issues', '0x00000008'],
['Debug NML', '0x00000010'],
['Debug Motion Time', '0x00000040'],
['Debug Interpreter', '0x00000080'],
['Debug RCS', '0x00000100'],
['Debug Interperter List', '0x00000800'],
['Debug IO Control', '0x00001000'],
['Debug O Word', '0x00002000'],
['Debug Remap', '0x00004000'],
['Debug Python', '0x00008000'],
['Debug Named Parameters', '0x00010000'],
['Debug Gdbon Signal', '0x00020000'],
['Debug Python Task', '0x00040000'],
['Debug User 1', '0x10000000'],
['Debug User 2', '0x20000000'],
['Debug Unconditional', '0x40000000'],
['Debug All', '0x7FFFFFFF']
]
for item in debug:
parent.debugCB.addItem(item[0], item[1])
parent.pp1typeCB.addItem('Select', False)
parent.pp1typeCB.addItem('In', 'in')
parent.pp1typeCB.addItem('Out', 'out')
parent.pp2typeCB.addItem('Select', False)
parent.pp2typeCB.addItem('In', 'in')
parent.pp2typeCB.addItem('Out', 'out')
```
#### File: src/libpport/buildhal.py
```python
import os
from datetime import datetime
def build(parent):
halFilePath = os.path.join(parent.configPath, parent.configNameUnderscored + '.hal')
parent.machinePTE.appendPlainText(f'Building {halFilePath}')
halContents = []
halContents = ['# This file was created with the Parallel Port Configuration Tool on ']
halContents.append(datetime.now().strftime('%b %d %Y %H:%M:%S') + '\n')
halContents.append('# If you make changes to this file DO NOT run the configuration tool again!\n')
halContents.append('# This file will be replaced with a new file if you do!\n\n')
# build the standard header
halContents.append('# kinematics\n')
halContents.append('loadrt [KINS]KINEMATICS\n\n')
halContents.append('# motion controller\n')
halContents.append('loadrt [EMCMOT]EMCMOT ')
halContents.append('base_period_nsec=[EMCMOT]BASE_PERIOD ')
halContents.append('servo_period_nsec=[EMCMOT]SERVO_PERIOD ')
halContents.append('num_joints=[KINS]JOINTS\n\n')
portCfg = f'{parent.pport1AddrLE.text()} {parent.pp1typeCB.currentData()}'
if parent.pp2typeCB.currentData():
portCfg = portCfg + f' {parent.pport2AddrLE.text()} {parent.pp2typeCB.currentData()}'
halContents.append(f'loadrt hal_parport cfg="{portCfg}"\n')
halContents.append(f'setp parport.0.reset-time {parent.stepTimeLE.text()}\n\n')
stepgens = {1:'0', 2:'0,0', 3:'0,0,0', 4:'0,0,0,0'}
halContents.append(f'loadrt stepgen step_type={stepgens[len(parent.coordinatesLB.text())]}\n')
halContents.append('addf parport.0.read base-thread\n')
halContents.append('addf stepgen.make-pulses base-thread\n')
halContents.append('addf parport.0.write base-thread\n')
halContents.append('addf parport.0.reset base-thread\n\n')
halContents.append('addf stepgen.capture-position servo-thread\n')
halContents.append('addf motion-command-handler servo-thread\n')
halContents.append('addf motion-controller servo-thread\n')
halContents.append('addf stepgen.update-freq servo-thread\n')
for i in range(1, 9):
if parent.axisTabs.isTabEnabled(i):
pass
# check port 1 for axes
axes = ['X', 'Y', 'Z', 'A', 'B', 'C', 'U', 'V', 'W']
if parent.pp1typeCB.currentData() == 'out':
halpins = {'p1OutPB_0':'parport.0.pin-01-out',
'p1OutPB_1':'parport.0.pin-02-out',
'p1OutPB_2':'parport.0.pin-03-out',
'p1OutPB_3':'parport.0.pin-04-out',
'p1OutPB_4':'parport.0.pin-05-out',
'p1OutPB_5':'parport.0.pin-06-out',
'p1OutPB_6':'parport.0.pin-07-out',
'p1OutPB_7':'parport.0.pin-08-out',
'p1OutPB_8':'parport.0.pin-09-out',
'p1OutPB_9':'parport.0.pin-14-out',
'p1OutPB_10':'parport.0.pin-16-out',
'p1OutPB_11':'parport.0.pin-17-out',
'p1InPB_0':'parport.0.pin-10-in',
'p1InPB_1':'parport.0.pin-11-in',
'p1InPB_2':'parport.0.pin-12-in',
'p1InPB_3':'parport.0.pin-13-in',
'p1InPB_4':'parport.0.pin-15-in',}
else:
pins = {'p1OutPB_0':'parport.0.pin-01-out',
'p1OutPB_1':'parport.0.pin-14-out',
'p1OutPB_2':'parport.0.pin-16-out',
'p1OutPB_3':'parport.0.pin-17-out',
'p1InPB_0':'parport.0.pin-2-in',
'p1InPB_1':'parport.0.pin-3-in',
'p1InPB_2':'parport.0.pin-4-in',
'p1InPB_3':'parport.0.pin-5-in',
'p1InPB_4':'parport.0.pin-6-in',
'p1InPB_5':'parport.0.pin-7-in',
'p1InPB_6':'parport.0.pin-8-in',
'p1InPB_7':'parport.0.pin-9-in',
'p1InPB_8':'parport.0.pin-10-in',
'p1InPB_9':'parport.0.pin-11-in',
'p1InPB_10':'parport.0.pin-12-in',
'p1InPB_11':'parport.0.pin-13-in',
'p1InPB_12':'parport.0.pin-15-in',}
portpins = {'in':{'out':{0:'01', 1:'14', 2:'16', 3:'17'},
'in':{0:'2', 1:'3', 2:'4', 3:'5', 4:'6',
5:'7', 6:'8', 7:'9', 8:'10', 9:'11',
10:'12', 11:'13', 12:'15'}},
'out':{}}
axes = ['X Step', 'X Direction',
'Y Step', 'Y Direction',
'Z Step', 'Z Direction',
'A Step', 'A Direction',
'B Step', 'B Direction',
'C Step', 'C Direction',
'U Step', 'U Direction',
'V Step', 'V Direction',
'W Step', 'W Direction']
signal = {'X Step': 'x-step',
'X Direction': 'x-direction',
'Y Step': 'y-step',
'Y Direction': 'y-direction',
'Z Step': 'z-step',
'Z Direction': 'z-direction',
'A Step': 'a-step',
'A Direction': 'a-direction',
'B Step': 'b-step',
'B Direction': 'b-direction',
'C Step': 'c-step',
'C Direction': 'c-direction',
'U Step': 'u-step',
'U Direction': 'u-direction',
'V Step': 'v-step',
'V Direction': 'v-direction',
'W Step': 'w-step',
'W Direction': 'w-direction'}
pins = {'in':{'inpins':['02', '03', '04', '05', '06',
'07', '08', '09', '10', '11', '12', '13', '15'],
'outpins':['01', '14', '16', '17']},
'out':{'inpins':['10', '11', '12', '13', '15'],
'outpins':['01', '02', '03', '04', '05',
'06', '07', '08', '09', '14', '16', '17']}}
inPins = pins[parent.pp1typeCB.currentData()]['inpins']
outPins = pins[parent.pp1typeCB.currentData()]['outpins']
if len(set(parent.coordinatesLB.text())) != len(parent.coordinatesLB.text()):
print('gantry')
for axis in parent.coordinatesLB.text():
pass
halContents.append('\n# Axes\n')
halContents.append('net enable <= motion.motion-enabled\n')
for i, (k, v) in enumerate(parent.p1outBtns.items()):
if v.text() in axes:
signal = v.text().replace(' ', '-').lower()
halContents.append(f'net {signal} => parport.0.pin-{outPins[i]}-out\n')
#if p1inCkBxs p1outCkBxs
if parent.p1outCkBxs[f'p1OutCB_{i}'].isChecked():
halContents.append(f'setp parport.0.pin-{outPins[i]}-out-reset 1\n')
for k, v in parent.p2outBtns.items():
if v.text() in axes:
signal = v.text().replace(' ', '-').lower()
halContents.append(f'net {signal} => parport.1.pin-{outPins[i]}-out\n')
if parent.p2outCkBxs[f'p2OutCB_{i}'].isChecked():
halContents.append(f'setp parport.1.pin-{outPins[i]}-out-reset 1\n')
halContents.append('\n# Step Generators\n')
for i, k in enumerate(parent.coordinatesLB.text()):
halContents.append(f'setp stepgen.{i}.position-scale [JOINT_{i}]SCALE\n')
halContents.append(f'setp stepgen.{i}.steplen 1\n')
halContents.append(f'setp stepgen.{i}.stepspace 0\n')
halContents.append(f'setp stepgen.{i}.dirhold {parent.dirHoldLE.text()}\n')
halContents.append(f'setp stepgen.{i}.dirsetup {parent.dirSetupLE.text()}\n')
halContents.append(f'setp stepgen.{i}.maxaccel [JOINT_{i}]STEPGEN_MAX_ACC\n')
halContents.append(f'net {k.lower()}-position-command joint.{i}.motor-pos-cmd => stepgen.{i}.position-cmd\n')
halContents.append(f'net {k.lower()}-position-feedback stepgen.{i}.position-fb => joint.{i}.motor-pos-fb\n')
halContents.append(f'net {k.lower()}-step <= stepgen.{i}.step\n')
halContents.append(f'net {k.lower()}-direction <= stepgen.{i}.dir\n')
halContents.append(f'net enable => stepgen.{i}.enable\n\n')
'''
net xpos-cmd joint.0.motor-pos-cmd => stepgen.0.position-cmd
net xpos-fb stepgen.0.position-fb => joint.0.motor-pos-fb
net xstep <= stepgen.0.step
net xdir <= stepgen.0.dir
'''
halContents.append('\n# E-Stop Loopback\n')
halContents.append('net estop-loopback <= iocontrol.0.user-enable-out\n')
halContents.append('net estop-loopback => iocontrol.0.emc-enable-in\n')
# halContents.append(f'{i}\n')
# halContents.append('\n')
'''
halContents.append('\n# Port 1 Inputs\n')
for k, v in parent.p1inBtns.items():
if v.text() != 'Select':
signal = v.text().replace(' ', '-').lower()
halContents.append(f'net {signal} <= {pins[k]}\n')
'''
#print(pins[k])
#print(signal[v.text()])
'''
# don't forget to add not!!!
coords = parent.coordinatesLB.text()
port1 = list(parent.p1outBtns.items())
#print(type(port1[0]))
for l in coords:
halContents.append(f'# {l} Axis\n')
for i, (k, v) in enumerate(port1):
if v.text().startswith(l):
halContents.append(f'net {stepDir[v.text()]}_{i} => {pins[k]}\n')
del port1[i]
#print(f'{i} {k} {v.text()}')
'''
'''
#print(type(port1))
for i, c in enumerate(coords):
halContents.append(f'\n# {c} Axis Joint {i}\n')
for k, v in port1.items():
if v.text().startswith(c):
halContents.append(f'net {stepDir[v.text()]}_{i} => {pins[k]}\n')
del port1[k]
'''
'''
if parent.pp1typeCB:
#for k, v in parent.p1inBtns.items():
# print(v.text())
# print(pins[k])
halContents.append('\n# standard components\n')
halContents.append(f'loadrt pid num_chan={parent.axes} \n\n')
halContents.append('# hostmot2 driver\n')
halContents.append('loadrt hostmot2\n\n')
halContents.append('loadrt [HOSTMOT2](DRIVER) ')
halContents.append('board_ip=[HOSTMOT2](IPADDRESS) ')
if parent.stepgensCB.currentData():
halContents.append('num_stepgens=[HOSTMOT2](STEPGENS) ')
if parent.encodersCB.currentData():
halContents.append('config="num_encoders=[HOSTMOT2](ENCODERS) ')
if parent.pwmgensCB.currentData():
halContents.append('num_pwmgens=[HOSTMOT2](PWMS) ')
halContents.append(f'\nsetp hm2_[HOSTMOT2](BOARD).0.watchdog.timeout_ns {parent.servoPeriodSB.value() * 5}\n')
halContents.append('\n# THREADS\n')
halContents.append('addf hm2_[HOSTMOT2](BOARD).0.read servo-thread\n')
halContents.append('addf motion-command-handler servo-thread\n')
halContents.append('addf motion-controller servo-thread\n')
halContents.append('setp hm2_[HOSTMOT2](BOARD).0.dpll.01.timer-us -100\n')
halContents.append('setp hm2_[HOSTMOT2](BOARD).0.stepgen.timer-number 1 \n')
for i in range(len(parent.coordinatesLB.text())):
halContents.append(f'addf pid.{i}.do-pid-calcs servo-thread\n')
halContents.append('addf hm2_[HOSTMOT2](BOARD).0.write servo-thread\n')
for i in range(parent.axes):
halContents.append(f'\n# Joint {i}\n')
halContents.append('# axis enable chain\n')
halContents.append(f'newsig emcmot.{i}.enable bit\n')
halContents.append(f'sets emcmot.{i}.enable FALSE\n')
halContents.append(f'net emcmot.{i}.enable <= joint.{i}.amp-enable-out\n')
halContents.append(f'net emcmot.{i}.enable => hm2_[HOSTMOT2](BOARD).0.stepgen.0{i}.enable pid.{i}.enable\n\n')
halContents.append('# position command and feedback\n')
halContents.append(f'net emcmot.{i}.pos-cmd joint.{i}.motor-pos-cmd => pid.{i}.command\n')
halContents.append(f'net motor.{i}.pos-fb <= hm2_[HOSTMOT2](BOARD).0.stepgen.0{i}.position-fb joint.{i}.motor-pos-fb pid.{i}.feedback\n')
halContents.append(f'net motor.{i}.command pid.{i}.output hm2_[HOSTMOT2](BOARD).0.stepgen.0{i}.velocity-cmd\n')
halContents.append(f'setp pid.{i}.error-previous-target true\n\n')
halContents.append(f'setp hm2_[HOSTMOT2](BOARD).0.stepgen.0{i}.dirsetup [JOINT_{i}]DIRSETUP\n')
halContents.append(f'setp hm2_[HOSTMOT2](BOARD).0.stepgen.0{i}.dirhold [JOINT_{i}]DIRHOLD\n')
halContents.append(f'setp hm2_[HOSTMOT2](BOARD).0.stepgen.0{i}.steplen [JOINT_{i}]STEPLEN\n')
halContents.append(f'setp hm2_[HOSTMOT2](BOARD).0.stepgen.0{i}.stepspace [JOINT_{i}]STEPSPACE\n')
halContents.append(f'setp hm2_[HOSTMOT2](BOARD).0.stepgen.0{i}.position-scale [JOINT_{i}]SCALE\n')
halContents.append(f'setp hm2_[HOSTMOT2](BOARD).0.stepgen.0{i}.maxvel [JOINT_{i}]STEPGEN_MAX_VEL\n')
halContents.append(f'setp hm2_[HOSTMOT2](BOARD).0.stepgen.0{i}.maxaccel [JOINT_{i}]STEPGEN_MAX_ACC\n')
halContents.append(f'setp hm2_[HOSTMOT2](BOARD).0.stepgen.0{i}.step_type 0\n')
halContents.append(f'setp hm2_[HOSTMOT2](BOARD).0.stepgen.0{i}.control-type 1\n\n')
halContents.append(f'setp pid.{i}.Pgain [JOINT_{i}]P\n')
halContents.append(f'setp pid.{i}.Igain [JOINT_{i}]I\n')
halContents.append(f'setp pid.{i}.Dgain [JOINT_{i}]D\n')
halContents.append(f'setp pid.{i}.bias [JOINT_{i}]BIAS\n')
halContents.append(f'setp pid.{i}.FF0 [JOINT_{i}]FF0\n')
halContents.append(f'setp pid.{i}.FF1 [JOINT_{i}]FF1\n')
halContents.append(f'setp pid.{i}.FF2 [JOINT_{i}]FF2\n')
halContents.append(f'setp pid.{i}.deadband [JOINT_{i}]DEADBAND\n')
halContents.append(f'setp pid.{i}.maxoutput [JOINT_{i}]MAX_OUTPUT\n')
halContents.append(f'setp pid.{i}.maxerror [JOINT_{i}]MAX_ERROR\n')
if parent.spindleTypeCB.itemData(parent.spindleTypeCB.currentIndex()):
halContents.append('\n# Spindle\n')
halContents.append('setp hm2_[HOSTMOT2](BOARD).0.pwmgen.00.output-type [SPINDLE]OUTPUT_TYPE\n')
halContents.append('setp hm2_[HOSTMOT2](BOARD).0.pwmgen.00.scale [SPINDLE]MAX_RPM\n')
halContents.append('setp hm2_[HOSTMOT2](BOARD).0.pwmgen.pwm_frequency [SPINDLE]PWM_FREQUENCY\n')
halContents.append('net spindle-on spindle.0.on => hm2_[HOSTMOT2](BOARD).0.pwmgen.00.enable\n')
halContents.append('net spindle-speed spindle.0.speed-out => hm2_[HOSTMOT2](BOARD).0.pwmgen.00.value\n')
externalEstop = False
for i in range(6):
key = getattr(parent, 'outputPB_' + str(i)).text()
if key == 'E Stop Out':
externalEstop = True
if not externalEstop:
halContents.append('\n# Standard I/O Block - EStop, Etc\n')
halContents.append('# create a signal for the estop loopback\n')
halContents.append('net estop-loopback iocontrol.0.emc-enable-in <= iocontrol.0.user-enable-out\n')
if parent.manualToolChangeCB.isChecked():
halContents.append('\n# create signals for tool loading loopback\n')
halContents.append('net tool-prep-loop iocontrol.0.tool-prepare => iocontrol.0.tool-prepared\n')
halContents.append('net tool-change-loop iocontrol.0.tool-change => iocontrol.0.tool-changed\n')
if parent.ladderGB.isChecked():
halContents.append('\n# # Load Classicladder without GUI\n')
# this line needs to be built from the options if any are above 0
ladderOptions = []
for option in parent.ladderOptionsList:
if getattr(parent, option).value() > 0:
ladderOptions.append(getattr(parent, option).property('option') + '=' + str(getattr(parent, option).value()))
if ladderOptions:
halContents.append(f'loadrt classicladder_rt {" ".join(ladderOptions)}\n')
else:
halContents.append('loadrt classicladder_rt\n')
halContents.append('addf classicladder.0.refresh servo-thread 1\n')
'''
try:
with open(halFilePath, 'w') as halFile:
halFile.writelines(halContents)
return True
except OSError:
parent.machinePTE.appendPlainText(f'OS error\n {traceback.print_exc()}')
return False
```
|
{
"source": "jethornton/plasma_v2",
"score": 2
}
|
#### File: plasma_v2/plasma_v2/mainwindow.py
```python
from qtpyvcp.widgets.form_widgets.main_window import VCPMainWindow
from PyQt5.QtSql import QSqlDatabase
# Setup logging
from qtpyvcp.utilities import logger
LOG = logger.getLogger('qtpyvcp.' + __name__)
import plasma_v2.nest as nest
import plasma_v2.nozzles as nozzles
import plasma_v2.create as create
import os
current_path = os.path.dirname(os.path.realpath(__file__)) + '/'
class MyMainWindow(VCPMainWindow):
"""Main window class for the VCP."""
def __init__(self, *args, **kwargs):
super(MyMainWindow, self).__init__(*args, **kwargs)
db = QSqlDatabase.addDatabase('QSQLITE')
db.setDatabaseName(current_path + 'plasma.db')
if db.open():
print("Connection success !")
else:
print("Connection failed !\n{}".format(db.lastError().text()))
nozzles.initNozzles(self)
nest.initNest(self)
create.initCreate(self)
def on_exitAppBtn_clicked(self):
self.app.quit()
```
|
{
"source": "jethornton/python3",
"score": 3
}
|
#### File: python3/examples/event-timer.py
```python
import signal, schedule
from PyQt5.QtCore import QTimer
class main():
def __init__(self, parent=None):
print('starting')
# catch ctrl c and run cleanExit
signal.signal(signal.SIGINT, self.cleanExit)
schedule.every().second.do(self.run)
def run(self):
schedule.run_pending()
print('press ctrl c to exit')
def cleanExit(self):
print('\nClean Exit')
sys.exit()
if __name__ == '__main__':
main()
```
|
{
"source": "jethro2/Resume-Ranker",
"score": 3
}
|
#### File: jethro2/Resume-Ranker/ranker.py
```python
__scriptname__ = "Resume Ranker"
__author__ = "<NAME>"
__copyright__ = "Copyright 2017"
__credits__ = []
__license__ = "GPL"
__version__ = "1.0.0"
__maintainer__ = "<NAME>"
__email__ = "<EMAIL>"
__status__ = "Development"
import os, PyPDF2, csv
from docopt import docopt
from os import sys, path
from docx import Document
from docx.document import Document as _Document
from docx.oxml.text.paragraph import CT_P
from docx.oxml.table import CT_Tbl
from docx.table import _Cell, Table
from docx.text.paragraph import Paragraph
class Environment:
"""
Setup the environment for the script; including opening any required files, checking
validity of files and directories, etc.
--
:param string|None dir - string containing the directory for iteration containing files
:param string keyword_file - string containing full file path to location of keyword file
:return Object Environment
"""
def __init__(self, dir=None, keyword_file=None):
self.dir = dir
self.keyword_file = keyword_file
def is_directory_given(self):
# check if the user provided a directory to iterate through
if not self.dir :
raise Exception("A directory must be provided. See --help option for script usage details.")
return self
def is_valid_directory(self):
# check if the directory provided by the user for files exists
if dir and not os.path.isdir(self.dir) :
raise Exception("The directory provided is not valid or found.")
return self
def is_valid_keyword_file(self):
# check if the file provided by the user for keywords exists
if not os.path.isfile(self.keyword_file):
raise Exception("The keyword file path provided is not valid or does not exist.")
return self
class Parsing:
"""
This class is designed to contain all necessary file parsing methodologies.
Each file passed as object instantiation parameter will be parsed into plain text
form and provided back to calling function.
--
:param string path - string containing the full file path of the file to open and parse into variable text
:return Object Parsing
"""
def __init__(self, path):
self.file = path
self.results = self.parse_file()
def parse_file(self) :
"""
Check the file extension against known/valid extensions and call
associated parsing method appropriately.
"""
# get the file extension from the filename
extension = os.path.splitext(self.file)[1]
# create an empty string variable
results = None
# if the file passed in is a valid file
if os.path.isfile(self.file) :
# figure out extension to determine what parsing methodology to use
d = { '.docx' : self.parse_word_doc
,'.pdf' : self.parse_pdf_doc
,'.txt' : self.parse_txt_doc
}
# invoke the value of the dict returned by extension key match
results = d[extension]()
return results
def parse_word_doc(self):
"""
Open a word document filetype and parse contents to string variable
for matching comparison.
"""
def iter_block_items(parent):
"""
Generate a reference to each paragraph and table child within *parent*,
in document order. Each returned value is an instance of either Table or
Paragraph. *parent* would most commonly be a reference to a main
Document object, but also works for a _Cell object, which itself can
contain paragraphs and tables.
"""
if isinstance(parent, _Document):
parent_elm = parent.element.body
elif isinstance(parent, _Cell):
parent_elm = parent._tc
for child in parent_elm.iterchildren():
if isinstance(child, CT_P):
yield Paragraph(child, parent)
elif isinstance(child, CT_Tbl):
yield Table(child, parent)
# create empty string variable for storing file content
docText = ''
# set the document object with the file
document = Document(self.file)
# iterate over blocks in the document object
for block in iter_block_items(document) :
# if block type is paragraph, simply grab text from paragraph
if isinstance(block, Paragraph) :
# append block text to text variable
docText += block.text
# if block type is table, we must iterate over the table components to get
# content out of the cells
elif isinstance(block, Table) :
# iterate over the rows inside the table
for row in block.rows :
# iterate over each cell inside each row
for cell in row.cells :
# append cell text to text variable
docText += cell.text
return docText.strip() or None
def parse_pdf_doc(self):
"""
Open a pdf document filetype and parse contents to string variable
for matching comparison.
"""
docText = ''
# open the file, with read/binary priviledges
f = open(self.file, 'rb')
pdf = PyPDF2.PdfFileReader(f)
for page in pdf.pages :
docText += page.extractText()
f.close()
return docText.strip() or None
def parse_txt_doc(self):
"""
Open a text document filetype and parse contents to string variable
for matching comparison.
"""
# open the file, with read priviledges
with open(self.file, 'r') as f :
docText = f.read()
return docText.strip() or None
class Rank :
"""
Use this function to determine the appropriate ranking/score of each file.
When instantiated, this class will first load the keywords file
--
:param list keyword_list - list containing each keyword found in keyword_file
:return Object Rank
"""
def __init__(self, keyword_list):
self.keywords = keyword_list
self.total_keys = len(self.keywords)
def get_rank(self, text):
"""
Get the rank of the file based on total count of keywords found in the file
contents.
"""
# set the initial rank and count to 0
rank = count = 0
# get the percentage that each keyword is worth
word_percentage = round(float(100)/float(len(self.keywords)), 2)
# iterate over list of keywords
for keyword in self.keywords :
keyword, multiplier = self.get_multiplier(keyword)
# was the keyword found in the file? increase overall percentage if true
rank += word_percentage if keyword.upper() in text.upper() else 0
# get the number of occurrences of the keyword in the file
count += text.upper().count( keyword.upper() ) * int( multiplier )
return (rank,count)
def get_multiplier(self, keyword):
"""
Split the keyword on multiplier delimiter if found. Otherwise provide 1 for multiplier
"""
multiplier = 1
# set the multiplier if found in the file
if ' *' in keyword :
keyword,multiplier = keyword.split(' *')
return (keyword, multiplier)
class File :
"""
Use this method to hold any method related to file interaction including,
gathering list of valid files, acting upon that list, and renaming files.
--
:param string|None dir - string containing the directory for iteration containing files
:param string keyword_file - string containing full file path to location of keyword file
:return Object File
"""
def __init__(self, dir=None, keyword_file=None):
self.dir = dir
self.keyword_file = keyword_file
self.keywords_list = []
self.file_buf = []
self.files = None
def get_keyword_list(self, keyword_file=None):
"""
Create the list of keywords from the keywords file defined by user.
--
:param string keyword_file|None - string containing full file path to location of keyword file
:return Object Environment
"""
# allow keyword file override
self.keyword_file = keyword_file or self.keyword_file
with open(self.keyword_file, 'r') as f:
content = f.readlines()
if len(content) == 0 :
raise Exception("No keywords found for ranking, in %s." % self.keyword_file)
self.keywords_list = [l.strip() for l in content]
# return self for method chaining
return self
def get_files(self, valid_types):
"""
Get a list of valid files found in iteration directory.
--
:param list valid_types - list containing valid file extensions for parsing.
:return Object File
"""
# get a list of files in the directory (files only)
self.files = [f for f in os.listdir( self.dir ) if os.path.isfile(os.path.join(self.dir, f )) and os.path.splitext(f)[1] in valid_types and f != os.path.basename(self.keyword_file) and "~$" not in f]
# throw error if no valid files are found in directory
if len(self.files) == 0 :
raise Exception("The directory provided has no valid files. Valid types include: .docx, .pdf, .txt")
# return self for method chaining
return self
def file_iterator(self):
# iterate over the valid files list
for f in self.files :
# remove the last character in the dir string if it is a slash for another directory
path = os.path.join( self.dir.rstrip('//'), f )
# instantiate an empty parsing object
p = Parsing(path)
# are there any results?
if p.results :
# instantiate the Rank object with the keyword_file passed as argument
r = Rank(self.keywords_list)
# pass the location of the keyword file, and the results to review into the rank class
# get_rank returns a tuple of (rank, total_count)
rank,total_count = r.get_rank(p.results)
# get the filename, regardless of if there is already a percentage in front of filename or not
filename_li = f.split('] - ')
# reverse the filename split so the actual file name is always in position 0 of the list
filename_li.reverse()
# add the file information to the file buffer to be used for the last iteration
self.file_buf.append({ 'orig_path' : path
,'orig_name' : filename_li[0]
,'dir' : self.dir.rstrip('//')
,'percent_rank' : rank
,'total_count' : total_count
})
# return self for method chaining
return self
def calc_percentile(self):
# if file_buf has information in it
if len(self.file_buf) :
# resort the file list based on the total_count, in descending order so the first element is always the highest count
self.files = sorted(self.file_buf, key=lambda k: k['total_count'], reverse=True)
# iterate over the newly sorted files list
for i, d in enumerate(self.files):
percentile = self.get_percentile(d, self.files[0])
# set the new filename with percentile and count included in filename
d['new_name'] = "%s%% [%s] - %s" % (percentile, d['total_count'], d['orig_name'])
d['percentile'] = percentile
# return self for method chaining
return self
def get_percentile(self, d, f):
return round( ( float(d['total_count']) / float(f['total_count']) ) * 100, 2)
def finish_output(self, output_type=None, output_file=None, rename=None, verbose=None) :
"""
Finally output the results in the preferred method specified by the user. Or defaulted to file renaming.
--
:param string|None output_type - user defined string containing the intended output file extension type from available values
:param string|None output_file - user defined string of full path location and filename of output file
:param bool|None rename - boolean flag defining whether original file names should be renamed with new filenames including percentile
:param bool|None verbose - boolean flag defining whether output resulting filenames should be printed to console
"""
try :
f = None
# open the file pointer if output_file is specified
if output_file :
f = open(output_file, 'w')
# if the file type is csv then initialize the csv writer object
if output_type and output_type.upper() == 'CSV' :
writer = csv.writer(f)
# write the header row to the
writer.writerow( ('Percentile', 'Total Count', 'File Name') )
for i, d in enumerate(self.files) :
if verbose:
# print the new filename to the console for the user
print( os.path.basename(d['new_name']) )
# only rename the files if the rename option is set to true
if rename:
self.rename_file( d['orig_path'], os.path.join(d['dir'], d['new_name']) )
# append the filename to a string to be used to write to a file at the end of this iteration
if output_type and output_type.upper() == 'TXT' :
f.write( "%s\n" % d['new_name'] )
if output_type and output_type.upper() == 'CSV' :
writer.writerow( (d['percentile'], d['total_count'], d['new_name']) )
finally :
# close the file pointer if it exists
if f :
f.close()
def rename_file(self, opath, npath):
# rename the file name with the new rank
os.rename(opath, npath)
if __name__ == "__main__" :
# Docopt will check all arguments, and exit with the Usage string if they don't pass.
# If you simply want to pass your own modules documentation then use __doc__,
# otherwise, you would pass another docopt-friendly usage string here.
# You could also pass your own arguments instead of sys.argv with: docopt(__doc__, argv=[your, args])
docopt_args = docopt(__doc__, version='Resume Ranker 1.0.0')
verbosity = docopt_args["-v"]
rename = docopt_args["--rename"] or 'YES'
dir = docopt_args["--dir"]
keyword_file = docopt_args["--keyword-file"]
output_type = docopt_args["--output-type"]
output_file = docopt_args["--output-file"]
## -------------- CLI Argument Normalization ---------------- ##
# normalize the rename option text to True/False
rename = True if rename and rename.upper() == 'YES' else False
# ensure the user input conforms to the available output types
if output_type and output_type.upper() not in ['CSV', 'TXT']:
raise Exception("Invalid value supplied to --output-type argument. See --help for details.")
# ensure the output file is a valid directory first
e = Environment(path.dirname(output_file)).is_valid_directory()
try :
# instantiate the environment object where we will check that all environment paths and file names are valid
# begin checking the paths and files, throw exception if something is not right
e = Environment(dir, keyword_file).is_directory_given()\
.is_valid_directory()\
.is_valid_keyword_file()
# set a list of the valid file types we can use, .docx, .pdf, .txt
valid_types = ['.docx', '.txt', '.pdf']
f = File(e.dir, e.keyword_file).get_keyword_list()\
.get_files(valid_types)\
.file_iterator()\
.calc_percentile()\
.finish_output(output_type, output_file, rename, verbosity)
except Exception:
raise
```
|
{
"source": "jethro33/napari-live-recording",
"score": 3
}
|
#### File: src/napari_live_recording/__init__.py
```python
from napari.viewer import Viewer
import napari_live_recording.devices as devices
from napari_live_recording.widgets import CameraSelection
from napari_live_recording.control import Controller
from qtpy.QtWidgets import QWidget, QFormLayout, QGroupBox
class NapariLiveRecording(QWidget):
def __init__(self, napari_viewer : Viewer) -> None:
super().__init__()
self.viewer = napari_viewer
self.mainLayout = QFormLayout()
self.selectionWidget = CameraSelection()
self.selectionWidget.setAvailableCameras(list(devices.devicesDict.keys()))
self.controller = Controller(self)
self.mainLayout.addRow(self.selectionWidget.group)
self.viewer.layers.events.removed.connect(self.controller.clearAlbumBuffer)
# Creates a new camera object and passes it to the controller
# whenever the add button is pressed
self.selectionWidget.newCameraRequested.connect(self.addNewCamera)
self.controller.cameraDeleted.connect(self.deleteCameraWidget)
self.setLayout(self.mainLayout)
def addNewCamera(self, type: str, name, idx: str) -> None:
camera = devices.devicesDict[type](name, idx)
self.mainLayout.addRow(self.controller.addCamera(camera))
def deleteCameraWidget(self, widget: QGroupBox) -> None:
self.mainLayout.removeRow(widget)
def refreshViewer(self, img, layerName) -> None:
""" Slot triggered every time a camera acquires a frame.
Creates a new layer on the viewer with the received image as content.
If the layer already exists, it updates its content.
Args:
img (np.ndarray): image data.
layerName (str): name of the layer to create/update.
"""
if img is not None:
try:
# layer is recreated in case the image changes type (i.e. grayscale -> RGB and viceversa)
if img.ndim != self.viewer.layers[layerName].data.ndim:
self.viewer.layers.remove(layerName)
self.viewer.add_image(img, name = layerName)
else:
self.viewer.layers[layerName].data = img
except KeyError:
# needed in case the layer of that live recording does not exist
self.viewer.add_image(img, name = layerName)
```
#### File: napari_live_recording/widgets/widgets.py
```python
from typing import Union
from qtpy.QtCore import Qt, QObject, Signal, QTimer
from qtpy.QtWidgets import (
QWidget,
QLabel,
QComboBox,
QSpinBox,
QDoubleSpinBox,
QLineEdit,
QPushButton
)
from superqt import QLabeledSlider
from qtpy.QtWidgets import QFormLayout, QGridLayout, QGroupBox
from abc import ABC, abstractmethod
from dataclasses import replace
from napari_live_recording.common import ROI
from enum import Enum
class Timer(QTimer):
pass
class WidgetEnum(Enum):
ComboBox = 0,
SpinBox = 1,
DoubleSpinBox = 2,
LabeledSlider = 3,
LineEdit = 4
class LocalWidget(ABC):
def __init__(self, internalWidget : QWidget, name: str, unit: str = "", orientation: str = "left") -> None:
"""Common widget constructor.
Args:
internalWidget (QWidget): widget to construct the form layout.
name (str): parameter label description.
unit (str, optional): parameter unit measure. Defaults to "".
orientation (str, optional): label orientation on the layout. Defaults to "left".
"""
self.__name = name
self.__unit = unit
labelStr = (self.__name + " (" + self.__unit + ")" if self.__unit != "" else self.__name)
self.label = QLabel(labelStr)
self.label.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.widget = internalWidget
@property
def isEnabled(self) -> bool:
"""Widget is enabled for editing (True) or not (False).
"""
return self.widget.isEnabled()
@isEnabled.setter
def isEnabled(self, enable : bool) -> None:
"""Sets widget enabled for editing (True) or not (False).
"""
self.widget.setEnabled(enable)
@abstractmethod
def changeWidgetSettings(self, newParam) -> None:
"""Common widget update parameter abstract method.
"""
pass
@property
@abstractmethod
def value(self) -> None:
"""Widget current value.
"""
pass
@value.setter
@abstractmethod
def value(self, value: Union[str, int, float]) -> None:
"""Widget value setter.
"""
pass
@property
@abstractmethod
def signals(self) -> dict[str, Signal]:
"""Common widget method to expose signals to the device.
"""
pass
class ComboBox(LocalWidget):
def __init__(self, param : list[str], name : str, unit : str = "", orientation: str = "left") -> None:
"""ComboBox widget.
Args:
param (list[str]): list of parameters added to the ComboBox.
name (str): parameter label description.
unit (str, optional): parameter unit measure. Defaults to "".
orientation (str, optional): label orientation on the layout. Defaults to "left".
"""
self.combobox = QComboBox()
self.combobox.addItems(param)
super().__init__(self.combobox, name, unit, orientation)
def changeWidgetSettings(self, newParam: list[str]) -> None:
"""ComboBox update widget parameter method. Old list of items is deleted.
Args:
newParam (list[str]): new list of parameters to add to the ComboBox.
"""
self.combobox.clear()
self.combobox.addItems(newParam)
@property
def value(self) -> tuple[str, int]:
"""Returns a tuple containing the ComboBox current text and index.
"""
return (self.combobox.currentText(), self.combobox.currentIndex())
@value.setter
def value(self, value: int) -> None:
"""Sets the ComboBox current showed value (based on elements indeces).
Args:
value (int): index of value to show on the ComboBox.
"""
self.combobox.setCurrentIndex(value)
@property
def signals(self) -> dict[str, Signal]:
"""Returns a dictionary of signals available for the ComboBox widget.
Exposed signals are:
- currentIndexChanged,
- currentTextChanged
Returns:
dict: dict of signals (key: function name, value: function objects).
"""
return {
"currentIndexChanged" : self.combobox.currentIndexChanged,
"currentTextChanged" : self.combobox.currentTextChanged
}
class SpinBox(LocalWidget):
def __init__(self, param: tuple[int, int, int], name: str, unit: str = "", orientation: str = "left") -> None:
"""SpinBox widget.
Args:
param (tuple[int, int, int]): parameters for SpinBox settings: (<minimum_value>, <maximum_value>, <starting_value>)
name (str): parameter label description.
unit (str, optional): parameter unit measure. Defaults to "".
orientation (str, optional): label orientation on the layout. Defaults to "left".
"""
self.spinbox = QSpinBox()
self.spinbox.lineEdit().setAlignment(Qt.AlignmentFlag.AlignCenter)
self.spinbox.setRange(param[0], param[1])
self.spinbox.setValue(param[2])
super().__init__(self.spinbox, name, unit, orientation)
def changeWidgetSettings(self, newParam : tuple[int, int, int]) -> None:
"""SpinBox update widget parameter method.
Args:
newParam (tuple(int, int, int)): new parameters for SpinBox settings: (<minimum_value>, <maximum_value>, <starting_value>)
"""
self.spinbox.setRange(newParam[0], newParam[1])
self.spinbox.setValue(newParam[2])
@property
def value(self) -> int:
"""Returns the SpinBox current value.
"""
return self.spinbox.value()
@value.setter
def value(self, value: int) -> None:
"""Sets the SpinBox current value to show on the widget.
Args:
value (int): value to set.
"""
self.spinbox.setValue(value)
@property
def signals(self) -> dict[str, Signal]:
"""Returns a dictionary of signals available for the SpinBox widget.
Exposed signals are:
- valueChanged,
- textChanged
Returns:
dict: dict of signals (key: function name, value: function objects).
"""
return {
"valueChanged" : self.spinbox.valueChanged,
"textChanged" : self.spinbox.textChanged
}
class DoubleSpinBox(LocalWidget):
def __init__(self, param: tuple[float, float, float], name: str, unit: str = "", orientation: str = "left") -> None:
"""DoubleSpinBox widget.
Args:
param (tuple[float, float, float]): parameters for spinbox settings: (<minimum_value>, <maximum_value>, <starting_value>)
name (str): parameter label description.
unit (str, optional): parameter unit measure. Defaults to "".
orientation (str, optional): label orientation on the layout. Defaults to "left".
"""
self.__spinbox = QDoubleSpinBox()
self.__spinbox.setRange(param[0], param[1])
self.__spinbox.setValue(param[2])
super().__init__(self.__spinbox, name, unit, orientation)
def changeWidgetSettings(self, newParam : tuple[float, float, float]) -> None:
"""DoubleSpinBox update widget parameter method.
Args:
newParam (tuple[float, float, float]): new parameters for SpinBox settings: (<minimum_value>, <maximum_value>, <starting_value>)
"""
self.__spinbox.setRange(newParam[0], newParam[1])
self.__spinbox.setValue(newParam[2])
@property
def value(self) -> float:
"""Returns the DoubleSpinBox current value.
"""
return self.__spinbox.value()
@value.setter
def value(self, value: float) -> None:
"""Sets the DoubleSpinBox current value to show on the widget.
Args:
value (float): value to set.
"""
self.__spinbox.setValue(value)
@property
def signals(self) -> dict[str, Signal]:
"""Returns a dictionary of signals available for the SpinBox widget.
Exposed signals are:
- valueChanged,
- textChanged
Returns:
dict: dict of signals (key: function name, value: function objects).
"""
return {
"valueChanged" : self.__spinbox.valueChanged,
"textChanged" : self.__spinbox.textChanged
}
class LabeledSlider(LocalWidget):
def __init__(self, param: tuple[int, int, int], name: str, unit: str = "", orientation: str = "left") -> None:
"""Slider widget.
Args:
param (tuple[int, int, int])): parameters for spinbox settings: (<minimum_value>, <maximum_value>, <starting_value>)
name (str): parameter label description.
unit (str, optional): parameter unit measure. Defaults to "".
orientation (str, optional): label orientation on the layout. Defaults to "left".
"""
self.__slider = QLabeledSlider(Qt.Horizontal)
self.__slider.setRange(param[0], param[1])
self.__slider.setValue(param[2])
super().__init__(self.__slider, name, unit, orientation)
def changeWidgetSettings(self, newParam : tuple[int, int, int]) -> None:
"""Slider update widget parameter method.
Args:
newParam (tuple[int, int, int]): new parameters for SpinBox settings: (<minimum_value>, <maximum_value>, <starting_value>)
"""
self.__slider.setRange(newParam[0], newParam[1])
self.__slider.setValue(newParam[2])
@property
def value(self) -> int:
"""Returns the Slider current value.
"""
return self.__slider.value()
@value.setter
def value(self, value: int) -> None:
"""Sets the DoubleSpinBox current value to show on the widget.
Args:
value (float): value to set.
"""
self.__slider.setValue(value)
@property
def signals(self) -> dict[str, Signal]:
"""Returns a dictionary of signals available for the SpinBox widget.
Exposed signals are:
- valueChanged
Returns:
dict: dict of signals (key: function name, value: function objects).
"""
return {
"valueChanged" : self.__slider.valueChanged
}
class LineEdit(LocalWidget):
def __init__(self, param: str, name: str, unit: str = "", orientation: str = "left") -> None:
"""LineEdit widget.
Args:
param (str): line edit contents
name (str): parameter label description.
unit (str, optional): parameter unit measure. Defaults to "".
orientation (str, optional): label orientation on the layout. Defaults to "left".
editable (bool, optional): sets the LineEdit to be editable. Defaults to False.
"""
self.__lineEdit = QLineEdit(param)
super().__init__(self.__lineEdit, name, unit, orientation)
def changeWidgetSettings(self, newParam : str) -> None:
"""Updates LineEdit text contents.
Args:
newParam (str): new string for LineEdit.
"""
self.__lineEdit.setText(newParam)
@property
def value(self) -> str:
"""Returns the LineEdit current text.
"""
return self.__lineEdit.text()
@value.setter
def value(self, value: str) -> None:
"""Sets the LineEdit current text to show on the widget.
Args:
value (str): string to set.
"""
self.__lineEdit.setText(value)
@property
def signals(self) -> dict[str, Signal]:
"""Returns a dictionary of signals available for the LineEdit widget.
Exposed signals are:
- textChanged,
- textEdited
Returns:
dict: dict of signals (key: function name, value: function objects).
"""
return {
"textChanged" : self.__lineEdit.textChanged,
"textEdited" : self.__lineEdit.textEdited
}
class CameraSelection(QObject):
newCameraRequested = Signal(str, str, str)
def __init__(self) -> None:
"""Camera selection widget. It includes the following widgets:
- a ComboBox for camera selection based on strings to identify each camera type;
- a LineEdit for camera ID or serial number input
- a QPushButton to add the camera
Widget grid layout:
|(0,0-1) ComboBox |(0,2) QPushButton|
|(1,0) LineEdit|Line Edit(1,1) |(1,2) |
The QPushButton remains disabled as long as no camera is selected (first index is highlited).
"""
super(CameraSelection, self).__init__()
self.group = QGroupBox()
self.camerasComboBox = ComboBox([], "Interface")
self.nameLineEdit = LineEdit(param="MyCamera", name="Camera name")
self.idLineEdit = LineEdit(param="0", name="Camera ID/SN", orientation="right")
self.addButton = QPushButton("Add camera")
self.addButton.setEnabled(False)
# create widget layout
self.camerasComboBox.signals["currentIndexChanged"].connect(self._setAddEnabled)
self.addButton.clicked.connect(lambda: self.newCameraRequested.emit(self.camerasComboBox.value[0], self.nameLineEdit.value, self.idLineEdit.value))
self.formLayout = QFormLayout()
self.formLayout.addRow(self.camerasComboBox.label, self.camerasComboBox.widget)
self.formLayout.addRow(self.nameLineEdit.label, self.nameLineEdit.widget)
self.formLayout.addRow(self.idLineEdit.label, self.idLineEdit.widget)
self.formLayout.addRow(self.addButton)
self.group.setLayout(self.formLayout)
self.group.setFlat(True)
def setAvailableCameras(self, cameras: list[str]) -> None:
"""Sets the ComboBox with the list of available camera devices.
Args:
cameras (list[str]): list of available camera devices.
"""
# we need to extend the list of available cameras with a selection text
cameras.insert(0, "Select device")
self.camerasComboBox.changeWidgetSettings(cameras)
self.camerasComboBox.isEnabled = True
def _setAddEnabled(self, idx: int):
"""Private method serving as an enable/disable mechanism for the Add button widget.
This is done to avoid the first index, the "Select device" string, to be considered
as a valid camera device (which is not).
"""
if idx > 0:
self.addButton.setEnabled(True)
else:
self.addButton.setEnabled(False)
class RecordHandling(QObject):
recordRequested = Signal(int)
def __init__(self) -> None:
"""Recording Handling widget. Includes QPushButtons which allow to handle the following operations:
- live viewing;
- recording to output file;
- single frame snap;
- album stacking snap.
Widget layout:
|(0,0) QPushButton (Snap)|(0,1) QPushButton (Album)|(0,2) QPushButton (Live) |
|(1,0-1) QSpinBox (Record size) |(0,2) QPushButton (Record)|
"""
QObject.__init__(self)
self.group = QGroupBox()
self.layout = QGridLayout()
self.snap = QPushButton("Snap")
self.album = QPushButton("Album")
self.live = QPushButton("Live")
# the live button is implemented as a toggle button
self.live.setCheckable(True)
self.recordSpinBox = QSpinBox()
self.recordSpinBox.lineEdit().setAlignment(Qt.AlignmentFlag.AlignCenter)
# todo: this is currently hardcoded
# maybe should find a way to initialize
# from outside the instance?
self.recordSpinBox.setRange(1, 5000)
self.recordSpinBox.setValue(100)
self.record = QPushButton("Record")
self.layout.addWidget(self.snap, 0, 0)
self.layout.addWidget(self.album, 0, 1)
self.layout.addWidget(self.live, 0, 2)
self.layout.addWidget(self.recordSpinBox, 1, 0, 1, 2)
self.layout.addWidget(self.record, 1, 2)
self.group.setLayout(self.layout)
# whenever the live button is toggled,
# the other pushbutton must be enabled/disabled
# in order to avoid undefined behaviors
# when grabbing frames from the device
self.live.toggled.connect(self._handleLiveToggled)
def setWidgetsEnabling(self, isEnabled : bool) -> None:
""" Enables/Disables all record handling widgets. """
self.snap.setEnabled(isEnabled)
self.album.setEnabled(isEnabled)
self.live.setEnabled(isEnabled)
self.record.setEnabled(isEnabled)
self.recordSpinBox.setEnabled(isEnabled)
def _handleLiveToggled(self, status: bool) -> None:
"""Enables/Disables pushbuttons when the live button is toggled.
Args:
status (bool): new live button status.
"""
self.snap.setEnabled(not status)
self.album.setEnabled(not status)
self.record.setEnabled(not status)
@property
def recordSize(self) -> int:
"""Returns the record size currently indicated in the QSpinBox widget.
"""
return self.recordSpinBox.value()
@property
def signals(self) -> dict[str, Signal]:
"""Returns a dictionary of signals available for the RecordHandling widget.
Exposed signals are:
- snapRequested,
- albumRequested,
- liveRequested,
- recordRequested
Returns:
dict: dict of signals (key: function name, value: function objects).
"""
return {
"snapRequested" : self.snap.clicked,
"albumRequested" : self.album.clicked,
"liveRequested" : self.live.toggled,
"recordRequested" : self.record.clicked,
}
class ROIHandling(QObject):
changeROIRequested = Signal(ROI)
fullROIRequested = Signal(ROI)
def __init__(self, sensorShape : ROI) -> None:
"""ROI Handling widget. Defines a set of non-custom widgets to set the Region Of Interest of the device.
This widget is common for all devices.
Args:
cameraROI (ROI): data describing the device sensor shape and step value to increment/decrement each parameter.
"""
QObject.__init__(self)
# todo: maybe this is inefficient...
# in previous implementation
# copying the reference would cause
# issues when changing the ROI
# so we'll create a local copy
# and discard the input
self.sensorFullROI = replace(sensorShape)
# todo: these widgets are not
# our custom LocalWidgets
# but since they are common
# for all types of cameras
# it is not worth to customize them...
# ... right?
self.offsetXLabel = QLabel("Offset X (px)")
self.offsetXLabel.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.offsetXSpinBox = QSpinBox()
self.offsetXSpinBox.lineEdit().setAlignment(Qt.AlignmentFlag.AlignCenter)
self.offsetXSpinBox.setRange(0, self.sensorFullROI.width)
self.offsetXSpinBox.setSingleStep(self.sensorFullROI.ofs_x_step)
self.offsetXSpinBox.setValue(0)
self.offsetYLabel = QLabel("Offset Y (px)", )
self.offsetYLabel.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.offsetYSpinBox = QSpinBox()
self.offsetYSpinBox.lineEdit().setAlignment(Qt.AlignmentFlag.AlignCenter)
self.offsetYSpinBox.setRange(0, self.sensorFullROI.height)
self.offsetYSpinBox.setSingleStep(self.sensorFullROI.ofs_y_step)
self.offsetYSpinBox.setValue(0)
self.widthLabel = QLabel("Width (px)")
self.widthLabel.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.widthSpinBox = QSpinBox()
self.widthSpinBox.lineEdit().setAlignment(Qt.AlignmentFlag.AlignCenter)
self.widthSpinBox.setRange(0, self.sensorFullROI.width)
self.widthSpinBox.setSingleStep(self.sensorFullROI.width_step)
self.widthSpinBox.setValue(self.sensorFullROI.width)
self.heightLabel = QLabel("Height (px)")
self.heightLabel.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.heightSpinBox = QSpinBox()
self.heightSpinBox.lineEdit().setAlignment(Qt.AlignmentFlag.AlignCenter)
self.heightSpinBox.setRange(0, self.sensorFullROI.height)
self.heightSpinBox.setSingleStep(self.sensorFullROI.height_step)
self.heightSpinBox.setValue(self.sensorFullROI.height)
self.changeROIButton = QPushButton("Set ROI")
self.fullROIButton = QPushButton("Full frame")
self.layout = QGridLayout()
self.layout.addWidget(self.offsetXLabel, 0, 0)
self.layout.addWidget(self.offsetXSpinBox, 0, 1)
self.layout.addWidget(self.offsetYSpinBox, 0, 2)
self.layout.addWidget(self.offsetYLabel, 0, 3)
self.layout.addWidget(self.widthLabel, 1, 0)
self.layout.addWidget(self.widthSpinBox, 1, 1)
self.layout.addWidget(self.heightSpinBox, 1, 2)
self.layout.addWidget(self.heightLabel, 1, 3)
self.layout.addWidget(self.changeROIButton, 2, 0, 1, 2)
self.layout.addWidget(self.fullROIButton, 2, 2, 1, 2)
# "clicked" signals are connected to private slots.
# These slots expose the signals available to the user
# to process the new ROI information if necessary.
self.changeROIButton.clicked.connect(self._onROIChanged)
self.fullROIButton.clicked.connect(self._onFullROI)
self.group = QGroupBox()
self.group.setLayout(self.layout)
def changeWidgetSettings(self, settings : ROI):
"""ROI handling update widget settings method.
This method is useful whenever the ROI values are changed based
on some device requirements and adapted.
Args:
settings (ROI): new ROI settings to change the widget values and steps.
"""
self.offsetXSpinBox.setSingleStep(settings.ofs_x_step)
self.offsetXSpinBox.setValue(settings.offset_x)
self.offsetYSpinBox.setSingleStep(settings.ofs_y_step)
self.offsetYSpinBox.setValue(settings.offset_y)
self.widthSpinBox.setSingleStep(settings.width_step)
self.widthSpinBox.setValue(settings.width)
self.heightSpinBox.setSingleStep(settings.height_step)
self.heightSpinBox.setValue(settings.height)
def _onROIChanged(self) -> None:
"""Private slot for ROI changed button pressed. Exposes a signal with the updated ROI settings.
"""
# read the current SpinBoxes status
newRoi = ROI(
offset_x=self.offsetXSpinBox.value(),
ofs_x_step=self.offsetXSpinBox.singleStep(),
offset_y=self.offsetYSpinBox.value(),
ofs_y_step=self.offsetXSpinBox.singleStep(),
width=self.widthSpinBox.value(),
width_step=self.widthSpinBox.singleStep(),
height=self.heightSpinBox.value(),
height_step=self.heightSpinBox.singleStep()
)
self.changeROIRequested.emit(newRoi)
def _onFullROI(self) -> None:
"""Private slot for full ROI button pressed. Exposes a signal with the full ROI settings.
It also returns the widget settings to their original value.
"""
self.changeWidgetSettings(self.sensorFullROI)
self.fullROIRequested.emit(replace(self.sensorFullROI))
@property
def signals(self) -> dict[str, Signal]:
"""Returns a dictionary of signals available for the ROIHandling widget.
Exposed signals are:
- changeROIRequested,
- fullROIRequested,
Returns:
dict: dict of signals (key: function name, value: function objects).
"""
return {
"changeROIRequested" : self.changeROIRequested,
"fullROIRequested" : self.fullROIRequested,
}
```
|
{
"source": "jethrocarr/itsalarming",
"score": 2
}
|
#### File: jethrocarr/itsalarming/simulate.py
```python
import socket
import sys
import time
import datetime
import string
import re
import signal
import select
import threading
import yaml # requires pyyaml third party package
import beanstalkc # requires beanstalkc third party package
class HowAlarmingCLI:
def __init__(self):
# Load configuration from YAML file and assign configuration values.
try:
self.config = yaml.load(open('config.yaml', 'r'))
# Beanstalkd Message Queue settings
self.beanstalk_host = self.config['beanstalkd']['host']
self.beanstalk_port = int(self.config['beanstalkd']['port'])
self.beanstalk_tubes_commands = self.config['beanstalkd']['tubes']['commands']
self.beanstalk_tubes_events = self.config['beanstalkd']['tubes']['events']
except IOError:
print 'Fatal: Could not open configuration file'
raise
except (KeyError, AttributeError) as err:
print 'Fatal: Unable to find required configuration in config.yaml'
raise
def beanstalk_connect(self):
try:
self.beanstalk = beanstalkc.Connection(host=self.beanstalk_host, port=self.beanstalk_port)
print 'system: Beanstalkd connected on ' + str(self.beanstalk_host) + ' on port ' + str(self.beanstalk_port)
except socket.error, (value,message):
print "Fatal: Unable to connect to beanstalkd"
raise
def beanstalk_push(self, message):
# Send outputs to all defined event tubes (queues in beanstalk speak).
for tube in self.beanstalk_tubes_events:
self.beanstalk.use(tube)
self.beanstalk.put(message)
return
def keyboard_poll(self):
# Poll STDIN for a newline, when we get one, push to the beanstalkd
# command tube for processing.
i,o,e = select.select([sys.stdin],[],[],1)
for s in i:
if s == sys.stdin:
k = sys.stdin.readline()
k = k[:len(k)-1]
timestamp = str(int(time.time()))
if k == 'command':
self.beanstalk_push('{"type": "command", "code": "123", "message": "Arm alarm command issued", "raw": "123 command issued", "timestamp": "'+ timestamp +'"}')
elif k == 'info':
self.beanstalk_push('{"type": "info", "code": "236", "message": "Some kind of general information event occured", "raw": "236 INFO GENERAL", "timestamp": "'+ timestamp +'"}')
elif k == 'armed':
self.beanstalk_push('{"type": "armed", "code": "535", "message": "Alarm now armed", "raw": "535 ARMED", "timestamp": "'+ timestamp +'"}')
elif k == 'disarmed':
self.beanstalk_push('{"type": "disarmed", "code": "525", "message": "Alarm is disarmed", "raw": "525 disarmed", "timestamp": "'+ timestamp +'"}')
elif k == 'response':
self.beanstalk_push('{"type": "response", "code": "123", "message": "ACK of command", "raw": "123 response", "timestamp": "'+ timestamp +'"}')
elif k == 'alarm':
self.beanstalk_push('{"type": "alarm", "code": "911", "message": "Alarm triggered in sector 5", "raw": "911 ALARM ALARM", "timestamp": "'+ timestamp +'"}')
elif k == 'recovery':
self.beanstalk_push('{"type": "recovery", "code": "1332", "message": "Alarm recovered", "raw": "1332 recovery", "timestamp": "'+ timestamp +'"}')
elif k == 'fault':
self.beanstalk_push('{"type": "fault", "code": "666", "message": "Flux Capaciter Failed", "raw": "666 FLUXERR", "timestamp": "'+ timestamp +'"}')
elif k == 'unknown':
self.beanstalk_push('{"type": "unknown", "code": "???", "message": "unknown", "raw": "Unknown error, there\s no helping you now son", "timestamp": "'+ timestamp +'"}')
else:
print "Request a specific alarm event to simulate from: [command|info|armed|disarmed|response|alarm|recovery|fault|unknown]"
return
if __name__ == '__main__':
try:
c = HowAlarmingCLI()
c.beanstalk_connect()
print "system: what time of alarm event would you like to simulate?"
while(True):
c.keyboard_poll()
except KeyboardInterrupt:
print 'system: User Terminated'
except socket.error, err:
print 'system: socket error ' + str(err[0])
```
|
{
"source": "jethrodaniel/bluetooth",
"score": 3
}
|
#### File: bluetooth/blutooth/scan.py
```python
import time
import sys
import bluetooth.ble as ble
from blutooth.uuid_database import UuidDatabase
from blutooth.gatt import Device, Service, Characteristic
print("Scanning for BLE devices... (indefinately)")
service = ble.DiscoveryService() # DiscoveryService("hci0")
time_taken = 0
timeout = 5
devices = []
while len(devices) == 0:
try:
devices = service.discover(timeout)
except RuntimeError as e:
sys.exit(f"ERROR: {e}")
if len(devices) > 0:
pass
# import pdb; pdb.set_trace()
# devices = {k:v for (k,v) in devices.items() if v == 'SET-A15'}
time_taken += timeout
print(f"...found {len(devices)} device(s) ({time_taken} seconds)")
print("\n=== Devices ===")
for address, name in devices.items():
print(f"\n[device]: {address} ({name})")
for address, name in devices.items():
if name != 'SET-A15': continue # TODO: rm
req = ble.GATTRequester(address)
print(f"\n==> [device]: {address} ({name}) ===")
# We get a segmentation fault if we don't do this ?
req.read_by_uuid('2a24')
print(f"\nServices:")
for serv in req.discover_primary():
db = UuidDatabase()
name = db.uuid(serv['uuid'])['name']
value = db.uuid(serv['uuid'])['name']
uuid = serv['uuid'][4:8]
s = Service(uuid, name)
print(f"({uuid}) {name}, start: {serv['start']}, end: {serv['end']}")
print(f"\nCharacteristics:")
for char in req.discover_characteristics():
db = UuidDatabase()
name = db.uuid(char['uuid'])['name']
name = str.ljust(name, 42)
value = req.read_by_handle(char['value_handle'])[0]
properties = {
2: 'READ',
34: 'INDICATE, READ',
18: 'NOTIFY, READ',
10: 'READ, WRITE'
}
properties = properties[char['properties']]
uuid = char['uuid'][4:8]
print(
f"({uuid}) {name}: {value}, handle: {char['handle']}, properties: {properties}"
)
def set_volume(req, level):
val = int(level)
req.write_by_handle(0x0025, val.to_bytes(1, 'big'))
print("== Volume Level mapping ==")
print("\t1 = 10%")
print("\t9 = 20%")
print("\t17 = 30%")
print("\t25 = 40%")
print("\t33 = 50%")
print("\t41 = 60%")
print("\t57 = 70%")
while True:
res = input("Enter volume input: ")
if res == "q":
sys.exit(0)
print(f"=> {set_volume(req, res)}")
```
|
{
"source": "Jethrodeen/word2vec",
"score": 4
}
|
#### File: word2vec/src/docload.py
```python
import collections
import numpy as np
import pickle
import re
def load_books(filenames):
"""
Read files and count number of occurrences of each unique word in the
file. Also return the document as a list of words in the same order
as the original document.
Notes:
The following punctuation are treated as separate words: ;:-()&.,!?'"
All letters changed to lower-case
Contractions (e.g. don't, we'll) returned as-is (i.e. ' treated as
letter). This could cause problems for text that uses single
quotes (') for other purposes
:param filenames: list of filenames (including path, if needed)
:return: tuple:
0) collections.Counter() with unique word counts
1) list with document words in order
2) tuples: (number of lines read, number of words read)
"""
word_counter = collections.Counter()
word_list = []
num_lines, num_words = (0, 0)
for filename in filenames:
with open(filename, 'r') as f:
for line in f.readlines():
# TODO: check reg-exp below
words = re.findall("[\\w']+|[;:\-\(\)&.,!?\"]", line.lower().strip('\n'))
word_counter.update(words)
word_list.extend(words)
num_lines += 1
num_words += len(words)
return word_counter, word_list, num_lines, num_words
def build_dict(word_counter, vocab_size=50000):
"""
Builds dictionary and reverse dictionary of most common words in word_counter.
Number of words to include in the dictionary is set by dict_size.
:param word_counter: collections.Counter() with keys = word and values = number of
occurrences. Case sensitive.
:param vocab_size: Upper limit on vocabulary size. If number of unique words
greater than vocab_size, will take most commonly occurring words
:return: tuple:
0) dictionary of words to integers (most common word is 0, next most
common is 1, ...)
1) reverse dictionary of integers to words (same integer to word mapping as
"forward dictionary"
"""
top_words = word_counter.most_common(vocab_size)
top_words.sort(key=lambda t: -t[1])
dictionary = dict()
for idx, word in enumerate(map(lambda t: t[0], top_words)):
dictionary[word] = idx
return dictionary
def doc2num(word_list, dictionary):
"""
Maps list of words to np.array of integers using key/value pairs in
dictionary. Words not found in dictionary will be mapped to len(dictionary)
(i.e. 1 larger than biggest value in dictionary).
:param word_list: List of words
:param dictionary: Dictionary mapping words to integers
:return: return numpy array of type np.int32 corresponding to integer mapping
of words, with words not appearing in dictionary being mapped to
largest integer in dictionary (i.e. len(dictionary)-1)
"""
word_array = []
unknown_val = len(dictionary)
for word in word_list:
word_array.append(dictionary.get(word, unknown_val))
return np.array(word_array, dtype=np.int32)
def build_word_array(filenames, vocab_size):
"""
Convenience function that runs: 1) load_books(), 2) build_dict(),
and doc2num() in sequence and returns integer word array of documents,
a dictionary and basic document statistics.
:param filenames: list of file names (including path, if needed)
:param vocab_size: Upper limit on vocabulary size. If number of unique words
greater than vocab_size, will take most commonly occurring words
:param gutenberg: Set flag to True for .txt files from Project Gutenberg.
Loader will then skip Gutenberg preamble and license text at end of
file.
:return: 3-tuple:
0) numpy array of type np.int32 corresponding to integer mapping
of words in documents. Words not in dictionary are mapped to
largest integer in dictionary (i.e. len(dictionary)-1)
1) dictionary: word -> int dictionary
2) 2-tuple: (number of lines read, number of words read)
Note: no integration coverage
"""
word_counter, word_list, num_lines, num_words = load_books(filenames)
dictionary = build_dict(word_counter, vocab_size)
word_array = doc2num(word_list, dictionary)
num_unique_words = len(word_counter.keys())
return word_array, dictionary, num_lines, num_words, num_unique_words
def save_word_array(filename, word_array, dictionary,num_lines, num_words, num_unique_words):
"""
Save word array and dictionary for faster load.
:param filename: Filename, with path. Saved as python pickle file.
:param word_array: Numpy integer word array of document
:param dictionary: Word -> int document
:return: None
Note: no unit test coverage
"""
word_array_dict = dict()
word_array_dict['word_array'] = word_array
word_array_dict['dictionary'] = dictionary
word_array_dict['num_lines'] = num_lines
word_array_dict['num_words'] = num_words
word_array_dict['num_unique_words'] = num_unique_words
with open(filename + '.p', 'wb') as f:
pickle.dump(word_array_dict, f)
def load_word_array(filename):
"""
Load integer word array and dictionary saved by save_word_array()
:param filename: Same filename used with save_word_array()
:return: 2-tuple
0) Numpy word array of integers (document representation)
1) Word -> int dictionary
Note: no unit test coverage
"""
with open(filename + '.p', 'rb') as f:
word_array_dict = pickle.load(f)
return word_array_dict['word_array'], word_array_dict['dictionary'], word_array_dict['num_lines'], \
word_array_dict['num_words'], word_array_dict['num_unique_words']
```
|
{
"source": "jethrodew/PyReel",
"score": 3
}
|
#### File: jethrodew/PyReel/reelLib.py
```python
import time
import sys
import feedparser
import config
#Constants
logo_print_speed = 0.002
# Helper Functions
def delay(t):
time.sleep(t)
# Print Functions
def delay_print(s,t=0.03):
for c in s:
sys.stdout.write('%s' % c)
sys.stdout.flush()
time.sleep(t)
sys.stdout.write('\n')
def print_rss(post):
print('\n')
delay_print(post.title)
print('- '*20)
delay_print(post.summary)
def print_weather(obs,fore):
print('\n')
print('- '*20)
delay_print("Current Temperature ("+ config.region_name +")")
print('- '*10)
delay_print(obs.entries[0].title.replace('°',''))
print('\n')
print('- '*20)
delay_print("3 Day Forecast ("+ config.region_name +")")
print('- '*10)
for post in fore.entries:
delay_print (post.title.replace('°',''))
print('\n')
#Logo functions
def bbc_logo():
print("\n")
print("\n")
delay_print('88888888ba 88888888ba ,ad8888ba, ',logo_print_speed)
delay_print('88 "8b 88 "8b d8"\' `"8b',logo_print_speed)
delay_print('88 ,8P 88 ,8P d8\' ',logo_print_speed)
delay_print('88aaaaaa8P\' 88aaaaaa8P\' 88 ',logo_print_speed)
delay_print('88""""""8b, 88""""""8b, 88 ',logo_print_speed)
delay_print('88 `8b 88 `8b Y8, ',logo_print_speed)
delay_print('88 a8P 88 a8P Y8a. .a8P',logo_print_speed)
delay_print('88888888P" 88888888P" `"Y8888Y"\' ',logo_print_speed)
def bbc_news_logo():
print('\n')
print('\n')
delay_print('88888888ba 88888888ba ,ad8888ba, 888b 88 ',logo_print_speed)
delay_print('88 "8b 88 "8b d8"\' `"8b 8888b 88 ',logo_print_speed)
delay_print('88 ,8P 88 ,8P d8\' 88 `8b 88 ',logo_print_speed)
delay_print('88aaaaaa8P\' 88aaaaaa8P\' 88 88 `8b 88 ,adPPYba, 8b db d8 ,adPPYba, ',logo_print_speed)
delay_print('88""""""8b, 88""""""8b, 88 88 `8b 88 a8P_____88 `8b d88b d8\' I8[ "" ',logo_print_speed)
delay_print('88 `8b 88 `8b Y8, 88 `8b 88 8PP""""""" `8b d8\'`8b d8\' `"Y8ba, ',logo_print_speed)
delay_print('88 a8P 88 a8P Y8a. .a8P 88 `8888 "8b, ,aa `8bd8\' `8bd8\' aa ]8I ',logo_print_speed)
delay_print('88888888P" 88888888P" `"Y8888Y"\' 88 `888 `"Ybbd8"\' YP YP `"YbbdP"\' ',logo_print_speed)
def technology_logo():
print("\n")
delay_print('888888888888 88 88 ',logo_print_speed)
delay_print(' 88 88 88 ',logo_print_speed)
delay_print(' 88 88 88 ',logo_print_speed)
delay_print(' 88 ,adPPYba, ,adPPYba, 88,dPPYba, 8b,dPPYba, ,adPPYba, 88 ,adPPYba, ,adPPYb,d8 8b d8 ',logo_print_speed)
delay_print(' 88 a8P_____88 a8" "" 88P\' "8a 88P\' `"8a a8" "8a 88 a8" "8a a8" `Y88 `8b d8\' ',logo_print_speed)
delay_print(' 88 8PP""""""" 8b 88 88 88 88 8b d8 88 8b d8 8b 88 `8b d8\' ',logo_print_speed)
delay_print(' 88 "8b, ,aa "8a, ,aa 88 88 88 88 "8a, ,a8" 88 "8a, ,a8" "8a, ,d88 `8b,d8\' ',logo_print_speed)
delay_print(' 88 `"Ybbd8"\' `"Ybbd8"\' 88 88 88 88 `"YbbdP"\' 88 `"YbbdP"\' `"YbbdP"Y8 Y88\' ',logo_print_speed)
delay_print(' aa, ,88 d8\' ',logo_print_speed)
delay_print(' "Y8bbdP" d8\' ',logo_print_speed)
def weather_logo():
print('\n')
delay_print('I8, 8 ,8I 88 ',logo_print_speed)
delay_print('`8b d8b d8\' ,d 88 ',logo_print_speed)
delay_print(' "8, ,8"8, ,8" 88 88 ',logo_print_speed)
delay_print(' Y8 8P Y8 8P ,adPPYba, ,adPPYYba, MM88MMM 88,dPPYba, ,adPPYba, 8b,dPPYba, ',logo_print_speed)
delay_print(' `8b d8\' `8b d8\' a8P_____88 "" `Y8 88 88P\' "8a a8P_____88 88P\' "Y8 ',logo_print_speed)
delay_print(' `8a a8\' `8a a8\' 8PP""""""" ,adPPPPP88 88 88 88 8PP""""""" 88 ',logo_print_speed)
delay_print(' `8a8\' `8a8\' "8b, ,aa 88, ,88 88, 88 88 "8b, ,aa 88 ',logo_print_speed)
delay_print(' `8\' `8\' `"Ybbd8"\' `"8bbdP"Y8 "Y888 88 88 `"Ybbd8"\' 88 ',logo_print_speed)
# Run Functions
def bbc_news():
f = feedparser.parse('http://feeds.bbci.co.uk/news/rss.xml?edition='+config.news_region) #BBC News Frontpage
bbc_news_logo()
for post in f.entries[:10]:
print_rss(post)
delay(1)
delay(2)
print('\n')
def bbc_technology_news():
f = feedparser.parse('http://feeds.bbci.co.uk/news/technology/rss.xml?edition='+config.news_region) #BBC Technology News
bbc_logo()
technology_logo()
for post in f.entries[:10]:
print_rss(post)
delay(1)
delay(2)
print('\n')
def bbc_weather():
w = feedparser.parse('http://open.live.bbc.co.uk/weather/feeds/en/' + config.region_code + '/3dayforecast.rss') #BBC Weather 3 Day Forecast (Oxford)
o = feedparser.parse('http://open.live.bbc.co.uk/weather/feeds/en/' + config.region_code + '/observations.rss') #BBC Weather Observations (Oxford)
bbc_logo()
weather_logo()
print_weather(o,w)
delay(2)
print('\n')
```
|
{
"source": "jethroFloyd/naggin-naagin",
"score": 4
}
|
#### File: naggin-naagin/agents/q_learning.py
```python
import agent
class QLearning(agent.Agent):
"""
Implements the Q-Learning
"""
def UpdateQ(self, state, action, state_, action_, reward, explore):
if explore:
return
if not state:
return
q = self.Q[state][action]
if not state_:
q += self.alpha * (reward - q)
else:
q_ = max(self.Q[state_].values())
q += self.alpha * (reward + self.gamma * q_ - q)
self.Q[state][action] = q
```
#### File: jethroFloyd/naggin-naagin/interact.py
```python
class Interact:
def __init__(self):
pass
def PerformAndReturnNextMove(self, sl):
pass
```
#### File: naggin-naagin/snake_game/pygame_artist.py
```python
import artist
import os
import pygame
class PyGameArtist(artist.Artist):
def __init__(self, size, pixel_width=12):
self.size = size*pixel_width
pygame.display.set_caption("Snake")
self.screen = pygame.display.set_mode((self.size,
self.size))
self.font = pygame.font.Font(None, 32)
self.color_fruit = (255, 0, 0)
self.color_wall = (0, 0, 0)
self.color_snake = (0, 0, 255)
self.pixel_width = pixel_width
return
def __DrawRectangle(self, logical_position, color):
(lx, ly) = logical_position
self.screen.fill(color, (lx * self.pixel_width,
ly * self.pixel_width,
self.pixel_width,
self.pixel_width))
return
def Draw(self, sl):
if not sl.IsAlive():
gameovertext = self.font.render("GAME OVER!", 1, (0, 0, 0))
self.screen.blit(gameovertext,
((self.size - gameovertext.get_width())/2
,(self.size - gameovertext.get_height())/2))
else:
state = sl.state
self.screen.fill((255, 255, 255))
for fruit in state.fruits:
self.__DrawRectangle(fruit, self.color_fruit)
for wall in state.walls:
self.__DrawRectangle(wall, self.color_wall)
for s in state.snake_position:
self.__DrawRectangle(s, self.color_snake)
score = self.font.render("Score : %d"%sl.GetScore(), 1, (0, 0, 0))
self.screen.blit(score, (5, 5))
pygame.display.flip()
return
```
|
{
"source": "JethroLong/COMP90024-Proj2",
"score": 2
}
|
#### File: COMP90024-Proj2/analytics/create_views.py
```python
import couchdb
def create_view(url, db_name, view_name, mapFunc, reduceFunc=None, overwrite=False):
server = couchdb.Server(url=url)
db = server[db_name]
design_doc = db.get("_design/analyze")
view_path = "_design/analyze/_view/{}".format(view_name)
if design_doc is None:
new_design_doc = {"_id": "_design/analyze", "views": {view_name: {"map": mapFunc}}, "language": "javascript"}
db.save(new_design_doc)
return view_path
else:
if view_name in design_doc["views"]:
if overwrite:
design_doc["views"][view_name] = {"map": mapFunc}
db.save(design_doc)
return view_path
else:
return view_path
else:
design_doc["views"].update({view_name: {"map": mapFunc}})
db.save(design_doc)
return view_path
```
#### File: COMP90024-Proj2/web_flask/draw_map.py
```python
import json
import couchdb
import folium
import pandas as pd
from folium.plugins import MarkerCluster
class DrawMap:
def __init__(self):
couchdb_ip = self.read_ipAddr()
couchdb_port = str(5984)
self.url = "http://{}:{}".format(couchdb_ip, couchdb_port)
self.couch_server = couchdb.Server(url=self.url)
@staticmethod
def read_ipAddr():
with open("./hosts", mode='r') as f:
found = False
for line in f:
if found:
if line.endswith("\n"):
return line[:-1]
else:
return line
if line.find("[harvester]") >= 0:
found = True
return None
def retrieve_data(self, doc_id, db_name):
while True:
try:
db = self.couch_server[db_name]
data = db.get(doc_id)
if data is not None:
break
except Exception as e:
print('No processed data for {}, please wait...'.format(doc_id))
return data
# @staticmethod
# def set_color(sentiment):
# if sentiment >= 0.05:
# return 'green'
# elif -0.05 < sentiment < 0.05:
# return 'orange'
# elif sentiment <= -0.05:
# return 'red'
@staticmethod
def create_marker(cor, sentiment, text, pos_fg, neu_fg, neg_fg):
if sentiment >= 0.05:
marker = folium.Marker(location=cor[::-1], popup=(folium.Popup(text)),
icon=(folium.Icon(color='green')))
pos_fg.add_child(marker)
elif -0.05 < sentiment < 0.05:
marker = folium.Marker(location=cor[::-1], popup=(folium.Popup(text)),
icon=(folium.Icon(color='yellow')))
neu_fg.add_child(marker)
elif sentiment <= -0.05:
marker = folium.Marker(location=cor[::-1], popup=(folium.Popup(text)),
icon=(folium.Icon(color='red')))
neg_fg.add_child(marker)
return marker, pos_fg, neu_fg, neg_fg
def mapper(self, doc_id, db_name):
AUS_BOUND_BOX = (113.338953078, -43.6345972634, 153.569469029, -10.6681857235)
# centeroid = [(AUS_BOUND_BOX[1] + AUS_BOUND_BOX[3]) / 2, (AUS_BOUND_BOX[0] + AUS_BOUND_BOX[2]) / 2]
data = self.retrieve_data(doc_id, db_name)
df = pd.DataFrame(data['data'])
map = folium.Map(location=[-37.814, 144.96332], zoom_start=12, tiles='OpenStreetMap')
folium.TileLayer('Mapbox Control Room').add_to(map)
folium.TileLayer('Stamen Terrain').add_to(map)
folium.TileLayer('Stamen Toner').add_to(map)
folium.TileLayer('stamenwatercolor').add_to(map)
folium.TileLayer('cartodbpositron').add_to(map)
cluster = MarkerCluster(name='Cluster')
fg = folium.FeatureGroup(name='Sentiment Distribution')
pos_fg = folium.FeatureGroup(name='Positive')
neu_fg = folium.FeatureGroup(name='Neutral')
neg_fg = folium.FeatureGroup(name='Negative')
for index, row in df.iterrows():
cor = row['coordinates']
if AUS_BOUND_BOX[0] <= cor[0] <= AUS_BOUND_BOX[2] and AUS_BOUND_BOX[1] <= cor[1] <= AUS_BOUND_BOX[3]:
marker, pos_fg, neu_fg, neg_fg = self.create_marker(cor, row['sentiment'], row['text'],
pos_fg, neu_fg, neg_fg)
cluster.add_child(marker)
fg.add_child(cluster)
fg.add_child(pos_fg)
fg.add_child(neu_fg)
fg.add_child(neg_fg)
map.add_child(fg)
# map.add_child(pos_fg)
# map.add_child(neu_fg)
# map.add_child(neg_fg)
# folium.LayerControl().add_to(fg)
folium.LayerControl().add_to(map)
return map
```
|
{
"source": "jethro-swan/om-client-library",
"score": 2
}
|
#### File: swagger_client/api/auth_api.py
```python
from __future__ import absolute_import
import re # noqa: F401
# python 2 and python 3 compatibility library
import six
from swagger_client.api_client import ApiClient
class AuthApi(object):
"""NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
Ref: https://github.com/swagger-api/swagger-codegen
"""
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def account_get(self, stewardname, **kwargs): # noqa: E501
"""Get Steward account information # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.account_get(stewardname, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:return: str
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.account_get_with_http_info(stewardname, **kwargs) # noqa: E501
else:
(data) = self.account_get_with_http_info(stewardname, **kwargs) # noqa: E501
return data
def account_get_with_http_info(self, stewardname, **kwargs): # noqa: E501
"""Get Steward account information # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.account_get_with_http_info(stewardname, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:return: str
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['stewardname'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method account_get" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'stewardname' is set
if ('stewardname' not in params or
params['stewardname'] is None):
raise ValueError("Missing the required parameter `stewardname` when calling `account_get`") # noqa: E501
if ('stewardname' in params and
len(params['stewardname']) > 255):
raise ValueError("Invalid value for parameter `stewardname` when calling `account_get`, length must be less than or equal to `255`") # noqa: E501
if 'stewardname' in params and not re.search(r'^[A-Za-z0-9_.-]+$', params['stewardname']): # noqa: E501
raise ValueError("Invalid value for parameter `stewardname` when calling `account_get`, must conform to the pattern `/^[A-Za-z0-9_.-]+$/`") # noqa: E501
collection_formats = {}
path_params = {}
if 'stewardname' in params:
path_params['stewardname'] = params['stewardname'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['text/html']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/stewards/{stewardname}/account', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='str', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def login_get(self, stewardname, **kwargs): # noqa: E501
"""Login Page for the steward # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.login_get(stewardname, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:return: str
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.login_get_with_http_info(stewardname, **kwargs) # noqa: E501
else:
(data) = self.login_get_with_http_info(stewardname, **kwargs) # noqa: E501
return data
def login_get_with_http_info(self, stewardname, **kwargs): # noqa: E501
"""Login Page for the steward # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.login_get_with_http_info(stewardname, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:return: str
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['stewardname'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method login_get" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'stewardname' is set
if ('stewardname' not in params or
params['stewardname'] is None):
raise ValueError("Missing the required parameter `stewardname` when calling `login_get`") # noqa: E501
if ('stewardname' in params and
len(params['stewardname']) > 255):
raise ValueError("Invalid value for parameter `stewardname` when calling `login_get`, length must be less than or equal to `255`") # noqa: E501
if 'stewardname' in params and not re.search(r'^[A-Za-z0-9_.-]+$', params['stewardname']): # noqa: E501
raise ValueError("Invalid value for parameter `stewardname` when calling `login_get`, must conform to the pattern `/^[A-Za-z0-9_.-]+$/`") # noqa: E501
collection_formats = {}
path_params = {}
if 'stewardname' in params:
path_params['stewardname'] = params['stewardname'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['text/plain']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/stewards/{stewardname}/login', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='str', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def login_post(self, stewardname, **kwargs): # noqa: E501
"""Login steward # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.login_post(stewardname, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:param str authorization:
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.login_post_with_http_info(stewardname, **kwargs) # noqa: E501
else:
(data) = self.login_post_with_http_info(stewardname, **kwargs) # noqa: E501
return data
def login_post_with_http_info(self, stewardname, **kwargs): # noqa: E501
"""Login steward # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.login_post_with_http_info(stewardname, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:param str authorization:
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['stewardname', 'authorization'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method login_post" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'stewardname' is set
if ('stewardname' not in params or
params['stewardname'] is None):
raise ValueError("Missing the required parameter `stewardname` when calling `login_post`") # noqa: E501
if ('stewardname' in params and
len(params['stewardname']) > 255):
raise ValueError("Invalid value for parameter `stewardname` when calling `login_post`, length must be less than or equal to `255`") # noqa: E501
if 'stewardname' in params and not re.search(r'^[A-Za-z0-9_.-]+$', params['stewardname']): # noqa: E501
raise ValueError("Invalid value for parameter `stewardname` when calling `login_post`, must conform to the pattern `/^[A-Za-z0-9_.-]+$/`") # noqa: E501
if 'authorization' in params and not re.search(r'^Basic [A-Za-z0-9\/+=.]+$', params['authorization']): # noqa: E501
raise ValueError("Invalid value for parameter `authorization` when calling `login_post`, must conform to the pattern `/^Basic [A-Za-z0-9\/+=.]+$/`") # noqa: E501
collection_formats = {}
path_params = {}
if 'stewardname' in params:
path_params['stewardname'] = params['stewardname'] # noqa: E501
query_params = []
header_params = {}
if 'authorization' in params:
header_params['Authorization'] = params['authorization'] # noqa: E501
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['text/plain']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/x-www-form-urlencoded']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/stewards/{stewardname}/login', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def logout_post(self, stewardname, **kwargs): # noqa: E501
"""Logout steward # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.logout_post(stewardname, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.logout_post_with_http_info(stewardname, **kwargs) # noqa: E501
else:
(data) = self.logout_post_with_http_info(stewardname, **kwargs) # noqa: E501
return data
def logout_post_with_http_info(self, stewardname, **kwargs): # noqa: E501
"""Logout steward # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.logout_post_with_http_info(stewardname, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['stewardname'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method logout_post" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'stewardname' is set
if ('stewardname' not in params or
params['stewardname'] is None):
raise ValueError("Missing the required parameter `stewardname` when calling `logout_post`") # noqa: E501
if ('stewardname' in params and
len(params['stewardname']) > 255):
raise ValueError("Invalid value for parameter `stewardname` when calling `logout_post`, length must be less than or equal to `255`") # noqa: E501
if 'stewardname' in params and not re.search(r'^[A-Za-z0-9_.-]+$', params['stewardname']): # noqa: E501
raise ValueError("Invalid value for parameter `stewardname` when calling `logout_post`, must conform to the pattern `/^[A-Za-z0-9_.-]+$/`") # noqa: E501
collection_formats = {}
path_params = {}
if 'stewardname' in params:
path_params['stewardname'] = params['stewardname'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json', 'text/html']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/stewards/{stewardname}/logout', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def oauth_access_token_post(self, stewardname, access_token_request, **kwargs): # noqa: E501
"""Exchanges the user or client credentials for an access token used to access resources. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.oauth_access_token_post(stewardname, access_token_request, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:param AccessTokenRequest access_token_request: Access Token Request Object (required)
:param str authorization:
:return: TokenResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.oauth_access_token_post_with_http_info(stewardname, access_token_request, **kwargs) # noqa: E501
else:
(data) = self.oauth_access_token_post_with_http_info(stewardname, access_token_request, **kwargs) # noqa: E501
return data
def oauth_access_token_post_with_http_info(self, stewardname, access_token_request, **kwargs): # noqa: E501
"""Exchanges the user or client credentials for an access token used to access resources. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.oauth_access_token_post_with_http_info(stewardname, access_token_request, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:param AccessTokenRequest access_token_request: Access Token Request Object (required)
:param str authorization:
:return: TokenResponse
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['stewardname', 'access_token_request', 'authorization'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method oauth_access_token_post" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'stewardname' is set
if ('stewardname' not in params or
params['stewardname'] is None):
raise ValueError("Missing the required parameter `stewardname` when calling `oauth_access_token_post`") # noqa: E501
# verify the required parameter 'access_token_request' is set
if ('access_token_request' not in params or
params['access_token_request'] is None):
raise ValueError("Missing the required parameter `access_token_request` when calling `oauth_access_token_post`") # noqa: E501
if ('stewardname' in params and
len(params['stewardname']) > 255):
raise ValueError("Invalid value for parameter `stewardname` when calling `oauth_access_token_post`, length must be less than or equal to `255`") # noqa: E501
if 'stewardname' in params and not re.search(r'^[A-Za-z0-9_.-]+$', params['stewardname']): # noqa: E501
raise ValueError("Invalid value for parameter `stewardname` when calling `oauth_access_token_post`, must conform to the pattern `/^[A-Za-z0-9_.-]+$/`") # noqa: E501
if 'authorization' in params and not re.search(r'^Bearer|Basic [A-Za-z0-9\/+=.]+$', params['authorization']): # noqa: E501
raise ValueError("Invalid value for parameter `authorization` when calling `oauth_access_token_post`, must conform to the pattern `/^Bearer|Basic [A-Za-z0-9\/+=.]+$/`") # noqa: E501
collection_formats = {}
path_params = {}
if 'stewardname' in params:
path_params['stewardname'] = params['stewardname'] # noqa: E501
query_params = []
header_params = {}
if 'authorization' in params:
header_params['Authorization'] = params['authorization'] # noqa: E501
form_params = []
local_var_files = {}
body_params = None
if 'access_token_request' in params:
body_params = params['access_token_request']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json', 'text/html']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['basicAuthenticationSecurity', 'oauth2Refresh'] # noqa: E501
return self.api_client.call_api(
'/stewards/{stewardname}/oauth/token', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TokenResponse', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def oauth_application_post(self, stewardname, application, **kwargs): # noqa: E501
"""Create an application for a client_id and client_secret for oauth token authorization. # noqa: E501
Existing steward Registers an application with the openmoney network. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.oauth_application_post(stewardname, application, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:param ApplicationRequest application: Application Object (required)
:param str authorization:
:return: ApplicationResponse
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.oauth_application_post_with_http_info(stewardname, application, **kwargs) # noqa: E501
else:
(data) = self.oauth_application_post_with_http_info(stewardname, application, **kwargs) # noqa: E501
return data
def oauth_application_post_with_http_info(self, stewardname, application, **kwargs): # noqa: E501
"""Create an application for a client_id and client_secret for oauth token authorization. # noqa: E501
Existing steward Registers an application with the openmoney network. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.oauth_application_post_with_http_info(stewardname, application, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:param ApplicationRequest application: Application Object (required)
:param str authorization:
:return: ApplicationResponse
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['stewardname', 'application', 'authorization'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method oauth_application_post" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'stewardname' is set
if ('stewardname' not in params or
params['stewardname'] is None):
raise ValueError("Missing the required parameter `stewardname` when calling `oauth_application_post`") # noqa: E501
# verify the required parameter 'application' is set
if ('application' not in params or
params['application'] is None):
raise ValueError("Missing the required parameter `application` when calling `oauth_application_post`") # noqa: E501
if ('stewardname' in params and
len(params['stewardname']) > 255):
raise ValueError("Invalid value for parameter `stewardname` when calling `oauth_application_post`, length must be less than or equal to `255`") # noqa: E501
if 'stewardname' in params and not re.search(r'^[A-Za-z0-9_.-]+$', params['stewardname']): # noqa: E501
raise ValueError("Invalid value for parameter `stewardname` when calling `oauth_application_post`, must conform to the pattern `/^[A-Za-z0-9_.-]+$/`") # noqa: E501
if 'authorization' in params and not re.search(r'^Basic [A-Za-z0-9\/+=.]+$', params['authorization']): # noqa: E501
raise ValueError("Invalid value for parameter `authorization` when calling `oauth_application_post`, must conform to the pattern `/^Basic [A-Za-z0-9\/+=.]+$/`") # noqa: E501
collection_formats = {}
path_params = {}
if 'stewardname' in params:
path_params['stewardname'] = params['stewardname'] # noqa: E501
query_params = []
header_params = {}
if 'authorization' in params:
header_params['Authorization'] = params['authorization'] # noqa: E501
form_params = []
local_var_files = {}
body_params = None
if 'application' in params:
body_params = params['application']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['basicAuthenticationSecurity'] # noqa: E501
return self.api_client.call_api(
'/stewards/{stewardname}/oauth/application', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ApplicationResponse', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def oauth_dialoge_get(self, stewardname, client_id, **kwargs): # noqa: E501
"""Implicit authorization dialog presented to steward to authorize client_id to access API resources on their behalf. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.oauth_dialoge_get(stewardname, client_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:param str client_id: Client ID received during registration (required)
:param str redirect_uri: A uri to redirect steward after authorization
:param list[str] scopes: A comma separated list of scopes. If not provided, scope defaults to an empty list of scopes for stewards that don’t have a valid token for the app. For stewards who do already have a valid token for the app, the steward won’t be shown the OAuth authorization page with the list of scopes. Instead, this step of the flow will automatically complete with the same scopes that were used last time the steward completed the flow.
:return: ErrorModel
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.oauth_dialoge_get_with_http_info(stewardname, client_id, **kwargs) # noqa: E501
else:
(data) = self.oauth_dialoge_get_with_http_info(stewardname, client_id, **kwargs) # noqa: E501
return data
def oauth_dialoge_get_with_http_info(self, stewardname, client_id, **kwargs): # noqa: E501
"""Implicit authorization dialog presented to steward to authorize client_id to access API resources on their behalf. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.oauth_dialoge_get_with_http_info(stewardname, client_id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:param str client_id: Client ID received during registration (required)
:param str redirect_uri: A uri to redirect steward after authorization
:param list[str] scopes: A comma separated list of scopes. If not provided, scope defaults to an empty list of scopes for stewards that don’t have a valid token for the app. For stewards who do already have a valid token for the app, the steward won’t be shown the OAuth authorization page with the list of scopes. Instead, this step of the flow will automatically complete with the same scopes that were used last time the steward completed the flow.
:return: ErrorModel
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['stewardname', 'client_id', 'redirect_uri', 'scopes'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method oauth_dialoge_get" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'stewardname' is set
if ('stewardname' not in params or
params['stewardname'] is None):
raise ValueError("Missing the required parameter `stewardname` when calling `oauth_dialoge_get`") # noqa: E501
# verify the required parameter 'client_id' is set
if ('client_id' not in params or
params['client_id'] is None):
raise ValueError("Missing the required parameter `client_id` when calling `oauth_dialoge_get`") # noqa: E501
if ('stewardname' in params and
len(params['stewardname']) > 255):
raise ValueError("Invalid value for parameter `stewardname` when calling `oauth_dialoge_get`, length must be less than or equal to `255`") # noqa: E501
if 'stewardname' in params and not re.search(r'^[A-Za-z0-9_.-]+$', params['stewardname']): # noqa: E501
raise ValueError("Invalid value for parameter `stewardname` when calling `oauth_dialoge_get`, must conform to the pattern `/^[A-Za-z0-9_.-]+$/`") # noqa: E501
if ('client_id' in params and
len(params['client_id']) > 800):
raise ValueError("Invalid value for parameter `client_id` when calling `oauth_dialoge_get`, length must be less than or equal to `800`") # noqa: E501
if ('client_id' in params and
len(params['client_id']) < 5):
raise ValueError("Invalid value for parameter `client_id` when calling `oauth_dialoge_get`, length must be greater than or equal to `5`") # noqa: E501
if 'client_id' in params and not re.search(r'^[A-Za-z0-9\\\\\\s\/=+-]+$', params['client_id']): # noqa: E501
raise ValueError("Invalid value for parameter `client_id` when calling `oauth_dialoge_get`, must conform to the pattern `/^[A-Za-z0-9\\\\\\s\/=+-]+$/`") # noqa: E501
if ('redirect_uri' in params and
len(params['redirect_uri']) > 512):
raise ValueError("Invalid value for parameter `redirect_uri` when calling `oauth_dialoge_get`, length must be less than or equal to `512`") # noqa: E501
collection_formats = {}
path_params = {}
if 'stewardname' in params:
path_params['stewardname'] = params['stewardname'] # noqa: E501
query_params = []
if 'client_id' in params:
query_params.append(('client_id', params['client_id'])) # noqa: E501
if 'redirect_uri' in params:
query_params.append(('redirect_uri', params['redirect_uri'])) # noqa: E501
if 'scopes' in params:
query_params.append(('scopes', params['scopes'])) # noqa: E501
collection_formats['scopes'] = 'multi' # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['text/html']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/stewards/{stewardname}/dialog/authorize', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ErrorModel', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def oauth_dialoge_post(self, stewardname, oauth_authorize_request, **kwargs): # noqa: E501
"""Authorizes a steward on the openmoney network # noqa: E501
Authorization dialoge decision with allowed scopes. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.oauth_dialoge_post(stewardname, oauth_authorize_request, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:param OauthAuthorizeRequest oauth_authorize_request: (required)
:return: ErrorModel
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.oauth_dialoge_post_with_http_info(stewardname, oauth_authorize_request, **kwargs) # noqa: E501
else:
(data) = self.oauth_dialoge_post_with_http_info(stewardname, oauth_authorize_request, **kwargs) # noqa: E501
return data
def oauth_dialoge_post_with_http_info(self, stewardname, oauth_authorize_request, **kwargs): # noqa: E501
"""Authorizes a steward on the openmoney network # noqa: E501
Authorization dialoge decision with allowed scopes. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.oauth_dialoge_post_with_http_info(stewardname, oauth_authorize_request, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str stewardname: (required)
:param OauthAuthorizeRequest oauth_authorize_request: (required)
:return: ErrorModel
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['stewardname', 'oauth_authorize_request'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method oauth_dialoge_post" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'stewardname' is set
if ('stewardname' not in params or
params['stewardname'] is None):
raise ValueError("Missing the required parameter `stewardname` when calling `oauth_dialoge_post`") # noqa: E501
# verify the required parameter 'oauth_authorize_request' is set
if ('oauth_authorize_request' not in params or
params['oauth_authorize_request'] is None):
raise ValueError("Missing the required parameter `oauth_authorize_request` when calling `oauth_dialoge_post`") # noqa: E501
if ('stewardname' in params and
len(params['stewardname']) > 255):
raise ValueError("Invalid value for parameter `stewardname` when calling `oauth_dialoge_post`, length must be less than or equal to `255`") # noqa: E501
if 'stewardname' in params and not re.search(r'^[A-Za-z0-9_.-]+$', params['stewardname']): # noqa: E501
raise ValueError("Invalid value for parameter `stewardname` when calling `oauth_dialoge_post`, must conform to the pattern `/^[A-Za-z0-9_.-]+$/`") # noqa: E501
collection_formats = {}
path_params = {}
if 'stewardname' in params:
path_params['stewardname'] = params['stewardname'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'oauth_authorize_request' in params:
body_params = params['oauth_authorize_request']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/stewards/{stewardname}/dialog/authorize/decision', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ErrorModel', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
```
|
{
"source": "jeti182/tvatoj-power",
"score": 3
}
|
#### File: jeti182/tvatoj-power/example_power_one_condition.py
```python
from tvatojpower import hierarchical_model_noncentered, sim_and_fit
'''
This is an example of a power estimation for a TOJ experiment with a single condition.
That is, there is an attention manipulation that is expected to produce a benefit for
the probe stimulus (the one which comes first at negative SOAs). For instance, the
probe could be more salient. There are no "neutral" trials in this example.
'''
# Step 1: Define your hypothetical design:
design = {
'num_participants' : 25, # Specify the number of participants
'SOAs' : [-100.0, -80.0, -60.0, # Specify the intended SOAs in ms
-40.0, -20.0, 0.0, 20.0,
40.0, 60.0, 80.0, 100.0],
'repetitions' : [24, 24, 32, 32, 48, # Specify the repetitions of each SOA
48, 48, 32, 32, 24, 24], # (length must match SOAs)
'C_mu' : 0.070, # Group mean of the simulated Cs in 1/ms
'C_sd_between' : 0.020, # Standard deviation of simulated Cs
'wp_mu' : 0.55, # Group mean of the simulated wps
'wp_sd_between' : 0.02, # Standard deviation of similated wps
'num_simulation' : 200, # Number of simulations to perform
}
# Step 2: Define your research goals. (When was the experiment succesful?)
def check_rates(summary_stats):
success = summary_stats['hdi_2.5%']['wp_mu[0]'] > 0.5 # All we care about in this example is that
# that we see an attention effect in the probe weight,
# meaning that it is larger than .5 (neutral weight)
# Note that despite having only one condition we have
# to use the index [0] here.
return success
# Step 3: Start the simulations and power estimation
sim_and_fit(setup=design, # The deisgn specified above
model_func=hierarchical_model_noncentered, # A function that returns a pymc3 model (currently only this one)
single_C=True,
single_wp=True,
iterations=200, # How many simulated experiments do we want?
condition_func=check_rates, # A function that checks our goals (defined above)
goal_var_names=['C_mu', 'wp_mu'], # Limit summary stats to the variables used
# to the printed after each iteration
outfile='single_condition.csv' # A file where the log (==final result) will be stored
)
```
#### File: tvatoj-power/tvatojpower/tvatojpower.py
```python
from numpy import random, exp, array, zeros, log, clip
from theano.tensor import mean, cast
from theano.tensor import exp as ttexp
from math import floor
from numpy.random import random as runif
from tqdm import tqdm
import pymc3
import pandas as pd
from scipy.optimize import fmin
from scipy.stats import *
from tqdm import tqdm
from scipy.stats import beta
import sys, logging
import warnings
logger = logging.getLogger(__name__)
try:
import coloredlogs
coloredlogs.install(level='DEBUG')
except ImportError:
logging.info('If you like the terminal output colored.' +
'Install colored coloredlogs (e.g., pip install coloredlogs)')
# The TVAOJ psychometric function, see Tünnermann, Petersen, & Scharlau (2015):
def tvatoj_psychometric_function(SOA, C, wp, vp=None, vr=None):
""" Takes SOAs in ms and either C in 1/ms and w or vp and vr in 1/ms """
if vp is None or vr is None:
vp = C * wp
vr = C * (1 - wp)
SOA = array(SOA)
left = (1-exp(-vp*abs(SOA))) + exp(-vp*abs(SOA)) * vp/(vp+vr)
right = exp(-vr*abs(SOA))*vp/(vp+vr)
return ((SOA<=0)*left + (SOA>0)*right)
# A generative simulation of the process
def simulate_subject_toj(SOA, reps, C, wp):
v1 = C * wp # attentional weights and overall rate C ...
v2 = C * (1 -wp) # ... determine the individual rates
probe_first_count = 0 # Our counter each SOA starts with zero
for i in range(0, reps): # For every repetition
tS = -log(1 - runif(1)) / v2 # let stimulus 2 race and record its VSTM arrival
tC = SOA - log(1 - runif(1)) / v1 # sane for stimulus 1, offset by the SOA
if tC < tS: # Did 1 arrive before 2?
probe_first_count += 1 # Count as a "probe first judment"
return probe_first_count # Return the result across all SOAs
# Simulate TOJs for a group of participants, by drawing
# their individual parameters from distributions
def simulate_tojs(simulation_setup):
s = simulation_setup # For convenient access ...
single_wp=False
# Get the paras per individual
if 'C_sd_within' in s: # within subject design
logging.info('[SIM] Simulating two different (but correlated) C parameters.')
C_sub_mu = clip(random.normal(s['C_mu'], s['C_sd_between'], size=s['num_participants']), 0, None)
C_a_sub = clip(random.normal(C_sub_mu, s['C_sd_within'], size=s['num_participants']), 0, None)
C_n_sub = clip(random.normal(C_sub_mu, s['C_sd_within'], size=s['num_participants']), 0,None)
wp_a_sub = clip(random.normal(s['wp_a_mu'], s['wp_a_sd_between'], size=s['num_participants']), 0, None)
wp_n_sub = clip(random.normal(s['wp_n_mu'], s['wp_n_sd_between'], size=s['num_participants']), 0, None)
elif 'C_a_mu' in s: # between design
logging.info('[SIM] Simulating two independent C parameters.')
C_a_sub = clip(random.normal(s['C_a_mu'], s['C_a_sd_between'], size=s['num_participants']), 0, None)
C_n_sub = clip(random.normal(s['C_n_mu'], s['C_n_sd_between'], size=s['num_participants']), 0,None)
wp_a_sub = clip(random.normal(s['wp_a_mu'], s['wp_a_sd_between'], size=s['num_participants']), 0, None)
wp_n_sub = clip(random.normal(s['wp_n_mu'], s['wp_n_sd_between'], size=s['num_participants']), 0, None)
elif 'C_single_mu' in s:
logging.info('[SIM] Simulating a single C parameter for both conditions.')
C_a_sub = clip(random.normal(s['C_single_mu'], s['C_single_sd_between'], size=s['num_participants']), 0, None)
C_n_sub = C_a_sub
wp_a_sub = clip(random.normal(s['wp_a_mu'], s['wp_a_sd_between'], size=s['num_participants']), 0, None)
wp_n_sub = clip(random.normal(s['wp_n_mu'], s['wp_n_sd_between'], size=s['num_participants']), 0, None)
elif 'wp_mu' in s: # A single wp ==> Single condition experient
logging.info('[SIM] Simulating a single condition.')
C_sub = clip(random.normal(s['C_mu'], s['C_sd_between'], size=s['num_participants']), 0, None)
wp_sub = clip(random.normal(s['wp_mu'], s['wp_sd_between'], size=s['num_participants']), 0, None)
single_wp=True
else:
logger.error('Could not infer the design from the simulation parameters provided. Please refer to the exmaples')
sys.exit('Aborting')
# Get the TOJs
participant_id = []
condition_id = []
probe_first_count = []
repetitions = []
SOA = []
if single_wp:
condition_nums = [0]
else:
condition_nums = [0, 1]
for p in range(0, s['num_participants']):
for i,soa in enumerate(s['SOAs']):
for c in condition_nums:
participant_id.append(p)
condition_id.append(c)
SOA.append(soa)
repetitions.append(s['repetitions'][i])
if c == 0 and not single_wp: # simulate a neutral condition TOJ
probe_first_count.append(simulate_subject_toj(soa, s['repetitions'][i], C_n_sub[p], wp_n_sub[p]))
if c == 1 and not single_wp: # simulate an attention condition TOJ
probe_first_count.append(simulate_subject_toj(soa, s['repetitions'][i], C_a_sub[p], wp_a_sub[p]))
if c == 0 and single_wp:
probe_first_count.append(simulate_subject_toj(soa, s['repetitions'][i], C_sub[p], wp_sub[p]))
df = pd.DataFrame()
df['participant_id'] = participant_id
df['condition_id'] = condition_id
df['SOA'] = SOA
df['repetitions'] = repetitions
df['probe_first_count'] = probe_first_count
return df
# Using the non-centered reparamtrization to reduce divergenses
# See here for the rationale: https://twiecki.io/blog/2017/02/08/bayesian-hierchical-non-centered/
def hierarchical_model_noncentered(data, single_C=False, single_wp=False):
'''Sets up a pymc3 model based on TVATOJ.
:param data: A TOJ dataframe as return by the simulations
:param single_C: Whether to use single C (for both conditions)
:param single_wp: Whether to use a single wp (implies single C and produces a model for a single condition only)
:returns: Model
:rtype: pymc3.Model
'''
model = pymc3.Model()
with model:
p_id = data['participant_id']
c_id = data['condition_id']
if single_wp:
wp_c_id = len(data['condition_id']) * [0]
single_C = True
else:
wp_c_id = c_id
if single_C:
C_c_id = len(data['condition_id']) * [0]
else:
C_c_id = c_id
pfc = pymc3.Data('probe_first_count',data['probe_first_count'])
C_mu = pymc3.Normal('C_mu', 0.080, 0.050, shape=len(set(C_c_id)))
C_sd = pymc3.HalfCauchy('C_sd', 0.1, shape=len(set(C_c_id)))
wp_mu = pymc3.Normal('wp_mu', 0.5,0.2, shape=len(set(wp_c_id)))
wp_sd = pymc3.HalfCauchy('wp_sd', 0.2, shape=len(set(wp_c_id)))
wp_e = pymc3.Normal('wp_e', 0,1, shape=(len(set(p_id)), len(set(wp_c_id))))
C_e = pymc3.Normal('C_e', 0,1, shape=(len(set(p_id)), len(set(C_c_id))))
C = pymc3.Deterministic('C', (C_mu + C_e * C_sd).clip(0.0001, 0.9999))
wp = pymc3.Deterministic('wp', (wp_mu + wp_e * wp_sd).clip(0.0001, 0.9999))
theta = pymc3.Deterministic('theta', tvatoj_psychometric_function(
data['SOA'], C[(p_id, C_c_id)], wp[(p_id, wp_c_id)]))
y = pymc3.Binomial('y', n=cast(data['repetitions'], 'int64'),
p=theta, observed=pfc,
dtype='int64')
# The deterministic transformation could probably be externalized
# However, here the calculation is most safe to produce prober within subject estimates
vp = pymc3.Deterministic('vp', wp * C)
vr = pymc3.Deterministic('vr', (1 - wp) * C)
vp_mean = pymc3.Deterministic('vp_mean', mean(vp, axis=0))
vr_mean = pymc3.Deterministic('vr_mean', mean(vr, axis=0))
if not single_wp:
va_diff_mean = pymc3.Deterministic('va_diff_mean', mean(vp[:,1] - vr[:,1])) # Diff of probe and ref rate in the attention cond
vp_diff_mean = pymc3.Deterministic('vp_diff_mean', mean(vp[:,1] - vp[:,0])) # Diff of attention and neutral condition probe rates
vr_diff_mean = pymc3.Deterministic('vr_diff_mean', mean(vr[:,1] - vr[:,0])) # Diff of attention and neutral condition probe rates
wpa_mean = pymc3.Deterministic('wpa_mean', mean(wp[:,1]))
wp_diff_mean = pymc3.Deterministic('wp_diff_mean', mean(wp[:,1] - wp[:,0]))
else:
wp_vs_point5_mean = pymc3.Deterministic('wp_mean', mean(wp))
return(model)
# This function is borrowed from @aloctavodia, who ported it from <NAME>'s scripts
# https://github.com/aloctavodia/Doing_bayesian_data_analysis/blob/master/HDIofICDF.py
def HDIofICDF(dist_name, credMass=0.95, **args):
# freeze distribution with given arguments
distri = dist_name(**args)
# initial guess for HDIlowTailPr
incredMass = 1.0 - credMass
def intervalWidth(lowTailPr):
return distri.ppf(credMass + lowTailPr) - distri.ppf(lowTailPr)
# find lowTailPr that minimizes intervalWidth
HDIlowTailPr = fmin(intervalWidth, incredMass, ftol=1e-8, disp=False)[0]
# return interval as array([low, high])
return distri.ppf([HDIlowTailPr, credMass + HDIlowTailPr])
def sim_and_fit(setup, model_func, iterations, condition_func,
goal_var_names=None, log_var_names=['C_mu', 'wp_mu'],
single_C=False, single_wp=False, outfile='out.csv',
turn_off_warnings=True,
tune=1000,
target_accept=0.85,
init='adapt_diag'):
if (turn_off_warnings):
warnings.filterwarnings("ignore")
logging.warning('Attention: Warnings turned off. ') # There is so much from pymc3 and theano ..
if log_var_names==None or len(log_var_names) < 1:
sys.exit('log_var_names should not be empty or None! Log at least one variable!')
num_success=0
model = None
for i in tqdm(range(iterations), desc='Overall progress'):
data = simulate_tojs(setup)
if model is None:
model = model_func(data, single_C=single_C, single_wp=single_wp)
with model:
pymc3.set_data({'probe_first_count': data['probe_first_count']})
trace = pymc3.sample(2000, tune=tune, cores=4, init=init, target_accept=target_accept)
summary_stats = pymc3.summary(trace, var_names=goal_var_names, hdi_prob=0.95)
print(summary_stats)
success = condition_func(summary_stats) * 1 # Either 0 or 1, depending on reaching our goals.
num_success += success
attempts = (i+1)
success_rate = num_success / attempts
hdi = HDIofICDF(beta,a=1+num_success, b=1+(attempts-num_success))
logging.info(('[ESTIMATE] Success rate: %.2f' % success_rate +
' [95 %% HDI: %.2f to %.2f]' % (hdi[0],hdi[1]) +
'\n' + '-'* 20))
out_df = pymc3.summary(trace, var_names=log_var_names, hdi_prob=0.95)
out_df.insert(0, 'iteration', attempts)
out_df.insert(1, 'success', success)
out_df.insert(2, 'power_est', success_rate)
out_df.insert(3, 'power_hdi_2.5%', hdi[0])
out_df.insert(4, 'power_hdi_97.5%', hdi[1])
if attempts == 1:
out_df.to_csv(outfile)
else:
out_df.to_csv(outfile, mode='a', header=False)
'''
Convenience function to fit with logging.
'''
def fit(model, outfile='fit.csv'):
with model:
trace = pymc3.sample(2000, tune=1000, cores=4, init='adapt_diag') #, target_accept=.85)
summary_stats = pymc3.summary(trace, hdi_prob=0.95)
summary_stats.to_csv(outfile)
logger.info('The model was fitted and a summary was written to: ' + outfile)
logger.info('You can analyze the returned trace with help of the Arviz library (https://arviz-devs.github.io/arviz/)')
logger.info('For instance, plot parameter posteriors with arviz.plot_posterior(trace, var_names=["C", "wp"])')
return trace
```
|
{
"source": "jeticg/CMPT411-HW2",
"score": 3
}
|
#### File: jeticg/CMPT411-HW2/test_case_generator.py
```python
import random
import sys
class KBTestCaseGenerator():
def __init__(self, length=10, atoms=10):
self.generate(length, atoms)
return
def generate(self, length, atoms):
self.atomList = []
self.sentenceList = []
for i in range(atoms):
self.atomList.append('a' + str(i))
for i in range(length):
sentence = [random.randint(0, atoms - 1), [], []]
for j in range(random.randint(0, atoms / 2)):
tmp = random.randint(0, atoms - 1)
if tmp != sentence[0] and tmp not in sentence[1]:
sentence[1].append(tmp)
for j in range(random.randint(0, atoms / 2)):
tmp = random.randint(0, atoms - 1)
if tmp != sentence[0] and tmp not in sentence[2]:
sentence[2].append(tmp)
self.sentenceList.append(sentence)
return
def writeToFile(self, fileName):
f = open(fileName, "w")
for sentence in self.sentenceList:
f.write("[" + self.atomList[sentence[0]] + " [")
for i in range(len(sentence[1])):
if i != len(sentence[1]) - 1:
f.write(self.atomList[sentence[1][i]] + " ")
else:
f.write(self.atomList[sentence[1][i]])
f.write("] [")
for i in range(len(sentence[2])):
if i != len(sentence[2]) - 1:
f.write(self.atomList[sentence[2][i]] + " ")
else:
f.write(self.atomList[sentence[2][i]])
f.write("]]\n")
f.close()
return
if __name__ == '__main__':
if len(sys.argv) > 2:
g = KBTestCaseGenerator(sys.argv[2], sys.argv[3])
else:
g = KBTestCaseGenerator()
g.writeToFile(sys.argv[1])
```
|
{
"source": "jeticg/Code013-CL-LexPG",
"score": 3
}
|
#### File: Code013-CL-LexPG/src/main.py
```python
import sys
import importlib
import inspect
import dynet as dy
from support.logger import logging, initialiseLogger, getCommitHash
import support.configHandler as configHandler
from encoder.BiLSTM import Encoder
from models.ModelBase import loadModel
from trainer import trainModel
import evaluator
from evaluator import trans2str
__version__ = "v0.7a"
def translate(input):
f = input.strip().split()
return evaluator.translate(encoder, decoder, f)
def demoMode():
def onScreen(output):
if output is None:
print("[WARN] No previous output available")
else:
print(output)
return
__logger.debug("Running in demo mode. Enter sentences for translation")
__logger.debug("Programme terminates upon receiving <EOF>")
__logger.debug("View structured representation of previous output using " +
"'onscreen' command")
if config["plot"] is True:
if "plot" not in vars(decoder):
__logger.warning("Current decoder does not support plotting!")
config["plot"] = False
else:
decoder.plot = True
from support.plot import plotAlignmentWithScore, showPlot
import numpy as np
output = None
outputStr = None
while True:
try:
line = input("> ")
except (EOFError):
break
if line == "onscreen":
onScreen(output)
continue
__logger.info("Source:\t" + line)
output = translate(line)
outputStr = evaluator.trans2str(output)
__logger.info("Target:\t" + outputStr)
return
if __name__ == "__main__":
# Loading options here, the main programme reads the config file and parses
# command line options
initialiseLogger('main.log')
__logger = logging.getLogger('MAIN')
__logger.debug("""Code013 CL-LexPG %s""" % __version__)
__logger.debug("""Based on Projekt013, Projekt003, Projekt005""")
__logger.debug("--Commit#: {}".format(getCommitHash()))
config = configHandler.processConfig(__version__)
trainDataset = configHandler.configLoadDataset(
config, 'trainData', config['trainSize'])
valDataset = configHandler.configLoadDataset(
config, 'validationData', config['trainSize'])
testDataset = configHandler.configLoadDataset(
config, 'testData', config['testSize'])
pc = dy.ParameterCollection()
__logger.info("Loading encoder: " + config['encoder'] +
"; decoder: " + config['decoder'])
if len(config['encoderOption']) != 0:
__logger.info("Encode options: " + str(config['encoderOption']))
if len(config['decoderOption']) != 0:
__logger.info("decode options: " + str(config['decoderOption']))
# Loading models, that includes the encoder and decoder.
Encoder = importlib.import_module("encoder." + config['encoder']).Encoder
encoder = Encoder()
encoder.option = config["encoderOption"]
Decoder = importlib.import_module("decoder." + config['decoder']).Decoder
decoder = Decoder()
decoder.option = config["decoderOption"]
decoder.alpha = config["alpha"]
if len(config['plugins']) != 0:
if "plugins" not in decoder.component:
__logger.info("Selected decoder does not support plugins")
for plugin in config['plugins']:
__logger.info("decoder plugin: " + plugin)
DecoderPlugin = importlib.import_module(
"decoder.plugins." + plugin).DecoderPlugin
pluginInitParams = inspect.getargspec(DecoderPlugin.__init__)[0]
if "lexFiles" in pluginInitParams:
__logger.debug("Injecting pluginLex option into plugin: " +
plugin)
decoder.plugins.append(
DecoderPlugin(decoder, lexFiles=config["pluginLex"]))
else:
decoder.plugins.append(DecoderPlugin(decoder))
if not config["attention"]:
decoder.atten = False
if config["beamSize"] != 0:
decoder.beamSize = config["beamSize"]
__logger.info("Beam Search enabled, size: " + str(config["beamSize"]))
# Load pretrained model
# if not specified, initialise the model randomly
if config["loadModel"] != "":
loadModel(config["loadModel"], pc, encoder, decoder)
if config['forcePlugin'] is True:
__logger.warning('forcePlugin option is enabled, replacing plugin')
decoder.plugins = []
for plugin in config['plugins']:
__logger.info("decoder plugin: " + plugin)
DecoderPlugin = importlib.import_module(
"decoder.plugins." + plugin).DecoderPlugin
pluginInitParams =\
inspect.getargspec(DecoderPlugin.__init__)[0]
if "lexFiles" in pluginInitParams:
__logger.debug("Injecting pluginLex option into plugin: " +
plugin)
decoder.plugins.append(
DecoderPlugin(decoder, lexFiles=config["pluginLex"]))
else:
decoder.plugins.append(DecoderPlugin(decoder))
else:
if trainDataset is None:
__logger.warning("No selected trainDataset and savedModel")
__logger.debug("Terminating")
exit()
__logger.info("Building Model with trainDataset")
__logger.info("Maximum lexiconSize: " + str(config["lexiconSize"]))
encoder.buildLexicon(trainDataset,
lexiconSize=config["lexiconSize"],
minFrequency=config["srcLexBar"])
decoder.buildLexicon(trainDataset,
lexiconSize=config["lexiconSize"],
minFrequency=config["tgtLexBar"])
encoder.buildModel(
pc, config["inputDim"], config["hiddenDim"],
config["layer"])
decoder.buildModel(
pc, config["inputDim"], config["hiddenDim"],
config["layer"])
# Perform training
if trainDataset is not None:
__logger.debug("Training with trainDataset")
if config["warmup"]:
__logger.debug("""Warmup activated, first epoch of training will
not utilise plugins""")
trainModel(pc, encoder, decoder, trainDataset,
epochs=config["epochs"],
batchSize=config["batchSize"],
validationDataset=valDataset,
trainerName=config["trainer"],
warmup=config["warmup"],
savePath=config["saveModel"],
dropout=config["dropout"],
maxValLossPatience=config["maxValLossPatience"],
maxTrainLen=config['maxLen'])
__logger.debug("Training complete")
# Threshold experiment
# Interactive mode only
def threshold(threshold):
decoder.plugins[0].threshold = threshold
__logger.debug("Testing with testDataset and threshold=" +
str(threshold))
evaluator.evaluate(encoder, decoder, testDataset, config['output'])
__logger.debug("Test complete")
# Perform testing
if testDataset is not None:
if config['disablePlugin']:
plugins = decoder.plugins
decoder.plugins = []
__logger.debug("Testing with testDataset")
evaluator.evaluate(encoder, decoder, testDataset, config['output'])
__logger.debug("Test complete")
if config['disablePlugin']:
decoder.plugins = plugins
if config["demo"] is True:
demoMode()
```
#### File: src/support/plot.py
```python
from __future__ import unicode_literals
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import pyplot
from matplotlib import rcParams, rc, font_manager
rc('pdf', fonttype=42)
__version__ = "0.5a"
prop = None
# In case the characters are not display correctly, one can use the following
# two lines of code to manually load fonts.
# font_path = "/System/Library/Fonts/STHeiti Light.ttc"
# prop = font_manager.FontProperties(fname=font_path)
figures = []
x = y = 0
def plotAlignmentWithScore(score,
align,
f=None,
e=None,
debug=False,
dispValue=False,
output=None):
global x, y
global figures
figures.append(plt.subplots())
fig, ax = figures[-1]
if isinstance(score, np.ndarray):
x, y = score.shape[:2]
else:
x = len(score)
y = len(score[0])
# Produce coordinates
xs = np.tile(np.arange(x), (y, 1)).T.reshape(x * y) + 1
ys = np.tile(np.arange(y), (x, 1)).reshape(x * y) + 1
# Process colours
tmp = score + np.abs(np.min(score, axis=1)[:, None])
tmp *= tmp
tmp = tmp / np.max(tmp, axis=1)[:, None]
colours = 1. - tmp
# Set origin, move x axis labels
ax.xaxis.tick_top()
plt.gca().invert_yaxis()
# Add words
if f is not None:
pyplot.xticks(range(x + 2), rotation=90)
xlabels = [item.get_text() for item in ax.get_xticklabels()]
for i in range(len(f)):
xlabels[i + 1] = f[i][0].decode('utf-8')
if prop is not None:
ax.set_xticklabels(xlabels, fontproperties=prop)
else:
ax.set_xticklabels(xlabels)
if e is not None:
pyplot.yticks(range(y + 2))
ylabels = [item.get_text() for item in ax.get_yticklabels()]
for i in range(len(e)):
ylabels[i + 1] = e[i][0].decode('utf-8')
if y > len(e):
ylabels[len(e) + 1] = "NULL"
if prop is not None:
ax.set_yticklabels(ylabels, fontproperties=prop)
else:
ax.set_yticklabels(ylabels)
# Hover effect
points_with_annotation = []
for i in range(1, x + 1):
for j in range(1, y + 1):
point, = plt.plot(
i, j, "o", c=str(colours[i - 1][j - 1]), markersize=10)
annotation = ax.annotate(
score[i - 1][j - 1],
xy=(i, j), xycoords='data',
xytext=(i, j), textcoords='data',
horizontalalignment="left",
# arrowprops=dict(arrowstyle="simple",
# connectionstyle="arc3,rad=-0.2"),
bbox=dict(boxstyle="round", facecolor="w",
edgecolor="0.5", alpha=0.9)
)
# by default, disable the annotation visibility
annotation.set_visible(False)
points_with_annotation.append([point, annotation])
def on_move(event):
visibility_changed = False
for point, annotation in points_with_annotation:
should_be_visible = (point.contains(event)[0] is True)
if should_be_visible != annotation.get_visible():
visibility_changed = True
annotation.set_visible(should_be_visible)
if visibility_changed:
plt.draw()
on_move_id = fig.canvas.mpl_connect('motion_notify_event', on_move)
plt.scatter([1, x], [1, y], s=1)
# Display alignment
_axs = []
_ays = []
count = 1
for entry in align:
f = entry[0]
e = entry[1]
while f != count:
_axs.append(count)
_ays.append(y)
count += 1
_axs.append(f)
_ays.append(e)
count += 1
plt.plot(_axs, _ays, 'r', marker='+', markersize=10)
# Display scores
if dispValue:
for i in range(x):
for j in range(y):
plt.annotate(score[i][j], xy=(i + 1, j + 1))
if output is None:
pyplot.draw()
return
if not output.endswith(".pdf"):
output += ".pdf"
plt.subplots_adjust(top=0.88)
fig.savefig(output, bbox_inches='tight', dpi=fig.dpi)
return
def showPlot():
pyplot.show()
def addAlignmentToFigure(alignment, figureIndex, colour='#FFA500'):
if figureIndex >= len(figures):
print "duang", figureIndex, len(figures)
return
fig, ax = figures[figureIndex]
_axs = [entry[0] for entry in alignment]
_ays = [entry[1] for entry in alignment]
ax.scatter(_axs, _ays, s=200, marker='s', facecolors='none',
edgecolors=colour, linewidth='3')
if __name__ == '__main__':
print "This run is for debug purpose only"
alignment = [
(1, 10), (2, 7), (3, 3), (4, 1), (5, 2), (6, 3)
]
goldAlignment = [
(1, 10), (1, 9), (2, 7), (2, 6), (2, 8), (3, 4), (3, 5), (4, 1),
(5, 2), (6, 3)
]
score = [[-69.83854259, -50.24906734, -40.05389257, -52.78227564,
-48.95559616, -83.05203389, -41.84190419, -36.80988323,
-53.95177903, -5.51836396, -52.21216642],
[-52.62003578, -48.66259046, -49.63266598, -48.3515764,
-47.78903018, -47.54357859, -20.80823706, -23.82287451,
-46.78370645, -44.94213171, -54.38097957],
[-67.21835653, -65.00201479, -62.33380346, -64.35327028,
-63.36921806, -63.823067, -61.77243324, -61.50220974,
-63.21514471, -63.30335522, -69.67085268],
[-71.601932, -103.69747858, -107.72672434, -130.7129619,
-124.35902727, -139.03331623, -101.91164878, -116.38019098,
-129.80343778, -102.51292713, -110.36482535],
[-144.83428264, -111.05359273, -117.6295708, -113.49649321,
-125.38998938, -114.11012588, -114.2928265, -126.00118102,
-115.6176449, -117.29842781, -120.46454762],
[-154.63301046, -150.83650201, -151.92970335, -152.40304942,
-152.70031894, -153.19412, -153.31395162, -153.80551227,
-154.39353667, -154.82147064, -159.91620834]]
f = (u"阿富汗 阅兵典礼 遭攻击 三名 激进分子 被击毙 。"
).encode("utf-8").split()
e = (u"three militants killed in attack on troop parade in afghanistan" +
u" . NULL").encode("utf-8").split()
f = [(word,) for word in f]
e = [(word,) for word in e]
alignment2 = [(1, 1), (2, 2)]
goldAlignment2 = [(1, 1), (2, 2)]
score2 = [[-2.14112664, -38.80694869, -50.13921307],
[-36.93361547, -3.30257487, -51.00374225]]
f2 = (u"对 。").encode("utf-8").split()
e2 = (u"right . NULL").encode("utf-8").split()
f2 = [(word,) for word in f2]
e2 = [(word,) for word in e2]
plotAlignmentWithScore(score, alignment, f, e)
plotAlignmentWithScore(score2, alignment2, f2, e2)
addAlignmentToFigure(goldAlignment, 0)
addAlignmentToFigure(goldAlignment2, 1)
showPlot()
```
|
{
"source": "jeticg/Projekt006-CL-Datatool",
"score": 2
}
|
#### File: Projekt006-CL-Datatool/natlang/__init__.py
```python
from __future__ import absolute_import
import unittest
import sys
from natlang import format
from natlang import analysis
from natlang import exporter
from natlang import fileConverter
from natlang import loader as loade
from natlang import __version__
__version__ = __version__.version
testModules = {
analysis.conllTransformer,
format.AMR,
format.semanticFrame,
format.tree,
format.txt,
format.txtFiles,
format.txtOrTree,
format.conll,
loader,
}
def testSuite():
loader = unittest.TestLoader()
suite = unittest.TestSuite()
# add tests to the test suite
for module in testModules:
suite.addTests(loader.loadTestsFromModule(module))
return suite
name = "natlang"
# Functions
def load(filePattern,
format='txtOrTree',
loader=None,
linesToLoad=sys.maxsize, verbose=True, option=None):
_loader = loade.DataLoader(format, loader)
return _loader(filePattern,
linesToLoad=linesToLoad,
verbose=verbose,
option=option)
def biload(srcFilePattern, tgtFilePattern,
srcFormat='txtOrTree', tgtFormat='txtOrTree',
srcLoader=None, tgtLoader=None,
linesToLoad=sys.maxsize, verbose=True, option=None):
lad = loader.ParallelDataLoader(srcFormat, tgtFormat)
return lad(fFile=srcFilePattern,
eFile=tgtFilePattern,
linesToLoad=linesToLoad,
verbose=verbose,
option=option)
def export(content, fileName):
f = exporter.RealtimeExporter(fileName)
for line in content:
f.write(line)
return
```
|
{
"source": "jeti-flight/PyViCare",
"score": 2
}
|
#### File: PyViCare/tests/test_VitovalorPT2.py
```python
import pytest
from tests.ViCareServiceMock import ViCareServiceMock
from PyViCare.PyViCareFuelCell import FuelCell
from PyViCare.PyViCareGazBoiler import GazBoiler
import inspect
@pytest.fixture
def service():
return ViCareServiceMock('response_VitovalorPT2.json', 0)
@pytest.fixture
def fuelcell(service):
return FuelCell(None, None, None, 0, 0, service)
def get_fields(clazz):
return [name for name, _ in inspect.getmembers(clazz, predicate=inspect.isfunction)
if name.startswith('get')]
def get_fuelcell_fields():
return sorted(list(set(get_fields(FuelCell)) - set(get_fields(GazBoiler))))
@pytest.mark.parametrize("field", get_fuelcell_fields())
def test_field(fuelcell, field):
# call method
getattr(fuelcell, field)()
```
|
{
"source": "jetilton/ts_knn",
"score": 3
}
|
#### File: ts_knn/ts_knn/test.py
```python
import pandas as pd
from knn_ensemble import KnnEnsemble, get_data, get_data_df
import unittest
import numpy as np
from sklearn.neighbors import KNeighborsRegressor
from cwms_read.cwms_read import get_cwms
from datetime import timedelta
class TestMethods(unittest.TestCase):
endogenous = pd.read_csv('endogenous.csv')
endogenous['date'] = pd.to_datetime(endogenous['date'])
endogenous.set_index('date', drop = True, inplace = True)
exogenous = pd.read_csv('exogenous.csv')
exogenous['date'] = pd.to_datetime(exogenous['date'])
exogenous.set_index('date', drop = True, inplace = True)
# def test_get_data_x(self):
# x = self.endogenous
# x = x.iloc[:,0]
# x.name = 'lag'
# x = x.interpolate().dropna()
# lag = np.random.randint(1,10,1)[0]
# test1 = get_data(x, lag, forward = False)
# test_index = np.random.randint(0,len(test1)-1,1)[0]
# time_stamp = test1.index[test_index]
# vals = [x for x in reversed(test1.loc[time_stamp].values)]
# index = pd.date_range(time_stamp- timedelta(hours = len(vals)), periods=len(vals), freq='H')
# self.assertEqual(vals, x.loc[index].values.tolist())
#
#
# def test_get_data_y(self):
# x = self.endogenous
# x = x.iloc[:,0]
# x.name = 'lag'
# x = x.interpolate().dropna()
# lag = np.random.randint(1,10,1)[0]
# test1 = get_data(x, lag, forward = True)
# test_index = np.random.randint(0,len(test1)-1,1)[0]
# time_stamp = test1.index[test_index]
# vals = [x for x in test1.loc[time_stamp].values]
# index = pd.date_range(time_stamp+ timedelta(hours = 1), periods=len(vals), freq='H')
# self.assertEqual(vals, x.loc[index].values.tolist())
#
# def test_fit(self):
# x = self.endogenous
# x = x.iloc[:,0]
# x.name = 'lag'
# lags = np.random.randint(1,10,1)[0]
# model = KnnEnsemble()
# model.fit(x, x, 'H', 24, lags, limit = 5, new_fit = True)
#
# self.assertEqual(False in model.X.index == model.y.index, False)
#
# def test_static(self):
# x = self.endogenous
# x = x.iloc[:,0]
# index = x.index[int(len(x)*.85)]
# x_train = x[:index]
# x_test = x[index:]
# lags = np.random.randint(1,10,1)[0]
# model = KnnEnsemble()
# model.fit(x_train,x_train, 'H', 24, lags, limit = 5, new_fit = True)
# y_hat = model.static(x_test, test = True)
# k3 = KNeighborsRegressor(n_neighbors = 3)
# k5 = KNeighborsRegressor(n_neighbors = 5)
# k7 = KNeighborsRegressor(n_neighbors = 7)
# results = []
# x_trn = model.X
# y_trn = model.y
# for m in [k3, k5, k7]:
# m.fit(x_trn, y_trn)
# results.append(m.predict(model.x_test))
# results = np.mean(results, axis =0)
# res = results == y_hat
# self.assertEqual(False in res, False)
#
# def test_forward_selection(self):
# x = self.endogenous
# x = x.iloc[:,0]
# index = x.index[int(len(x)*.85)]
# x_train = x[:index]
# y_train = x_train.copy()
# x_test = x[index:]
# y_test = x_test.copy()
# lags = 15
# model = KnnEnsemble()
# errors = model.forward_selection(x_train,y_train, x_test,y_test,'H', 24, max_lags=lags, limit = 5, brk_at_min = True)
# errors.mean()
# min_test = errors.mean()[-1]>errors.mean()[-2] and errors.mean()[-3]>errors.mean()[-2]
# self.assertEqual(min_test, True)
#
# def test_forward_selection_start_time(self):
# x = self.endogenous
# x = x.iloc[:,0]
# index = x.index[int(len(x)*.85)]
# x_train = x[:index]
# y_train = x_train.copy()
# x_test = x[index:]
# y_test = x_test.copy()
# lags = 60
# model = KnnEnsemble()
# errors = model.forward_selection(x_train,y_train, x_test,y_test,'H', 24, start_time = '08:00', max_lags=lags, limit = 5, brk_at_min = False)
# self.assertEqual(errors.mean().min(), 1.5084587278235737)
#
# def test_backward_selection(self):
# x = self.endogenous
# x = x.iloc[:,0]
# index = x.index[int(len(x)*.85)]
# x_train = x[:index]
# y_train = x_train
# x_test = x[index:]
# y_test = x_test
# lags = 15
# model = KnnEnsemble()
# errors=model.backward_selection(x_train,y_train, x_test,y_test,'H', 24, lags=lags, limit = 5, brk_at_min = True)
# errors_forward = model.forward_selection(x_train,y_train, x_test,y_test,'H', 24, max_lags=lags, limit = 5, brk_at_min = False)
#
# self.assertEqual(errors.mean()['lag_1'], errors_forward.mean()['lag_15'])
# def test_backward_selection_start_time(self):
# x = self.endogenous
# x = x.iloc[:,0]
# index = x.index[int(len(x)*.85)]
# x_train = x[:index]
# y_train = x_train.copy()
# x_test = x[index:]
# y_test = x_test.copy()
# lags = 60
# model = KnnEnsemble()
# errors=model.backward_selection(x_train,y_train, x_test,y_test,'H', 24, lags=lags, start_time = '08:00', limit = 5, brk_at_min = True)
# errors_forward = model.forward_selection(x_train,y_train, x_test,y_test,'H', 24, start_time = '08:00', max_lags=lags, limit = 5, brk_at_min = False)
#
# self.assertEqual(errors.mean()['lag_1'], errors_forward.mean()['lag_60'])
#
# def test_forward_backward_selection(self):
# x = self.endogenous
# x = x.iloc[:,0]
# index = x.index[int(len(x)*.85)]
# x_train = x[:index]
# y_train = x_train
# x_test = x[index:]
# y_test = x_test
# max_lags = 15
# model = KnnEnsemble()
# forward_errors = model.forward_selection(x_train,y_train, x_test,y_test,'H', 24, max_lags=max_lags, limit = 5, brk_at_min = True)
# lags = int(forward_errors.mean().idxmin().split('_')[-1])
# backward_errors=model.forward_backward_selection(x_train,y_train, x_test,y_test,'H', 24, max_lags=max_lags, limit = 5, brk_at_min = True)
# min_lag = int(backward_errors.mean().idxmin().split('_')[-1])
# self.assertEqual(model.X.shape[1] == lags-min_lag+1, True)
#
# def test_forward_backward_selection_start_time(self):
# x = self.endogenous
# x = x.iloc[:,0]
# index = x.index[int(len(x)*.85)]
# x_train = x[:index]
# y_train = x_train
# x_test = x[index:]
# y_test = x_test
# max_lags = 15
# model = KnnEnsemble()
# forward_errors = model.forward_selection(x_train,y_train, x_test,y_test,'H', 24, max_lags=max_lags,start_time='08:00', limit = 5, brk_at_min = True)
# lags = int(forward_errors.mean().idxmin().split('_')[-1])
# backward_errors=model.forward_backward_selection(x_train,y_train, x_test,y_test,'H', 24, max_lags=max_lags,start_time='08:00',limit = 5, brk_at_min = True)
# min_lag = int(backward_errors.mean().idxmin().split('_')[-1])
# self.assertEqual(model.X.shape[1] == lags-min_lag+1, True)
#
# def test_rtrn_fwd_lags_bck_lag(self):
# model = KnnEnsemble()
# fwd_lags = model._KnnEnsemble__rtrn_fwd_lags(self.endogenous, exogenous=None, offset='Y', freqstr='H', h = 24, max_lags = 15, interpolate = True, limit = 5, brk_at_min=False)
# self.assertEqual(isinstance(fwd_lags, int), True)
# lag = model._KnnEnsemble__rtrn_bck_lag(self.endogenous, fwd_lags=fwd_lags,exogenous=None, offset='Y', freqstr='H', h = 24, interpolate = True, limit = 5, brk_at_min=False)
# self.assertEqual(isinstance(lag, int), True)
def test_automatic_intervals(self):
model = KnnEnsemble()
#x_test = model.automatic(endogenous=self.endogenous,exogenous=self.exogenous,offset='Y',freqstr='H', h=24, max_lags=max_lags, limit = 5, brk_at_min = True)
#self.assertEqual(x_test.shape[1], 2)
f,b=model.automatic(self.endogenous, exogenous=None, offset='Y', freqstr='H', h = 24, max_lags = 15, start_time = None, interpolate = True, limit = 5, brk_at_min=False, p = .95)
print(f,b)
if __name__ == '__main__':
unittest.main()
```
|
{
"source": "JetJacobs/Cpre-331",
"score": 3
}
|
#### File: Cpre-331/decryptvigenre/freqanalysis.py
```python
class FreqAnalysis:
alphabet = 'abcdefghijklmnopqrstuvwxyz'
## Can't remember where I found the distribution
proabilityDict = {
'e': .1202,
't': .0910,
'a': .0812,
'o': .0768,
'i': .0731,
'n': .0695,
's': .0628,
'r': .0602,
'h': .0592,
'd': .0432,
'l': .0398,
'u': .0288,
'c': .0271,
'm': .0261,
'f': .0230,
'y': .0211,
'w': .0209,
'g': .0203,
'p': .0182,
'b': .0149,
'v': .0111,
'k': .0069,
'x': .0017,
'q': .0011,
'j': .0010,
'z': .0007
}
## Takes each shiftcipher, and does aprediction against it
def predictKey(self, ciphertext, keylen):
splits = self.splitCipherText(ciphertext, keylen)
result = ''
for i in range(keylen):
occurrence = self.__generateOccurrences(splits[i])
result = result + self.__predictKeyLetter(occurrence)
return result
def getPredicted(self, partialciphertext):
return self.__generatePredictionDict(partialciphertext)
def getOccurrences(self, partialciphertext):
return self.__generateOccurrences(partialciphertext)
## Splits the ciphertext into its shift ciphers
## based on keylen
def splitCipherText(self, ciphertext, keylen):
cipherTextArr = []
for i in range(keylen):
cipherTextArr.append(self.__splitify(ciphertext, i, keylen))
return cipherTextArr
## Creates a prediction based on the dict up top,
## and the length of the shift ciphers text
def __generatePredictionDict(self, shiftciphertext):
predictionDict = {}
for i in self.alphabet:
predictionDict[i] = round(
len(shiftciphertext) * self.proabilityDict[i])
return predictionDict
## Generates an occurrence map based on some text
## in this it uses one of the derived shift ciphers
def __generateOccurrences(self, shiftciphertext):
occurrenceDict = {}
for i in self.alphabet:
occurrenceDict[i] = 0
for i in shiftciphertext:
occurrenceDict[i] += 1
return occurrenceDict
## Takes the most occurred letter and shifts it to e
## then derive the number shifted and reassociate
## with the predicted letter
def __predictKeyLetter(self, occurrenceDict):
mostFrequent = 0
approxE = ''
for i in occurrenceDict:
if (occurrenceDict[i] > mostFrequent):
mostFrequent = occurrenceDict[i]
approxE = i
return self.__deshift(approxE)
def __deshift(self, mostFrequent):
return self.alphabet[self.alphabet.find(mostFrequent) - 4]
## Splits the text into pieces based on which
## letter of the key they are encrypted with
def __splitify(self, text, start, nth):
return text[start::nth]
```
#### File: Cpre-331/decryptvigenre/vignere.py
```python
import sys
from findkey import KeyGuess
from freqanalysis import FreqAnalysis
alphabet = 'abcdefghijklmnopqrstuvwxyz'
keyLenPredictor = KeyGuess()
analyser = FreqAnalysis()
def main():
arguments = len(sys.argv)
print('--------------------------------------')
if ('--keylen' in sys.argv and arguments >= 3):
ciphertext = loadCipherText('--keylen')
print(keyLenPredictor.predictKeyLen(ciphertext))
elif ('-a' in sys.argv and arguments >= 3):
ciphertext = loadCipherText('-a')
keylen = keyLenPredictor.predictKeyLen(ciphertext)
splits = analyser.splitCipherText(ciphertext, keylen)
for i in range(keylen):
print('\t\t\t------Shift', i + 1, '------')
printDicts(analyser.getPredicted(splits[i]),
analyser.getOccurrences(splits[i]))
elif ('--key' in sys.argv and arguments >= 3):
ciphertext = loadCipherText('--key')
keylen = keyLenPredictor.predictKeyLen(ciphertext)
result = analyser.predictKey(ciphertext, keylen)
print('Guessed Key:', result)
elif ('-s' in sys.argv and arguments >= 4):
ciphertext = loadCipherText('-s')
key = sys.argv[sys.argv.index('-s') + 1]
print(shiftAll(ciphertext, key))
elif (sys.argv[1] == '-h' or sys.argv[1] == '--help'):
print('Run the program with the following\n')
print('You may read from a file using the following')
print('Please note the filename must follow the flag imediately')
print('\tRead From File:\t -f #\n')
print('\tPredict Key Length:\t --keylen <ciphertext>')
print('\tFrequency Analysis:\t -a <ciphertext>')
print('\tGuess the Key:\t\t --key <ciphertext>')
print('\tDecode:\t\t\t -s <key> <ciphertext>')
else:
print('Try passing --help')
## Loads the cipher from the text file or argv depending
def loadCipherText(trigger):
## From https://stackoverflow.com/questions/8369219/how-to-read-a-text-file-into-a-string-variable-and-strip-newlines
ciphertext = ''
if ('-f' in sys.argv):
with open(sys.argv[sys.argv.index('-f') + 1]) as f:
ciphertext = ''.join([x.strip() for x in f])
elif (trigger == '-s'):
ciphertext = sys.argv[sys.argv.index(trigger) + 2]
key = sys.argv[sys.argv.index(trigger) + 1]
else:
ciphertext = sys.argv[sys.argv.index(trigger) + 1]
return ciphertext
def printDicts(dict1, dict2):
count = 0
print("Count:\t Letter:\t Prediction:\t Actual:\t Shift\t")
for i in alphabet:
count += 1
print(count, "\t", i, "\t\t", dict1[i], '\t\t', dict2[i], '\t\t',
alphabet[alphabet.find(i) - 4])
## preforms a shift based on the key letter
def shift(letter, keyletter):
index = alphabet.find(keyletter)
resultIndex = (alphabet.find(letter) - index)
if resultIndex >= len(alphabet):
resultIndex -= 26
return alphabet[resultIndex]
def shiftAll(ciphertext, key):
result = ''
for i in range(len(ciphertext)):
result += shift(ciphertext[i], key[i % len(key)])
return result
main()
```
#### File: Cpre-331/kickflipcipher/rotor.py
```python
class Rotor:
order = []
reset = ['']
position = 0
def __init__(self, position, key):
self.deriveOrder(key)
self.reset = self.order.copy()
self.position = position
def deriveOrder(self, key):
length = len(key)
neworder = []
for x in range(length):
neworder.append(key[x])
self.order = neworder
def getDisplay(self):
return self.order[self.position]
def findRotation(self, char):
rotation = 0
for x in range(len(self.order)):
if (self.order[x] == char):
if (x - self.position < 0):
rotation = 26 - (self.position - x)
break
else:
rotation = x - self.position
break
return rotation
def rotate(self, rotation):
self.position += rotation
if (self.position >= 26):
self.position = self.position % 26
if (self.position < 0):
self.position = 26 + -(26 % abs(self.position))
def flip(self):
oppositeIndex = self.findOpposite(self.position)
oppositeChar = self.order[oppositeIndex]
self.order[oppositeIndex] = self.getDisplay()
self.order[self.position] = oppositeChar
def kick(self, toRight):
if (toRight):
lastchar = self.order.pop()
self.order.insert(0, lastchar)
else:
lastchar = self.order.pop(0)
self.order.append(lastchar)
def findOpposite(self, pos):
if (pos >= 13):
return pos % 13
else:
return pos + 13
def resetRotor(self):
self.order = self.reset
```
#### File: Cpre-331/powerballgen/powerball.py
```python
import random
def generateDrawingOfPowerball():
whiteballs = []
while(len(whiteballs) < 5):
newball = random.randint(1, 69)
if(newball not in whiteballs):
whiteballs.append(newball)
redball = random.randint(1, 26)
return whiteballs, redball
def predictDrawing(previousdraw):
random.seed(1)
currDraw = [0, 1]
while(previousdraw[0] != currDraw[0] or previousdraw[1] != currDraw[1]):
currDraw = generateDrawingOfPowerball()
whiteballs, redball = generateDrawingOfPowerball()
return whiteballs, redball
def predictDrawingByNumber(drawing):
random.seed(1)
for i in range(1, drawing):
generateDrawingOfPowerball()
whiteballs, redball = generateDrawingOfPowerball()
return whiteballs, redball
def printBalls(balls, drawing):
print('----Drawing', drawing, '----')
print('White balls:',
balls[0][0],
balls[0][1],
balls[0][2],
balls[0][3],
balls[0][4],
'Red Ball:', balls[1])
print('\n')
if __name__ == "__main__":
print('######## Prediction for draw ########')
printBalls(predictDrawingByNumber(11), 11)
print('###### Powerball generator ######')
random.seed(1)
for i in range(1, 11):
drawing = generateDrawingOfPowerball()
printBalls(drawing, i)
print('########## Predicted Drawing! ##########')
printBalls(generateDrawingOfPowerball(), 11)
print('Draw Prediction based on previous draw')
printBalls(predictDrawing(drawing), 11)
```
|
{
"source": "JetJet13/ssmx",
"score": 2
}
|
#### File: JetJet13/ssmx/test_ssm.py
```python
import boto3
import ssm
import yaml
import tempfile
from click.testing import CliRunner
from moto import mock_ssm
@mock_ssm
def test_list_no_arg():
conn = boto3.client('ssm')
# Create two parameters and check both are returned
conn.put_parameter(Name='test', Value='testing123', Type='SecureString')
conn.put_parameter(Name='test1', Value='testing123', Type='SecureString')
# Call list without any parameters
out = ssm.list_params([])
names = [param['Name'] for param in out]
assert len(out) == 2
assert 'test1' in names
assert 'test' in names
@mock_ssm
def test_list_starts_with():
conn = boto3.client('ssm')
# Create two parameters and check both are returned
conn.put_parameter(Name='test1', Value='testing123', Type='SecureString')
conn.put_parameter(Name='anotherValue', Value='testing123', Type='SecureString')
out = ssm.list_params(["test"])
names = [param['Name'] for param in out]
assert len(out) == 1
assert 'test1' in names
assert 'anotherValue' not in names
@mock_ssm
def test_delete_correct():
conn = boto3.client('ssm')
# Create a parameter and check if it is deleted.
conn.put_parameter(Name='test1', Value='testing123', Type='SecureString')
out, err = ssm.delete_params(['test1'])
assert len(err) == 0
assert len(out) == 1
assert 'test1' in out
# Check if parameter is actually deleted
out = ssm.list_params(['test1'])
assert len(out) == 0
@mock_ssm
def test_delete_invalid():
# Delete an invalid parameter
out, err = ssm.delete_params(['InvalidParam'])
assert len(out) == 0
assert len(err) == 1
assert 'InvalidParam' in err
@mock_ssm
def test_get_param_correct():
conn = boto3.client('ssm')
# Put 2 parameters
conn.put_parameter(Name='test1', Value='testing1', Type='SecureString')
conn.put_parameter(Name='test1', Value='testing2', Type='SecureString')
# get the parameter
out, err = ssm.get_params(['test1'])
# Check output
assert len(out) == 1
assert len(err) == 0
assert out[0]['Name'] == 'test1'
assert out[0]['Value'] == 'testing1'
@mock_ssm
def test_get_param_incorrect():
conn = boto3.client('ssm')
# Put 2 parameters
conn.put_parameter(Name='test1', Value='testing1', Type='SecureString')
conn.put_parameter(Name='test2', Value='testing2', Type='SecureString')
# get the parameter
out, err = ssm.get_params(['test1', 'test3'])
# Check output
assert len(out) == 1
assert len(err) == 1
assert out[0]['Name'] == 'test1'
assert out[0]['Value'] == 'testing1'
# Check error
assert err[0] == 'test3'
@mock_ssm
def test_put_param():
# Put 1 parameter
ssm.put_param(name="test1", value="value1", description='my var', encrypt=True)
# get the parameter
out, err = ssm.get_params(['test1'])
# Check parameter is returned
assert len(out) == 1
assert len(err) == 0
assert out[0]['Name'] == 'test1'
assert out[0]['Value'] == 'value1'
@mock_ssm
def test_cli_list_no_arg():
conn = boto3.client('ssm')
# Create two parameters and check both are returned
conn.put_parameter(Name='test1', Value='testing1', Type='SecureString')
conn.put_parameter(Name='test2', Value='testing2', Type='SecureString')
# Call list without any parameters
runner = CliRunner()
result = runner.invoke(ssm.list)
assert "No parameters found" not in result.output
assert 'test1' in result.output
assert 'test2' in result.output
@mock_ssm
def test_cli_list_starts_with():
conn = boto3.client('ssm')
# Create two parameters and check both are returned
conn.put_parameter(Name='test1', Value='testing123', Type='SecureString')
conn.put_parameter(Name='anotherValue', Value='testing123', Type='SecureString')
runner = CliRunner()
result = runner.invoke(ssm.list, ['--name', 'test'])
assert 'test1' in result.output
assert 'anotherValue' not in result.output
@mock_ssm
def test_cli_get_param():
conn = boto3.client('ssm')
# Create two parameters and check both are returned
conn.put_parameter(Name='test1', Value='value1', Type='SecureString')
conn.put_parameter(Name='test2', Value='value2', Type='SecureString')
runner = CliRunner()
result = runner.invoke(ssm.get, ['--name', 'test1'])
assert 'Invalid Parameters' not in result.output
assert 'value1' in result.output
assert 'test1' in result.output
assert 'test2' not in result.output
assert 'value2' not in result.output
@mock_ssm
def test_cli_delete_correct():
conn = boto3.client('ssm')
# Create a parameter and check if it is deleted.
conn.put_parameter(Name='test1', Value='testing123', Type='SecureString')
runner = CliRunner()
result = runner.invoke(ssm.delete, ['--name', 'test1'])
assert 'Deleted Parameters' in result.output
assert 'test1' in result.output
# Check if parameter is actually deleted
runner = CliRunner()
result = runner.invoke(ssm.list, ['--name', 'test1'])
assert 'No parameters found' in result.output
@mock_ssm
def test_cli_delete_invalid():
# Delete an invalid parameter
runner = CliRunner()
result = runner.invoke(ssm.delete, ['--name', 'invalid_param'])
assert 'Invalid Parameters' in result.output
assert 'invalid_param' in result.output
assert 'Deleted Parameters' not in result.output
@mock_ssm
def test_cli_put_param():
# Create a parameter
runner = CliRunner()
result = runner.invoke(ssm.put, ['--name', 'test1', '--value', 'value1', '--encrypt'])
assert 'Created Parameters' in result.output
assert 'test' in result.output
@mock_ssm
def test_cli_file_list():
# Create a temp file
test_file = tempfile.NamedTemporaryFile(delete=False, mode='w')
conn = boto3.client('ssm')
conn.put_parameter(Name='test1', Value='val', Type='SecureString')
conn.put_parameter(Name='test2', Value='val', Type='SecureString')
test_file.write('''
list:
- test''')
test_file.close()
runner = CliRunner()
result = runner.invoke(ssm.from_file, ['--path', test_file.name])
output_yaml = yaml.load(result.output)
assert 'list' in output_yaml.keys()
assert len(output_yaml['list']) == 2
assert 'test1' in [param['Name'] for param in output_yaml['list']]
assert 'test2' in [param['Name'] for param in output_yaml['list']]
@mock_ssm
def test_file_delete():
# Create a temp file
test_file = tempfile.NamedTemporaryFile(delete=False, mode='w')
conn = boto3.client('ssm')
conn.put_parameter(Name='test1', Value='val', Type='SecureString')
test_file.write('''
delete:
- test1
- invalid''')
test_file.close()
runner = CliRunner()
result = runner.invoke(ssm.from_file, ['--path', test_file.name])
output_yaml = yaml.load(result.output)
assert 'delete' in output_yaml.keys()
assert len(output_yaml['delete']['DeletedParameters']) == 1
assert output_yaml['delete']['DeletedParameters'][0] == 'test1'
assert len(output_yaml['delete']['InvalidParameters']) == 1
assert output_yaml['delete']['InvalidParameters'][0] == 'invalid'
@mock_ssm
def test_file_get():
# Create a temp file
test_file = tempfile.NamedTemporaryFile(delete=False, mode='w')
conn = boto3.client('ssm')
conn.put_parameter(Name='test1', Value='val', Type='SecureString')
test_file.write('''
get:
- test1
- invalid''')
test_file.close()
runner = CliRunner()
result = runner.invoke(ssm.from_file, ['--path', test_file.name])
output_yaml = yaml.load(result.output)
assert 'get' in output_yaml.keys()
assert len(output_yaml['get']['GetParameters']) == 1
assert output_yaml['get']['GetParameters'][0]['Name'] == 'test1'
assert len(output_yaml['get']['InvalidParameters']) == 1
assert output_yaml['get']['InvalidParameters'][0] == 'invalid'
@mock_ssm
def test_file_put():
# Create a temp file
test_file = tempfile.NamedTemporaryFile(delete=False, mode='w')
test_file.write('''
put:
- name: test
value: val
encrypt: True''')
test_file.close()
runner = CliRunner()
result = runner.invoke(ssm.from_file, ['--path', test_file.name])
output_yaml = yaml.load(result.output)
assert 'put' in output_yaml.keys()
assert len(output_yaml['put']['CreatedParameters']) == 1
assert output_yaml['put']['CreatedParameters'][0] == 'test'
# Check parameter actually got created
conn = boto3.client('ssm')
response = conn.describe_parameters()
assert response['Parameters'][0]['Name'] == 'test'
```
|
{
"source": "jetjokers24895/reviewvn",
"score": 2
}
|
#### File: reviewvn/getrw_adayroi/views.py
```python
from __future__ import unicode_literals
from . import search_adayroi
from django.shortcuts import render
# Create your views here.
def getrw_adayroi(request):
return render(request,"getrw_adayroi/form.html")
def createobj(keywords):
fclass = search_adayroi.search_adayroi(keywords)
print len(fclass)
listobj=list()
for i in fclass:
linkweb ='https://www.adayroi.com'+ i.a.get("href")
comment = search_adayroi.get_comment(linkweb)
#print len(comment)
if len(comment) == 0 :
continue
else:
#print comment
linkimg = i.a.img.get('data-src')
obj= search_adayroi.object_adayroi(linkweb,comment,linkimg)
listobj.append(obj)
return listobj
def mainaction(requests):
keywords = requests.POST['keywords']
lst= createobj(keywords)
if lst == []:
return render(requests,'getrw_adayroi/nocomment.html')
return render(requests,"getrw_adayroi/review.html",{'lst':lst})
```
#### File: reviewvn/getrw/views.py
```python
from __future__ import unicode_literals
from django.shortcuts import render
from . import search
# Create your views here.
def createobj(keywords):
fclass = search.search_lazada(keywords)
listobj=list()
for i in fclass:
linkweb = 'http://lazada.vn'+i.a.get("href")
comment = search.getcomment(linkweb)
#print len(comment)
if len(comment) == 0 :
continue
else:
#print comment
linkimg = search.get_src(i.span)
obj= search.object(linkweb,comment,linkimg)
listobj.append(obj)
return listobj
def getrw(request):
return render(request,"getrw/form.html")
def mainaction(requests):
keywords = requests.POST['keywords']
lst= createobj(keywords)
if lst == []:
return render(requests,'getrw/nocomment.html')
return render(requests,"getrw/review.html",{'lst':lst})
```
|
{
"source": "Jetli100/SHRA_Chapter6_7_9",
"score": 2
}
|
#### File: SHRA_Chapter6_7_9/Chapter 6-7/fn_PSHA_given_M_lambda.py
```python
import numpy as np
from scipy.stats import norm
from scipy.interpolate import interp1d
from gmpe_eval import gmpe_eval
# Compute PSHA, with rupture rates for each M precomputed
##############
### Inputs ###
##############
# lambda_M exceedance rate of EQs for each M
# M_vals values of M corresponding to lambda_M
# x IM values of interest
# x_example example IM value for table
# rup data structure with rupture parameters
# gmpeFlag =1 for BJF97, =2 for CY14
def fn_PSHA_given_M_lambda(lambda_M, M_vals, T, x, x_example, rup, gmpeFlag):
lambda_occur = -np.diff(lambda_M) # find occurence rates from exceedance rates
lambda_occur = np.append(lambda_occur, lambda_M[-1])
# p(exceeding each x threshold value | M)
lambda0 = {}
disagg = {}
lambda0["x"] = []
disagg["allv"] = []
for j in range(len(x)):
p_given_M = []
for i in range(len(M_vals)):
sa, sigma = gmpe_eval(T, M_vals[i], rup, gmpeFlag)
p_given_M.append(1 - norm.cdf(np.log(x[j]),np.log(sa),sigma))
p_given_M = np.array(p_given_M)
lambda0["x"].append(np.sum(lambda_occur * p_given_M)) # rate of exceeding x
disagg["allv"].append((lambda_occur * p_given_M) / lambda0["x"][j])
# calcs for example IM case
p_ex = []
for i in range(len(M_vals)):
sa, sigma = gmpe_eval(T, M_vals[i], rup, gmpeFlag)
p_ex.append(1-norm.cdf(np.log(x_example),np.log(sa),sigma))
example_output = [[i for i in range(len(M_vals))], list(M_vals), list(lambda_occur), p_ex, list(lambda_occur*np.array(p_ex))]
p_ex = np.asarray(p_ex)
M_vals = np.asarray(M_vals)
lambda0["example"] = np.sum(lambda_occur * p_ex)
disagg["example"] = (lambda_occur * p_ex) / lambda0["example"]
disagg["Mbar"] = np.sum(M_vals * disagg["example"])
# disagg conditional on occurence for example IM case
xInc = x_example * 1.02 # do computations at an increment on x
pInc = []
for i in range(len(M_vals)):
sa, sigma = gmpe_eval(T, M_vals[i], rup, gmpeFlag)
pInc.append(1 - norm.cdf(np.log(xInc),np.log(sa),sigma))
pInc = np.array(pInc)
lambdaInc = np.sum(lambda_occur * pInc)
disagg["equal"] = ((lambda_occur * p_ex) - (lambda_occur * pInc)) / (lambda0["example"]-lambdaInc)
disagg["equalMbar"] = np.sum(M_vals * disagg["equal"])
# disaggs with epsilon
deltaEps = 1 # final binning
epsVals = np.arange(-3, 4, deltaEps) # epsilon bins
deltaEpsFine = 0.1 # initial finer binning
epsValsFine = np.arange(-35, 36, int(deltaEpsFine*10)) / 10 # midpoints of bins
p_eps = norm.pdf(epsValsFine) * deltaEpsFine # estimate PDF using a PMF with discrete epsilon increments
lambda_M_and_eps = np.outer(lambda_occur, p_eps) # rate of events with a given magnitude and epsilon
Ind = []
for i in range(len(M_vals)):
sa, sigma = gmpe_eval(T, M_vals[i], rup, gmpeFlag)
Ind.append((np.log(sa) + epsValsFine*sigma) > np.log(x_example)) # indicator that the M/epsilon value causes IM > x_example
exceedRatesFine = np.asarray(Ind) * lambda_M_and_eps # rates of given M/epsilon values exceeding IM
lambdaExceed = np.sum(exceedRatesFine) # this is close to lambda.example, but may differ by a few percent due to epsilon discretization
# compute mean epsilon
epsDeagg = np.sum(exceedRatesFine, axis=0) / np.sum(exceedRatesFine)
disagg["epsBar"] = np.sum(epsValsFine * epsDeagg)
# aggregate results to coarser epsilon bins
exceedRates = []
for j in range(len(epsVals)):
idx = np.nonzero((epsValsFine >= (epsVals[j]-deltaEps/2)) & (epsValsFine < (epsVals[j]+deltaEps/2)))[0]
exceedRates.append(np.sum(exceedRatesFine[:,idx], axis=1))
exceedRates = np.transpose(np.asarray(exceedRates))
disagg["epsVals"] = epsVals # return bin midpoints
disagg["M_Eps"] = exceedRates / lambdaExceed # magnitude and epsilon disaggregation
disagg["eps"] = np.sum(exceedRates, axis=0) / lambdaExceed # epsilon disaggregation
return lambda0, example_output, disagg
```
#### File: SHRA_Chapter6_7_9/Chapter 6-7/fn_PSHA.py
```python
import numpy as np
from scipy.stats import norm
from scipy.interpolate import interp1d
from gmpe_prob_bjf97 import gmpe_prob_bjf97
from gmpe_BSSA_2014 import gmpe_BSSA_2014
from gmpe_CY_2014 import gmpe_CY_2014
# General function to do PSHA calculations under a variety of Rup and GMM parameters
def fn_PSHA(rup, M_vals, lambda_M, T, x, x_example):
# use BJF97 if not specified (for backwards compatibility)
if "gmm" not in rup:
rup["gmm"] = 1
lambda_occur = -np.diff(lambda_M) # find occurence rates from exceedance rates
lambda_occur = np.append(lambda_occur, lambda_M[-1])
# p(exceeding each x threshold value | M)
lambda_x = []
M_disagg = []
for j in range(len(x)):
p_given_M = []
for i in range(len(M_vals)):
if rup["gmm"] == 1: # BJF 1997 model
p_given_M.append(gmpe_prob_bjf97(x[j], M_vals[i], rup["R"], T, rup["Fault_Type"], rup["Vs30"]))
elif rup["gmm"] == 2: # BSSA 2014 model
sa, sigma, _ = gmpe_BSSA_2014(M_vals[i], T, rup["R"],rup["Fault_Type"], rup["region"], rup["Z10"], rup["Vs30"])
p_given_M.append(1 - norm.cdf(np.log(x[j]), np.log(sa), sigma))
else: #CY 2014 model
sa, sigma, _ = gmpe_CY_2014(M_vals[i], T, rup["R"], rup["R"], rup["R"], rup["Ztor"], rup["delta"], rup["lambda0"], rup["Z10"], rup["Vs30"], rup["Fhw"], rup["FVS30"], rup["region"])
p_given_M.append(1 - norm.cdf(np.log(x[j]), np.log(sa), sigma))
lambda_x.append(np.sum(lambda_occur * np.array(p_given_M))) # rate of exceeding x
M_disagg.append((lambda_occur * np.array(p_given_M)) / lambda_x[j])
# calcs for example IM case
p_ex = []
for i in range(len(M_vals)):
if rup["gmm"] == 1: # BJF 1997 model
p_ex.append(gmpe_prob_bjf97(x_example, M_vals[i], rup["R"], T, rup["Fault_Type"], rup["Vs30"]))
elif rup["gmm"] == 2: # BSSA 2014 model
sa, sigma, _ = gmpe_BSSA_2014(M_vals[i], T, rup["R"],rup["Fault_Type"], rup["region"], rup["Z10"], rup["Vs30"])
p_ex.append(1 - norm.cdf(np.log(x_example), np.log(sa), sigma))
else: # CY 2014 model
sa, sigma, _ = gmpe_CY_2014(M_vals[i], T, rup["R"], rup["R"], rup["R"], rup["Ztor"], rup["delta"], rup["lambda0"], rup["Z10"], rup["Vs30"], rup["Fhw"], rup["FVS30"], rup["region"])
p_ex.append(1 - norm.cdf(np.log(x_example), np.log(sa), sigma))
example_output = [[i for i in range(len(M_vals))], list(M_vals), list(lambda_occur), p_ex, list(lambda_occur*np.array(p_ex))]
lambda_example = np.sum(lambda_occur * np.array(p_ex))
return lambda_x, lambda_example, example_output, M_disagg
```
#### File: SHRA_Chapter6_7_9/Chapter 6-7/gmpe_CY_2014.py
```python
import numpy as np
from scipy.stats import norm
from scipy.interpolate import interp1d
# CY_14 attenuation equation - Update of the Chiou and Youngs NGA Model for
# the Average Horizontal Component of Peak Ground Motion and Response
# Spectra, Chiou and Youngs (2014)
##############
### Inputs ###
##############
# M = Moment Magnitude
# T = Period (sec); Use Period = -1 for PGV computation
# Use 1000 for output the array of Sa with original period
# (no interpolation)
# Rup = Closest distance (km) to the ruptured plane
# Rjb = Joyner-Boore distance (km); closest distance (km) to surface
# projection of rupture plane
# Rx = Horizontal distance from top of rupture measured perpendicular
# to fault strike (km). See Figures a, b and c for illustation% Ztor = Depth(km) to the top of ruptured plane
# delta = Fault dip angle (in degree)
# lamda = Rake angle (in degree)
# region = 0 for global (incl. Taiwan)
# = 1 for California
# = 2 for Japan
# = 3 for China
# = 4 for Italy
# = 5 for Turkey
# Z10 = Basin depth (km); depth from the groundsurface to the
# 1km/s shear-wave horizon.
# = 999 if unknown
# Vs30 = shear wave velocity averaged over top 30 m in m/s
# = ref: 1130
# FVS30 = 1 for Vs30 is inferred from geology
# = 0 for measured Vs30
# d_DPP = DPP centered on the site and earthquake specific average
# DPP, = 0 for median calc
# %d_DPP functionality added BAB 26 July 2020
###############
### Outputs ###
###############
# Sa: Median spectral acceleration prediction
# sigma: logarithmic standard deviation of spectral acceleration
# prediction
def CY_2014_sub(M, ip, R_RUP, R_JB, Rx, Ztor, delta, F_RV, F_NM, HW, Z10, Vs30, FVS30, region, d_DPP):
dict = {}
dict["c2"] = [1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06, 1.06]
dict["c4"] = [-2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1, -2.1]
dict["c4_a"] = [-0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5]
dict["c_RB"] = [50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50]
dict["c8"] = [0.2154, 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0.0991, 0.1982, 0.2154, 0.2154, 0.2154, 0.2154, 0.2154, 0.2154, 0.2154, 0.2154]
dict["c8_a"] = [0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695, 0.2695]
dict["c1"] = [ 2.3549, -1.5065, -1.5065, -1.4798, -1.2972, -1.1007, -0.9292, -0.658 , -0.5613, -0.5342, -0.5462, -0.5858, -0.6798, -0.8663, -1.0514, -1.3794, -1.6508, -2.1511, -2.5365, -3.0686, -3.4148, -3.9013, -4.2466, -4.5143, -5.0009, -5.3461]
dict["c1_a"] = [0.165 , 0.165 , 0.165 , 0.165 , 0.165 , 0.165 , 0.165 , 0.165 , 0.165 , 0.165 , 0.165 , 0.165, 0.165, 0.165, 0.165 , 0.165 , 0.165 , 0.165 , 0.165 , 0.165 , 0.1645, 0.1168, 0.0732, 0.0484, 0.022 , 0.0124]
dict["c1_b"] = [-0.0626, -0.255 , -0.255 , -0.255 , -0.255 , -0.255 , -0.255 , -0.254 , -0.253 , -0.252 , -0.25 , -0.248 , -0.2449, -0.2382, -0.2313, -0.2146, -0.1972, -0.162 , -0.14 , -0.1184, -0.11 , -0.104 , -0.102 , -0.101 , -0.101 , -0.1 ]
dict["c1_c"] = [-0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.165 , -0.1645, -0.1168, -0.0732, -0.0484, -0.022 , -0.0124]
dict["c1_d"] = [0.0626, 0.255 , 0.255 , 0.255 , 0.255 , 0.255 , 0.255 , 0.254 , 0.253 , 0.252 , 0.25 , 0.248 , 0.2449, 0.2382, 0.2313, 0.2146, 0.1972, 0.162 , 0.14 , 0.1184, 0.11 , 0.104 , 0.102 , 0.101 , 0.101 , 0.1 ]
dict["c_n"] = [ 3.3024, 16.0875, 16.0875, 15.7118, 15.8819, 16.4556, 17.6453, 20.1772, 19.9992, 18.7106, 16.6246, 15.3709, 13.7012, 11.2667, 9.1908, 6.5459, 5.2305, 3.7896, 3.3024, 2.8498, 2.5417, 2.1488, 1.8957, 1.7228, 1.5737, 1.5265]
dict["c_m"] = [5.423 , 4.9993, 4.9993, 4.9993, 4.9993, 4.9993, 4.9993, 5.0031, 5.0172, 5.0315, 5.0547, 5.0704, 5.0939, 5.1315, 5.167 , 5.2317, 5.2893, 5.4109, 5.5106, 5.6705, 5.7981, 5.9983, 6.1552, 6.2856, 6.5428, 6.7415]
dict["c3"] = [2.3152, 1.9636, 1.9636, 1.9636, 1.9636, 1.9636, 1.9636, 1.9636, 1.9636, 1.9795, 2.0362, 2.0823, 2.1521, 2.2574, 2.344 , 2.4709, 2.5567, 2.6812, 2.7474, 2.8161, 2.8514, 2.8875, 2.9058, 2.9169, 2.932 , 2.9396]
dict["c5"] = [5.8096, 6.4551, 6.4551, 6.4551, 6.4551, 6.4551, 6.4551, 6.4551, 6.8305, 7.1333, 7.3621, 7.4365, 7.4972, 7.5416, 7.56 , 7.5735, 7.5778, 7.5808, 7.5814, 7.5817, 7.5818, 7.5818, 7.5818, 7.5818, 7.5818, 7.5818]
dict["c_HM"] = [3.0514, 3.0956, 3.0956, 3.0963, 3.0974, 3.0988, 3.1011, 3.1094, 3.2381, 3.3407, 3.43 , 3.4688, 3.5146, 3.5746, 3.6232, 3.6945, 3.7401, 3.7941, 3.8144, 3.8284, 3.833 , 3.8361, 3.8369, 3.8376, 3.838 , 3.838 ]
dict["c6"] = [0.4407, 0.4908, 0.4908, 0.4925, 0.4992, 0.5037, 0.5048, 0.5048, 0.5048, 0.5048, 0.5045, 0.5036, 0.5016, 0.4971, 0.4919, 0.4807, 0.4707, 0.4575, 0.4522, 0.4501, 0.45 , 0.45 , 0.45 , 0.45 , 0.45 , 0.45 ]
dict["c7"] = [0.0324, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.0352, 0.016 , 0.0062, 0.0029, 0.0007, 0.0003]
dict["c7_b"] = [ 0.0097, 0.0462, 0.0462, 0.0472, 0.0533, 0.0596, 0.0639, 0.063 , 0.0532, 0.0452, 0.0345, 0.0283, 0.0202, 0.009 , -0.0004, -0.0155, -0.0278, -0.0477, -0.0559, -0.063 , -0.0665, -0.0516, -0.0448, -0.0424, -0.0348, -0.0253]
dict["c8_b"] = [5. , 0.4833, 0.4833, 1.2144, 1.6421, 1.9456, 2.181 , 2.6087, 2.9122, 3.1045, 3.3399, 3.4719, 3.6434, 3.8787, 4.0711, 4.3745, 4.6099, 5.0376, 5.3411, 5.7688, 6.0723, 6.5 , 6.8035, 7.0389, 7.4666, 7.77 ]
dict["c9"] = [0.3079, 0.9228, 0.9228, 0.9296, 0.9396, 0.9661, 0.9794, 1.026 , 1.0177, 1.0008, 0.9801, 0.9652, 0.9459, 0.9196, 0.8829, 0.8302, 0.7884, 0.6754, 0.6196, 0.5101, 0.3917, 0.1244, 0.0086, 0. , 0. , 0. ]
dict["c9_a"] = [0.1 , 0.1202, 0.1202, 0.1217, 0.1194, 0.1166, 0.1176, 0.1171, 0.1146, 0.1128, 0.1106, 0.115 , 0.1208, 0.1208, 0.1175, 0.106 , 0.1061, 0.1 , 0.1 , 0.1 , 0.1 , 0.1 , 0.1 , 0.1 , 0.1 , 0.1 ]
dict["c9_b"] = [6.5 , 6.8607, 6.8607, 6.8697, 6.9113, 7.0271, 7.0959, 7.3298, 7.2588, 7.2372, 7.2109, 7.2491, 7.2988, 7.3691, 6.8789, 6.5334, 6.526 , 6.5 , 6.5 , 6.5 , 6.5 , 6.5 , 6.5 , 6.5 , 6.5 , 6.5 ]
dict["c11"] = [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]
dict["c11_b"] = [-0.3834, -0.4536, -0.4536, -0.4536, -0.4536, -0.4536, -0.4536, -0.4536, -0.4536, -0.4536, -0.4536, -0.4536, -0.444 , -0.3539, -0.2688, -0.1793, -0.1428, -0.1138, -0.1062, -0.102 , -0.1009, -0.1003, -0.1001, -0.1001, -0.1, -0.1]
dict["c_g1"] = [-0.001852, -0.007146, -0.007146, -0.007249, -0.007869, -0.008316, -0.008743, -0.009537, -0.00983 , -0.009913, -0.009896, -0.009787, -0.009505, -0.008918, -0.008251, -0.007267, -0.006492, -0.005147, -0.004277, -0.002979, -0.002301, -0.001344, -0.001084, -0.00101 , -0.000964, -0.00095 ]
dict["c_g2"] = [-0.007403, -0.006758, -0.006758, -0.006758, -0.006758, -0.006758, -0.006758, -0.00619 , -0.005332, -0.004732, -0.003806, -0.00328 , -0.00269 , -0.002128, -0.001812, -0.001274, -0.001074, -0.001115, -0.001197, -0.001675, -0.002349, -0.003306, -0.003566, -0.00364 , -0.003686, -0.0037 ]
dict["c_g3"] = [4.3439, 4.2542, 4.2542, 4.2386, 4.2519, 4.296 , 4.3578, 4.5455, 4.7603, 4.8963, 5.0644, 5.1371, 5.188 , 5.2164, 5.1954, 5.0899, 4.7854, 4.3304, 4.1667, 4.0029, 3.8949, 3.7928, 3.7443, 3.709 , 3.6632, 3.623 ]
dict["phi1"] = [-0.7936, -0.521 , -0.521 , -0.5055, -0.4368, -0.3752, -0.3469, -0.3747, -0.444 , -0.4895, -0.5477, -0.5922, -0.6693, -0.7766, -0.8501, -0.9431, -1.0044, -1.0602, -1.0941, -1.1142, -1.1154, -1.1081, -1.0603, -0.9872, -0.8274, -0.7053]
dict["phi2"] = [-0.0699, -0.1417, -0.1417, -0.1364, -0.1403, -0.1591, -0.1862, -0.2538, -0.2943, -0.3077, -0.3113, -0.3062, -0.2927, -0.2662, -0.2405, -0.1975, -0.1633, -0.1028, -0.0699, -0.0425, -0.0302, -0.0129, -0.0016, 0. , 0. , 0. ]
dict["phi3"] = [-0.008444, -0.00701 , -0.00701 , -0.007279, -0.007354, -0.006977, -0.006467, -0.005734, -0.005604, -0.005696, -0.005845, -0.005959, -0.006141, -0.006439, -0.006704, -0.007125, -0.007435, -0.00812 , -0.008444, -0.007707, -0.004792, -0.001828, -0.001523, -0.00144 , -0.001369, -0.001361]
dict["phi4"] = [5.41000e+00, 1.02151e-01, 1.02151e-01, 1.08360e-01, 1.19888e-01, 1.33641e-01, 1.48927e-01, 1.90596e-01, 2.30662e-01, 2.53169e-01, 2.66468e-01, 2.65060e-01, 2.55253e-01, 2.31541e-01, 2.07277e-01, 1.65464e-01, 1.33828e-01, 8.51530e-02, 5.85950e-02, 3.17870e-02, 1.97160e-02, 9.64300e-03, 5.37900e-03, 3.22300e-03, 1.13400e-03, 5.15000e-04]
dict["phi5"] = [0.0202, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.001 , 0.004 , 0.01 , 0.034 , 0.067 , 0.143 , 0.203, 0.277, 0.309 , 0.321 , 0.329 , 0.33 ]
dict["phi6"] = [300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300]
dict["tau1"] = [0.3894, 0.4 , 0.4 , 0.4026, 0.4063, 0.4095, 0.4124, 0.4179, 0.4219, 0.4244, 0.4275, 0.4292, 0.4313, 0.4341, 0.4363, 0.4396, 0.4419, 0.4459, 0.4484, 0.4515, 0.4534, 0.4558, 0.4574, 0.4584, 0.4601, 0.4612]
dict["tau2"] = [0.2578, 0.26 , 0.26 , 0.2637, 0.2689, 0.2736, 0.2777, 0.2855, 0.2913, 0.2949, 0.2993, 0.3017, 0.3047, 0.3087, 0.3119, 0.3165, 0.3199, 0.3255, 0.3291, 0.3335, 0.3363, 0.3398, 0.3419, 0.3435, 0.3459, 0.3474]
dict["sigma1"] = [0.4785, 0.4912, 0.4912, 0.4904, 0.4988, 0.5049, 0.5096, 0.5179, 0.5236, 0.527 , 0.5308, 0.5328, 0.5351, 0.5377, 0.5395, 0.5422, 0.5433, 0.5294, 0.5105, 0.4783, 0.4681, 0.4617, 0.4571, 0.4535, 0.4471, 0.4426]
dict["sigma2"] = [0.3629, 0.3762, 0.3762, 0.3762, 0.3849, 0.391 , 0.3957, 0.4043, 0.4104, 0.4143, 0.4191, 0.4217, 0.4252, 0.4299, 0.4338, 0.4399, 0.4446, 0.4533, 0.4594, 0.468 , 0.4681, 0.4617, 0.4571, 0.4535, 0.4471, 0.4426]
dict["sigma3"] = [0.7504, 0.8 , 0.8 , 0.8 , 0.8 , 0.8 , 0.8 , 0.8 , 0.8 , 0.8 , 0.8 , 0.8 , 0.8 , 0.7999, 0.7997, 0.7988, 0.7966, 0.7792, 0.7504, 0.7136, 0.7035, 0.7006, 0.7001, 0.7 , 0.7 , 0.7 ]
dict["sigma2_JP"] = [0.3918, 0.4528, 0.4528, 0.4551, 0.4571, 0.4642, 0.4716, 0.5022, 0.523 , 0.5278, 0.5304, 0.531 , 0.5312, 0.5309, 0.5307, 0.531 , 0.5313, 0.5309, 0.5302, 0.5276, 0.5167, 0.4917, 0.4682, 0.4517, 0.4167, 0.3755]
dict["gamma_JP_IT"] = [2.2306, 1.5817, 1.5817, 1.574 , 1.5544, 1.5502, 1.5391, 1.4804, 1.4094, 1.3682, 1.3241, 1.3071, 1.2931, 1.315 , 1.3514, 1.4051, 1.4402, 1.528 , 1.6523, 1.8872, 2.1348, 3.5752, 3.8646, 3.7292, 2.3763, 1.7679]
dict["gamma_Wn"] = [0.335 , 0.7594, 0.7594, 0.7606, 0.7642, 0.7676, 0.7739, 0.7956, 0.7932, 0.7768, 0.7437, 0.7219, 0.6922, 0.6579, 0.6362, 0.6049, 0.5507, 0.3582, 0.2003, 0.0356, 0. , 0. , 0. , 0. , 0. , 0. ]
dict["phi1_JP"] = [-0.7966, -0.6846, -0.6846, -0.6681, -0.6314, -0.5855, -0.5457, -0.4685, -0.4985, -0.5603, -0.6451, -0.6981, -0.7653, -0.8469, -0.8999, -0.9618, -0.9945, -1.0225, -1.0002, -0.9245, -0.8626, -0.7882, -0.7195, -0.656 , -0.5202, -0.4068]
dict["phi5_JP"] = [0.9488, 0.459 , 0.459 , 0.458 , 0.462 , 0.453 , 0.436 , 0.383 , 0.375 , 0.377 , 0.379 , 0.38 , 0.384 , 0.393 , 0.408 , 0.462 , 0.524 , 0.658 , 0.78 , 0.96 , 1.11 , 1.291 , 1.387 , 1.433 , 1.46 , 1.464 ]
dict["phi6_JP"] = [800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, 800]
if region == 2:
dict["sigma2"] = dict["sigma2_JP"]
dict["phi1"] = dict["phi1_JP"]
dict["phi5"] = dict["phi5_JP"]
phi6 = phi6_JP
# fmag
term6 = dict["c2"][ip]*(M-6)
term7 = (dict["c2"][ip]-dict["c3"][ip])/dict["c_n"][ip]*np.log(1+np.exp(dict["c_n"][ip]*(dict["c_m"][ip]-M)))
# Distance Scaling and attenuation term
term8 = dict["c4"][ip] * np.log(R_RUP + dict["c5"][ip] * np.cosh(dict["c6"][ip] * max(M-dict["c_HM"][ip],0)))
term9 = (dict["c4_a"][ip] - dict["c4"][ip]) * np.log(np.sqrt(R_RUP**2 + dict["c_RB"][ip]**2))
term10 = (dict["c_g1"][ip] + dict["c_g2"][ip] / (np.cosh(max(M-dict["c_g3"][ip],0)))) * R_RUP
if (region == 2 or region == 4):
if (M>6 and M<6.9):
term10 = dict["gamma_JP_IT"][ip] * term10
if region == 3:
term10 = dict["gamma_Wn"][ip] * term10
# Style of faulting term
term2=(dict["c1_a"][ip] + dict["c1_c"][ip] / np.cosh(2 * max(M-4.5,0))) * F_RV
term3=(dict["c1_b"][ip] + dict["c1_d"][ip] / np.cosh(2 * max(M-4.5,0))) * F_NM
# Ztor term
if F_RV == 1:
E_Ztor = (max(2.704 - 1.226*max(M-5.849,0), 0)) ** 2
else:
E_Ztor = (max(2.673 - 1.136*max(M-4.970,0), 0)) ** 2
if Ztor == 999:
Ztor = E_Ztor
delta_ZTOR = Ztor - E_Ztor
term4 = (dict["c7"][ip] + dict["c7_b"][ip] / np.cosh(2 * max(M-4.5,0))) * delta_ZTOR
# Hanging wall term
term12 = dict["c9"][ip] * HW * np.cos(delta) * (dict["c9_a"][ip] + (1 - dict["c9_a"][ip]) * np.tanh(Rx/dict["c9_b"][ip])) * (1 - np.sqrt(R_JB**2 + Ztor**2) / (R_RUP + 1))
# Basin Depth term
# Z1.0 (m) ~ Vs30 (m/s) relationship
if region != 2: # in California and non-Japan region
z_1 = np.exp(-7.15 / 4 * np.log((Vs30**4 + 570.94**4) / (1360**4 + 570.94**4)))
else:
z_1 = np.exp(-5.23 / 2 * np.log((Vs30**2 + 412.39**2) / (1360**2 + 412.39**2)))
if Z10 ==999:
d_Z1 = 0
else:
d_Z1 = Z10 * 1000 - z_1
# Dip term
term5 = (dict["c11"][ip] + dict["c11_b"][ip] / np.cosh(2 * max(M-4.5,0))) * (np.cos(delta)**2)
# Directivity
term11 = dict["c8"][ip] * max(1 - max(R_RUP-40,0)/30,0) * min(max(M-5.5,0)/0.8,1) * np.exp(-dict["c8_a"][ip] * (M-dict["c8_b"][ip])**2) * d_DPP
term1 = dict["c1"][ip]
ln_yrefij = term1 + term2 + term3 + term4 + term5 + term6 + term7 + term8 + term9 + term10 + term11 + term12
yrefij = np.exp(ln_yrefij)
# Site response
term14 = dict["phi1"][ip] * min(np.log(Vs30/1130),0)
term15 = dict["phi2"][ip] * (np.exp(dict["phi3"][ip]*(min(Vs30,1130)-360)) - np.exp(dict["phi3"][ip] * (1130-360))) * np.log((yrefij + dict["phi4"][ip]) / dict["phi4"][ip])
term16 = dict["phi5"][ip] * (1 - np.exp(-d_Z1 / dict["phi6"][ip]))
Sa = yrefij * np.exp(term14 + term15 + term16)
# Compute standard deviation
Finferred = (FVS30==0) # equal 1 if Vs30 is inferred from geology.
Fmeasured = (FVS30==1) # equal 1 if Vs30 is measured.
NL0 = dict["phi2"][ip] * (np.exp(dict["phi3"][ip] * (min(Vs30,1130)-360)) - np.exp(dict["phi3"][ip] * (1130-360))) * (yrefij / (yrefij + dict["phi4"][ip]))
sigmaNL0 = (dict["sigma1"][ip] + (dict["sigma2"][ip] - dict["sigma1"][ip]) / 1.5 * (min(max(M,5),6.5) - 5)) * np.sqrt((dict["sigma3"][ip] * Finferred + 0.7 * Fmeasured) + (1 + NL0)**2)
tau = dict["tau1"][ip] + (dict["tau2"][ip] - dict["tau1"][ip]) / 1.5 * (min(max(M,5),6.5) - 5)
sigma = np.sqrt((1 + NL0)**2 * tau**2 + sigmaNL0**2)
return Sa, sigma
def gmpe_CY_2014(M, T, Rup, Rjb, Rx, Ztor, delta, lambda0, Z10, Vs30, Fhw, FVS30, region, *d_DPP):
period = [-1, 0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.075, 0.1, 0.12, 0.15, 0.17, 0.2, 0.25, 0.3, 0.4, 0.5, 0.75, 1, 1.5, 2, 3, 4, 5, 7.5, 10]
delta = delta * np.pi / 180.0
frv = (lambda0 >= 30 and lambda0 <= 150) # frv: 1 for lambda between 30 and 150, 0 otherwise
fnm = (lambda0 >= -120 and lambda0 <= -60) # fnm: 1 for lambda between -120 and -60, 0 otherwise
if Fhw == 1:
HW = 1
elif Fhw == 0:
HW = 0
else:
HW = Rx>=0
arg = list(d_DPP)
if len(arg) < 1: # for backward compatibility with prior versions that omit this term
d_DPP = 0 # for median calculatio, d_DPP=0.
if type(T) is not list:
T = [T]
if (len(T) == 1 and T == 1000): # Compute Sa and sigma with pre-defined period
Sa = np.zeros((1,len(period)-2))
sigma = np.zeros((1,len(period)-2))
period1 = period[2:]
for ip in range(2, len(period)): # 3:length(period)
Sa[ip-2],sigma[ip-2] = CY_2014_sub(M, ip, Rup, Rjb, Rx, Ztor, delta, frv, fnm, HW, Z10, Vs30, FVS30,region, d_DPP)
[PGA,sigma_PGA] = CY_2014_sub(M,1,Rup, Rjb, Rx, Ztor, delta, frv, fnm, HW, Z10, Vs30, FVS30,region, d_DPP)
if (Sa[ip-2]<PGA and period1[ip-2]<=0.3):
Sa[ip-2]= PGA
else: # Compute Sa and sigma with user-defined period
Sa = np.zeros((1, len(T)))
sigma = np.zeros((1, len(T)))
period1 = T
for i in range(len(T)):
Ti = T[i]
if len(np.where(abs(np.array(period)-Ti) < 0.0001)[0]) == 0: # The user defined period requires interpolation
T_low = max(np.array(period)[np.array(period) < Ti])
T_high = min(np.array(period)[np.array(period) > Ti])
ip_low = period.index(T_low)
ip_high = period.index(T_high)
Sa_low, sigma_low = CY_2014_sub(M, ip_low, Rup, Rjb, Rx, Ztor, delta, frv, fnm, HW, Z10, Vs30, FVS30, region, d_DPP)
Sa_high, sigma_high = CY_2014_sub(M, ip_high, Rup, Rjb, Rx, Ztor, delta, frv, fnm, HW, Z10, Vs30, FVS30, region, d_DPP)
PGA, sigma_PGA = CY_2014_sub(M,1,Rup, Rjb, Rx, Ztor, delta, frv, fnm, HW, Z10, Vs30, FVS30, region, d_DPP)
x = [np.log(T_low), np.log(T_high)]
Y_sa = [np.log(Sa_low), np.log(Sa_high)]
Y_sigma = [sigma_low, sigma_high]
interpF1 = interp1d(x, Y_sa)
Sa[i] = np.exp(interpF1(np.log(Ti)))
interpF2 = interp1d(x, Y_sigma)
sigma[i] = interpF2(np.log(Ti))
if (Sa[i] < PGA and period1[i] <= 0.3):
Sa[i]= PGA
else:
ip_T = np.where(abs(np.array(period) - Ti) < 0.0001)[0][0]
Sa[i], sigma[i] = CY_2014_sub(M, ip_T, Rup, Rjb, Rx, Ztor, delta, frv, fnm, HW, Z10, Vs30, FVS30, region, d_DPP)
PGA, sigma_PGA = CY_2014_sub(M,1,Rup, Rjb, Rx, Ztor, delta, frv, fnm, HW, Z10, Vs30, FVS30, region, d_DPP)
if (Sa[i]<PGA and period1[i] <= 0.3):
Sa[i] = PGA
return Sa[0][0], sigma[0][0], period1
```
#### File: SHRA_Chapter6_7_9/Chapter 6-7/gmpe_eval.py
```python
import numpy as np
from scipy.stats import norm
from scipy.interpolate import interp1d
from gmpe_bjf97 import gmpe_bjf97
from gmpe_CY_2014 import gmpe_CY_2014
# Master function to call a relevant GMPE and get median Sa and log standard deviation
##############
### Inputs ###
##############
# T IM period of interest
# M rupture magnitude
# rup data structure with rupture parameters
# gmpeFlag =1 for BJF97, =2 for CY14
###############
### Outputs ###
###############
# sa median spectral acceleration, given rup
# sigma log standard deviation, given rup
def gmpe_eval(T, M, rup, gmpeFlag):
if gmpeFlag == 1: # BJF 1997 model
sa, sigma = gmpe_bjf97(M, rup["R"], T, rup["Fault_Type"], rup["Vs30"])
elif gmpeFlag == 2: # CY 2014 model
sa, sigma, _ = gmpe_CY_2014(M, T, rup["R"], rup["R"], rup["R"], rup["Ztor"], rup["delta"], rup["rupLambda"], rup["Z10"], rup["Vs30"], rup["Fhw"], rup["FVS30"], rup["region"])
else:
print('Invalid gmpeFlag')
return sa, sigma
```
#### File: SHRA_Chapter6_7_9/Chapter 6-7/gmpe_prob_bjf97.py
```python
import numpy as np
from scipy.stats import norm
from gmpe_bjf97 import gmpe_bjf97
###################
### Description ###
###################
# The probability of exceeding a given PGA level x, using the BJF GMPE.
##########################
### Inputs and Outputs ###
##########################
# INPUT
#
# x = a vector of amplitudes of interest
# All other inputs are defined in gmpe_bjf97
#
# OUTPUT
#
# p = probabilities of exceeding each x value
def gmpe_prob_bjf97(x, M, R, T, Fault_Type, Vs, *sigmaFactor):
arg = list(sigmaFactor)
sa, sigma = gmpe_bjf97(M, R, T, Fault_Type, Vs)
if len(arg) > 0:
sigmaFactor = max(arg[0], 0.0001) # allows sigmaFactor=0 without an error
sigma = sigma * sigmaFactor
p = 1 - norm.cdf(np.log(x),np.log(sa),sigma)
return p
```
#### File: SHRA_Chapter6_7_9/Chapter 9/fn_HAZUS_loss.py
```python
import numpy as np
import h5py
from scipy.stats import norm
############
### Note ###
############
# These are the "Equivalent PGA Structural Fragility Curves from
# section 5.4.4 of Hazus, not the more precise fragilities based on
# capacity curves. They are similar to the capacity curve results, but not
# equivalent.
#######################
### Input variables ###
#######################
### analysisCase.codeLevel ### flag for code level:
# 1 --> High Code
# 2 --> Moderate Code
# 3 --> Low Code
# 4 --> Pre-Code
### analysisCase.buildingType ### 2- or 3-letter code for construction type. Allowable options:
# W1 Wood, Light Frame (< 5,000 sq. ft.)
# W2 Wood, Commercial and Industrial (> 5,000 sq. ft.)
# S1L Steel Moment Frame
# S1M Steel Moment Frame
# S1H Steel Moment Frame
# S2L Steel Braced Frame
# S2M Steel Braced Frame
# S2H Steel Braced Frame
# S3 Steel Light Frame
# S4L Steel Frame with Cast?in?Place Concrete Shear Walls
# S4M Steel Frame with Cast?in?Place Concrete Shear Walls
# S4H Steel Frame with Cast?in?Place Concrete Shear Walls
# S5L Steel Frame with Unreinforced Masonry Infill Walls
# S5M Steel Frame with Unreinforced Masonry Infill Walls
# S5H Steel Frame with Unreinforced Masonry Infill Walls
# C1L Concrete Moment Frame
# C1M Concrete Moment Frame
# C1H Concrete Moment Frame
# C2L Concrete Shear Walls
# C2M Concrete Shear Walls
# C2H Concrete Shear Walls
# C3L Concrete Frame with Unreinforced Masonry Infill Walls
# C3M Concrete Frame with Unreinforced Masonry Infill Walls
# C3H Concrete Frame with Unreinforced Masonry Infill Walls
# PC1 Precast Concrete Tilt?Up Walls
# PC2L Precast Concrete Frames with Concrete Shear Walls
# PC2M Precast Concrete Frames with Concrete Shear Walls
# PC2H Precast Concrete Frames with Concrete Shear Walls
# RM1L Reinforced Masonry Bearing Walls with Wood or Metal Deck Diaphragms
# RM1M Reinforced Masonry Bearing Walls with Wood or Metal Deck Diaphragms
# RM2L Reinforced Masonry Bearing Walls with Precast Concrete Diaphragms
# RM2M Reinforced Masonry Bearing Walls with Precast Concrete Diaphragms
# RM2H Reinforced Masonry Bearing Walls with Precast Concrete Diaphragms
# URML Unreinforced Masonry Bearing Walls
# URMM Unreinforced Masonry Bearing Walls
# MH Mobile Homes
### analysisCase.occType### 4- or 5-letter code for construction type. Allowable options:
# RES1 Single Family Dwelling
# RES2 Mobile Home
# RES3 Multi Family Dwelling
# RES4 Temporary Lodging
# RES5 Institutional Dormitory
# RES6 Nursing Home
# COM1 Retail Trade
# COM2 Wholesale Trade
# COM3 Personal and Repair Services
# COM4 Professional/Technical/ Business Services
# COM5 Banks/Financial Institutions
# COM6 Hospital
# COM7 Medical Office/Clinic
# COM8 Entertainment & Recreation
# COM9 Theaters
# COM10 Parking
# IND1 Heavy
# IND2 Light
# IND3 Food/Drugs/Chemicals
# IND4 Metals/Minerals Processing
# IND5 High Technology
# IND6 Construction
# AGR1 Agriculture
# REL1 Church/Membership/Organization
# GOV1 General Services
# GOV2 Emergency Response
# EDU1 Schools/Libraries
# EDU2 Colleges/Universities
### pgaVals ### PGA values for which to compute loss ratios
#######################
### Output Variables###
#######################
### lossRatio ### loss ratio (total loss) for each PGA
### caseLabel ### text label describing the analysis case
### structLossRatio ### loss ratio (structural) for each PGA
### nonStructAccLossRatio ### loss ratio (nonstructural acceleration
# sensitive) for each PGA
### nonStructDriftLossRatio ### loss ratio (nonstructural drift
# sensitive) for each PGA
def fn_HAZUS_loss(analysisCase, pgaVals):
# Load data created by import_HAZUS_data.m
# Make sure pgaVals is a list
if isinstance(pgaVals, list) == False:
pgaVals = [pgaVals]
# find index for building type
buildingTypeCode = ['W1', 'W2', 'S1L', 'S1M', 'S1H', 'S2L', 'S2M', 'S2H', 'S3', 'S4L', 'S4M', 'S4H', 'S5L', 'S5M', 'S5H', 'C1L', 'C1M', 'C1H', 'C2L', 'C2M', 'C2H', 'C3L', 'C3M', 'C3H', 'PC1', 'PC2L', 'PC2M', 'PC2H', 'RM1L', 'RM1M', 'RM2L', 'RM2M', 'RM2H', 'URML', 'URMM', 'MH']
idxBldg = buildingTypeCode.index(analysisCase['buildingType'])
# Make sure an appropriate building type was specified
assert ~np.isnan(idxBldg), 'Error with specified building type'
# find index of occupancy type
occCode = ['RES1', 'RES2', 'RES3', 'RES4', 'RES5', 'RES6', 'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9', 'COM10', 'IND1', 'IND2', 'IND3', 'IND4', 'IND5', 'IND6', 'AGR1', 'REL1', 'GOV1', 'GOV2', 'EDU1', 'EDU2']
idxOcc = occCode.index(analysisCase['occType'])
# Make sure an appropriate occupancy type was specified
assert ~np.isnan(idxOcc), 'Error with specified building type'
# Get fragility parameters for the given structure type and code level
hf = h5py.File('hazusData.h5', 'r')
medians = hf.get('medians')
betas = hf.get('betas')
medianDS = medians[analysisCase['codeLevel']].tolist()[idxBldg]
betaDS = betas[analysisCase['codeLevel']].tolist()[idxBldg]
# Make sure an appropriate occupancy type was specified
assert ~np.isnan(medianDS[0]), 'Error, this building type and code level is not allowed'
# Get loss ratio for the given occupancy type
lossStruct = hf.get('lossStruct')[idxOcc]
lossAccNS = hf.get('lossAccNS')[idxOcc]
lossDriftNS = hf.get('lossDriftNS')[idxOcc]
# Damage state exceedance probability per pgaVals
pDsExceed = []
length = len(pgaVals)
for i in range(length):
pDsExceed.append(norm.cdf(np.log(pgaVals[i]), np.log(medianDS), betaDS).tolist())
# Pad with zeros for probability of exceeding DS5 (add another column with zeros), to help with differentiation
# in the next step
pDsExceed = np.c_[pDsExceed, np.zeros(length)]
pDsEqual = np.empty((length, 4))
for i in range(4):
pDsEqual[:, i] = pDsExceed[:, i] - pDsExceed[:, i + 1]
# Compute loss ratios per PGA
structLossRatio = np.sum(pDsEqual * lossStruct, axis=1) / 100
nonStructAccLossRatio = np.sum(pDsEqual * lossAccNS, axis=1) / 100
nonStructDriftLossRatio = np.sum(pDsEqual * lossDriftNS, axis=1) / 100
lossRatio = structLossRatio + nonStructAccLossRatio + nonStructDriftLossRatio
# Make a label for the analysis case
codeLevel = ['High', 'Moderate', 'Low', 'Pre']
caseLabel = analysisCase['buildingType'] + ', ' + analysisCase['occType'] + ', ' + \
codeLevel[analysisCase['codeLevel']] + '-code'
return lossRatio, caseLabel, structLossRatio, nonStructAccLossRatio, nonStructDriftLossRatio
```
|
{
"source": "Jetli10/tf-idf-python",
"score": 3
}
|
#### File: tf-idf-python/src/main_gui.py
```python
import tkinter as tk
import tkinter.filedialog as tkfd
import os
from tkinter.scrolledtext import ScrolledText
from tf_idf import tf_idf
table = tf_idf()
main_window = tk.Tk()
main_window.title("TD-IDF")
main_window.geometry("1250x620")
def open_filedialog():
global folder
folder = tkfd.askdirectory(initialdir=os.path.dirname(__file__) + '/..', )
entry_dir_name.delete(0, tk.END)
entry_dir_name.insert(0, folder)
print(folder)
return 0
def execute():
table = tf_idf()
text_output.delete('1.0', tk.END)
folder_name = folder
num_of_files = len([name for name in os.listdir(folder) if os.path.isfile(os.path.join(folder, name))]) + 1
for x in range(1, num_of_files):
file_name = folder_name + '/' + str(x).zfill(2) + '.txt'
table.add_file(file_name)
top_k = entry_top_k.get()
top_k = int(top_k)
for x in range(1, num_of_files):
target_file = folder_name + '/' + str(x).zfill(2) + '.txt'
var = 'Top ' + str(top_k) + ' of tf-idf in ' + os.path.basename(target_file) + ' : \n'
text_output.insert('end', var)
var = table.get_tf_idf(target_file, top_k)
text_output.insert('end', var)
var = '\n\n'
text_output.insert('end', var)
keyword = entry_keyword.get()
var = 'tf-idf of key word "' + keyword + ' : \n'
text_output.insert('end', var)
var = table.similarities([keyword])
for x in var:
x[0] = os.path.basename(x[0])
text_output.insert('end', var)
return 0
if __name__ == "__main__":
label_dir_name = tk.Label(main_window,
text='TXT Folder name:',
font=('Microsoft YaHei', 12),
width=15,
height=1,
).grid(row=0, column=0)
entry_dir_name = tk.Entry(main_window, width=100)
entry_dir_name.grid(row=0, column=1)
label_keyword = tk.Label(main_window,
text='Searching Keyword:',
font=('Microsoft YaHei', 12),
width=15,
height=1,
).grid(row=2, column=0)
entry_keyword = tk.Entry(main_window, width=100)
entry_keyword.insert(0, '任我行')
entry_keyword.grid(row=2, column=1)
label_top_k = tk.Label(main_window,
text='Top K:',
font=('Microsoft YaHei', 12),
width=15,
height=1,
).grid(row=3, column=0)
entry_top_k = tk.Entry(main_window, width=100)
entry_top_k.insert(0, '20')
entry_top_k.grid(row=3, column=1)
button_execute = tk.Button(main_window, text="Execute", width=15, height=1, command=execute).grid(row=3, column=2)
button_file = tk.Button(main_window, text="Browse", width=15, height=1, command=open_filedialog).grid(row=0,
column=2)
text_output = ScrolledText(main_window, width=135, height=25, undo=True, font=('Microsoft YaHei', 12))
text_output.grid(row=4, column=0, columnspan=4)
text_output.tag_add("start", "1.8", "1.13")
text_output.tag_config("start", background="black", foreground="white")
main_window.mainloop()
```
|
{
"source": "JetLightStudio/Jet-Gest-stock-management",
"score": 2
}
|
#### File: auth_app/views/authViews.py
```python
from django.shortcuts import get_object_or_404
from serverConfig.utils import allowed_groups
from django.http.request import HttpRequest
from rest_framework.decorators import api_view
from rest_framework.response import Response
from django.contrib.auth import authenticate
from rest_framework import status
from rest_framework.authtoken.models import Token
from rest_framework.permissions import IsAuthenticated
from rest_framework.decorators import permission_classes
from auth_app.serializers.userSerializer import UserSerializer
from auth_app.serializers.groupSerializer import GroupSerializer
from auth_app.models.user import User, user_group_many
from auth_app.models.group import AuthGroup
@api_view(['POST'])
def login(request: HttpRequest):
username = request.data.get("username")
password = request.data.get("password")
if not username or not password:
return Response(
{
"status": 0,
"token": "",
},
status=status.HTTP_200_OK
)
user = authenticate(username=username, password=password)
if not user:
return Response(
{
"status": 1,
"token": "",
},
status=status.HTTP_200_OK
)
token, c = Token.objects.get_or_create(user=user)
return Response(
{
"status": 2,
"token": token.key,
},
status=status.HTTP_200_OK
)
@api_view(['GET'])
@permission_classes((IsAuthenticated, ))
def getUser(request: HttpRequest):
serialized = UserSerializer(request.user, context={'request': request})
return Response(serialized.data, status=status.HTTP_200_OK)
@api_view(['GET'])
@permission_classes((IsAuthenticated, ))
@allowed_groups(group_names=["admin"])
def userGet(request: HttpRequest, id):
user = get_object_or_404(User, id=id)
serialized = UserSerializer(user, context={'request': request})
return Response(serialized.data, status=status.HTTP_200_OK)
@api_view(['GET'])
@permission_classes((IsAuthenticated, ))
def userList(request: HttpRequest):
serialized = UserSerializer(User.objects.all(), context={'request': request}, many=True)
return Response(serialized.data, status=status.HTTP_200_OK)
@api_view(['GET'])
@permission_classes((IsAuthenticated, ))
def getGroups(request: HttpRequest):
serialized = GroupSerializer(AuthGroup.objects.all(), many=True, context={'request': request})
return Response(serialized.data, status=status.HTTP_200_OK)
@api_view(['POST'])
@permission_classes((IsAuthenticated, ))
@allowed_groups(group_names=["admin"])
def postUser(request: HttpRequest):
groups = request.data.pop("authGroups", [])
serialised = UserSerializer(data=request.data, context={'request': request})
if serialised.is_valid():
user = serialised.save()
for group in groups:
user_group_many.objects.create(user=user, group_id=group["id"])
return Response(status=status.HTTP_201_CREATED)
print(serialised.error_messages)
return Response(status=status.HTTP_400_BAD_REQUEST)
@api_view(['PUT'])
@permission_classes((IsAuthenticated, ))
@allowed_groups(group_names=["admin"])
def updateUser(request: HttpRequest, id):
user = get_object_or_404(User, id=id)
groups = request.data.pop("authGroups", [])
serialised = UserSerializer(user , data=request.data, context={'request': request}, partial=True)
if serialised.is_valid():
serialised.save()
user_group_many.objects.filter(user=user).delete()
for group in groups:
user_group_many.objects.create(user=user, group_id=group["id"])
return Response(status=status.HTTP_200_OK)
print(serialised.error_messages)
return Response(status=status.HTTP_400_BAD_REQUEST)
```
#### File: gestion/models/client.py
```python
from django.db import models
class Client(models.Model):
name = models.CharField(max_length=60)
lastName = models.CharField(max_length=60)
adress = models.TextField(blank=True)
city = models.CharField(max_length=40)
nMF = models.CharField(max_length=40)
nRC = models.CharField(max_length=40)
nAI = models.CharField(max_length=40)
def __str__(self) -> str:
return "client {} {}".format(self.name, self.lastName)
```
#### File: gestion/models/orderRando.py
```python
from datetime import datetime
from django.db import models
from django.conf import settings
from django.core.validators import MaxValueValidator, MinValueValidator
from django.db.models.signals import post_save
from django.dispatch import receiver
from serverConfig.models.gestionParams import GestionParam
from gestion.models.client import Client
from computedfields.models import ComputedFieldsModel, computed
class OrderRando(ComputedFieldsModel):
seller = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, on_delete=models.CASCADE)
client = models.CharField(max_length=40, blank=False, null=False)
creationDate = models.DateTimeField(default=datetime.now, blank=False)
total = models.FloatField(default=0)
def orderList(self):
from .productRandoOrder import ProductRandoOrder
return ProductRandoOrder.objects.filter(order=self)
def __str__(self):
return "#BONPOUR" + str(self.id).zfill(7)
```
#### File: gestion/models/product.py
```python
from django.core.files import storage
from django.db import models
from gestion.utils import products_path_and_rename
from gestion.models.category import Category
from gestion.models.subCategory import SubCategory
class Product(models.Model):
title = models.CharField(max_length=40, unique=True)
description = models.TextField(default="", blank=True)
creationDate = models.DateField(auto_now_add=True)
image = models.ImageField(upload_to=products_path_and_rename ,blank=True , null=True)
forcePrice = models.BooleanField(default=False)
price = models.FloatField(default=0)
categories = models.ManyToManyField(Category, blank=True, through="ProductCategoriesMany")
subCategories = models.ManyToManyField(SubCategory, blank=True, through="ProductSubCategoriesMany")
def getPrice(self):
from .entries import Entries
if self.forcePrice:
return self.price
else:
entries = Entries.objects.filter(product=self)
sumPrices = 0
count = entries.count()
if count <= 0:
count = 1
for entry in entries:
sumPrices += entry.unitPrice
if sumPrices == 0:
return self.price
else:
return sumPrices / count
def quantity(self):
from .SalesAndBalance import SalesAndBalance
sales, c = SalesAndBalance.objects.get_or_create(chooseProduct=self)
return sales.balance
def salesCount(self):
from .SalesAndBalance import SalesAndBalance
sales, c = SalesAndBalance.objects.get_or_create(chooseProduct=self)
return sales.totalSales
def __str__(self) -> str:
return "{} - {}".format(self.id, self.title)
class ProductCategoriesMany(models.Model):
product = models.ForeignKey(Product, on_delete=models.CASCADE)
category = models.ForeignKey(Category, on_delete=models.CASCADE)
class ProductSubCategoriesMany(models.Model):
product = models.ForeignKey(Product, on_delete=models.CASCADE)
subCategory = models.ForeignKey(SubCategory, on_delete=models.CASCADE)
```
#### File: gestion/serializers/expenseSerializer.py
```python
from rest_framework import serializers
from gestion.models.expenses import Expense
class ExpenseSerializer(serializers.ModelSerializer):
expense = serializers.SerializerMethodField()
class Meta:
model = Expense
fields = ("__all__")
def get_expense(self, obj :Expense):
return obj.getExpense()
```
#### File: gestion/serializers/productRandoOrderSerializer.py
```python
from django.db.models import fields
from rest_framework import serializers
from gestion.models.productRandoOrder import ProductRandoOrder
from gestion.serializers.productSerializer import ProductSerializer
class ProductRandoOrderSerializer(serializers.ModelSerializer):
price = serializers.SerializerMethodField()
product = ProductSerializer()
class Meta:
model = ProductRandoOrder
fields = (
'id',
'quantity',
'price',
'unitPrice',
'product',
)
def get_price(self, obj: ProductRandoOrder):
return obj.price()
```
#### File: server/serverConfig/admin.py
```python
from django.contrib import admin
from .models.gestionParams import GestionParam
@admin.register(GestionParam)
class generalSettingsModelAdmin(admin.ModelAdmin):
def has_add_permission(self, request):
base_has_permission = super(generalSettingsModelAdmin, self).has_add_permission(request)
return base_has_permission and not GestionParam.objects.exists()
```
#### File: server/serverConfig/views.py
```python
from django.http.request import HttpRequest
from rest_framework.response import Response
from rest_framework.decorators import api_view
from rest_framework import status
from serverConfig.models.gestionParams import GestionParam
# Create your views here.
@api_view(['GET'])
def getTva(request: HttpRequest):
tva : GestionParam = GestionParam.objects.first()
return Response({"tva": tva.defaultTva}, status=status.HTTP_200_OK)
```
#### File: server/user_socket/watchers.py
```python
from gestion.models.product import Product
from gestion.models.client import Client
from gestion.models.provider import Provider
from gestion.models.category import Category
from gestion.models.subCategory import SubCategory
from gestion.models.providerOrder import ProviderOrder
from gestion.models.orderData import OrderData
from gestion.models.orderRando import OrderRando
from django.db.models.signals import post_save, post_delete
from django.dispatch import receiver
from channels.layers import get_channel_layer
from asgiref.sync import async_to_sync
@receiver(post_save)
def _post_save_receiver(sender, instance, using, created, **kwargs):
if using == "default":
update(instance)
@receiver(post_delete)
def _post_delete_receiver(sender, instance, using, **kwargs):
if using == "default":
update(instance)
def update(instance):
message = None
if isinstance(instance, Product):
message = 1
elif isinstance(instance, Client):
message = 2
elif isinstance(instance, Provider):
message = 3
elif isinstance(instance, (Category, SubCategory)):
message = 4
elif isinstance(instance, ProviderOrder):
message = 5
elif isinstance(instance, OrderData):
message = 6
elif isinstance(instance, OrderRando):
message = 7
else:
return
channel_layer = get_channel_layer()
async_to_sync(channel_layer.group_send)(
'user_update_group',
{'type': 'update_message', 'update': message}
)
```
|
{
"source": "jetlime/Subtyping_Session_Tool_SourceCode",
"score": 2
}
|
#### File: Subtyping-Checker-Extension/gen/SessionTypeVisitor.py
```python
from antlr4 import *
if __name__ is not None and "." in __name__:
from .SessionTypeParser import SessionTypeParser
else:
from SessionTypeParser import SessionTypeParser
# This class defines a complete generic visitor for a parse tree produced by SessionTypeParser.
class SessionTypeVisitor(ParseTreeVisitor):
# Visit a parse tree produced by SessionTypeParser#start.
def visitStart(self, ctx:SessionTypeParser.StartContext):
return self.visitChildren(ctx)
# Visit a parse tree produced by SessionTypeParser#stype.
def visitStype(self, ctx:SessionTypeParser.StypeContext):
return self.visitChildren(ctx)
# Visit a parse tree produced by SessionTypeParser#sprimetype.
def visitSprimetype(self, ctx:SessionTypeParser.SprimetypeContext):
return self.visitChildren(ctx)
# Visit a parse tree produced by SessionTypeParser#guarded.
def visitGuarded(self, ctx:SessionTypeParser.GuardedContext):
return self.visitChildren(ctx)
del SessionTypeParser
```
#### File: Subtyping-Checker-Extension/view/MainView.py
```python
import tkinter as tk
from controller.Controller import Controller
from utility.ObserverObjects import Observer
from view.WorkingArea import WorkingArea
from view.MenuView import MenuView
import subprocess
import platform
import json
import sys
import os
import tkinter.messagebox as mb
from utility.Location import *
class MainView(Observer):
def __init__(self):
Observer.__init__(self)
self.window = tk.Tk()
self.config = json.load(open("algorithms_config.json"))
self.controller = Controller(self.config)
self.window.protocol("WM_DELETE_WINDOW", self.on_closing)
self.observe("ReloadConfigEvent", self.__on_reload_config)
###Utilities###
self.maxwidth = self.window.winfo_screenwidth()
self.maxheight = self.window.winfo_screenheight()
self.width = int(self.maxwidth * 0.9)
self.height = int(self.maxheight * 0.62)
self.f1 = WorkingArea(self.width, self.height, Location.SUBTYPE, self.controller, self.window, self.config)
self.f2 = WorkingArea(self.width, self.height, Location.SUPERTYPE, self.controller, self.window, self.config)
self.custommenu = MenuView(self.window, self.config)
def create_gui(self):
###Page configuration####
self.window.title("Session Subtyping Tool")
self.window.configure(background='gray')
self.window.minsize(width=self.width, height=self.height)
self.window.config(menu=self.custommenu.menu)
self.custommenu.configure_menu(self.controller)
self.f1.create_frame(tk.LEFT, self.custommenu)
self.f2.create_frame(tk.RIGHT, self.custommenu)
self.window.mainloop()
def on_closing(self):
if platform.system() == "Windows": subprocess.run("rmdir /Q /S tmp", shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
else: subprocess.run("rm -r tmp", shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
self.window.destroy()
def __on_reload_config(self, newconf, alg_name):
if alg_name == "": self.config.append(newconf)
else:
for i, conf in enumerate(self.config):
if conf['alg_name'] == alg_name: self.config[i] = newconf
with open('algorithms_config.json', 'w') as outfile: json.dump(self.config, outfile)
if mb.askyesno("Restart", "Would you like to restart the program to make the modification effective?"):
python = sys.executable
os.execl(python, python, *sys.argv)
```
|
{
"source": "JetMake/bullet",
"score": 3
}
|
#### File: bullet/src/tags.py
```python
import tkinter as tk
import tkinter.font as tkFont
from tkinter import filedialog
import beacon
#==================================
#窗口类=============================
class App:
fpath = "Data-10313214-20220116.txt"
planeType = 0
def __init__(self, root):
#setting title
root.title("航前计划")
#setting window size
width=292
height=276
screenwidth = root.winfo_screenwidth()
screenheight = root.winfo_screenheight()
alignstr = '%dx%d+%d+%d' % (width, height, (screenwidth - width) / 2, (screenheight - height) / 2)
root.geometry(alignstr)
root.resizable(width=False, height=False)
GLabel_647=tk.Label(root)
ft = tkFont.Font(family='Times',size=14)
GLabel_647["font"] = ft
GLabel_647["fg"] = "#333333"
GLabel_647["justify"] = "left"
GLabel_647["text"] = "弹幕姬Data文件位置"
GLabel_647.place(x=20,y=30,width=167,height=30)
GLabel_803=tk.Label(root)
ft = tkFont.Font(family='Times',size=14)
GLabel_803["font"] = ft
GLabel_803["fg"] = "#333333"
GLabel_803["justify"] = "right"
GLabel_803["text"] = "机型"
GLabel_803.place(x=70,y=160,width=70,height=25)
GButton_731=tk.Button(root)
GButton_731["bg"] = "#efefef"
ft = tkFont.Font(family='Times',size=14)
GButton_731["font"] = ft
GButton_731["fg"] = "#000000"
GButton_731["justify"] = "center"
GButton_731["text"] = "C172"
GButton_731.place(x=190,y=110,width=70,height=25)
GButton_731["command"] = self.GButton_731_command
GButton_747=tk.Button(root)
GButton_747["bg"] = "#efefef"
ft = tkFont.Font(family='Times',size=14)
GButton_747["font"] = ft
GButton_747["fg"] = "#000000"
GButton_747["justify"] = "center"
GButton_747["text"] = "A32N"
GButton_747.place(x=190,y=160,width=70,height=25)
GButton_747["command"] = self.GButton_747_command
GButton_937=tk.Button(root)
GButton_937["bg"] = "#efefef"
ft = tkFont.Font(family='Times',size=14)
GButton_937["font"] = ft
GButton_937["fg"] = "#000000"
GButton_937["justify"] = "center"
GButton_937["text"] = "B77W"
GButton_937.place(x=190,y=210,width=70,height=25)
GButton_937["command"] = self.GButton_937_command
GButton_311=tk.Button(root)
GButton_311["bg"] = "#efefef"
ft = tkFont.Font(family='Times',size=14)
GButton_311["font"] = ft
GButton_311["fg"] = "#000000"
GButton_311["justify"] = "center"
GButton_311["text"] = "选择"
GButton_311.place(x=190,y=30,width=70,height=25)
GButton_311["command"] = self.GButton_311_command
GLabel_436=tk.Label(root)
ft = tkFont.Font(family='Times',size=14)
GLabel_436["font"] = ft
GLabel_436["fg"] = "#333333"
GLabel_436["justify"] = "center"
GLabel_436["text"] = self.labletext
GLabel_436.place(x=10,y=70,width=278,height=30)
def CallBeacon(self,type):
print(type)
print("传参前"+self.fpath)
beacon.Test(self.fpath)
def GButton_731_command(self):
self.planeType = 1
print(self.planeType)
self.CallBeacon(self.planeType)
def GButton_747_command(self):
self.planeType = 2
print(self.planeType)
self.CallBeacon(self.planeType)
def GButton_937_command(self):
self.planeType = 3
print(self.planeType)
self.CallBeacon(self.planeType)
def GButton_311_command(self):
print("c")
self.fpath = filedialog.askopenfilename()
self.labletext = "已选择"+ self.fpath
print("调用完文件寻找"+self.labletext)
labletext="例如:Data-10313214-20220116.txt"
#==================================
```
|
{
"source": "jetnew/smawm",
"score": 3
}
|
#### File: jetnew/smawm/generate_dataset.py
```python
from os import mkdir, getcwd
from os.path import join, exists
import h5py
import random
import numpy as np
from pettingzoo.mpe import simple_adversary_v2
from policies import random_policy, spurious_policy, follow_non_goal_landmark_policy, follow_goal_landmark_policy, follow_agent_closest_to_landmark_policy
from tqdm import tqdm
def save_list_dict_h5py(array_dict, fname):
"""Save list of dictionaries containing numpy arrays to h5py file."""
with h5py.File(fname, 'w') as hf:
for i in range(len(array_dict)):
grp = hf.create_group(str(i))
for key in array_dict[i].keys():
grp.create_dataset(key, data=array_dict[i][key])
def generate_dataset(
setting,
data_dir="datasets",
episodes=1000,
episode_length=100,
agents=2,
generate_new=False,
verbose=False):
"""
Generates either the Random, Spurious or Expert dataset.
Args:
setting: str - Either "random", "spurious" or "expert"
data_dir: str - Dataset save folder. Default: "datasets"
episodes: int - Number of rounds in dataset. Default: 1000
episode_length: int - Number of tuples per episode. Default: 1000
agents: int - Number of cooperative agents. Default: 2
seed: int - Random seed
"""
data_dir = join(getcwd(), data_dir, setting)
if exists(data_dir) and not generate_new:
if verbose:
print(f"Dataset {data_dir} exists.")
return
elif not exists(data_dir):
mkdir(data_dir)
if verbose:
print(f"Generating dataset: {data_dir}")
if setting == "random":
adversary = random_policy
agent1 = random_policy
agent2 = random_policy
elif setting == "spurious":
adversary = random_policy
agent1 = spurious_policy()
agent2 = spurious_policy()
elif setting == "expert":
adversary = follow_agent_closest_to_landmark_policy
agent1 = follow_non_goal_landmark_policy
agent2 = follow_goal_landmark_policy
else:
raise Exception(f"Setting '{setting}' not available!")
env = simple_adversary_v2.parallel_env(N=agents, max_cycles=episode_length, continuous_actions=False)
for n in tqdm(range(episodes), disable=not verbose):
obs = env.reset()
s_rollout = []
r_rollout = []
d_rollout = []
a_rollout = []
for i in range(episode_length):
adversary_action = adversary(obs['adversary_0'])
agent1_action = agent1(obs['agent_0'])
agent2_action = agent2(obs['agent_1'])
actions = [adversary_action, agent1_action, agent2_action]
obs, reward, done, _ = env.step({
agent: action for agent, action in (('adversary_0', adversary_action),
('agent_0', agent1_action),
('agent_1', agent2_action))})
s_rollout.append(obs['agent_1'])
r_rollout.append(reward['agent_1'])
d_rollout.append(done['agent_1'])
a_rollout.append(actions)
np.savez(join(data_dir, f'episode_{n}'),
observations=np.array(s_rollout),
rewards=np.array(r_rollout),
actions=np.array(a_rollout),
dones=np.array(d_rollout))
replay_buffer = []
for n in range(episodes):
data = np.load(join(data_dir, f'episode_{n}.npz'), allow_pickle=True)
dataset = {k: np.copy(v).tolist() for k, v in data.items()}
replay_buffer.append({'obs': [], 'action': [], 'next_obs': []})
for i in range(episode_length - 1):
replay_buffer[n]['obs'].append(dataset['observations'][i])
replay_buffer[n]['action'].append(dataset['actions'][i])
replay_buffer[n]['next_obs'].append(dataset['observations'][i + 1])
save_list_dict_h5py(replay_buffer, join(data_dir, "episodes.h5"))
prediction_buffer = []
for n in range(episodes):
data = np.load(join(data_dir, f'episode_{n}.npz'), allow_pickle=True)
dataset = {k: np.copy(v).tolist() for k, v in data.items()}
prediction_buffer.append({**{f'obs_t{t}': [] for t in range(11)},
**{f"action_t{t}": [] for t in range(10)}})
for i in range(episode_length - 10):
for t in range(10):
prediction_buffer[n][f'obs_t{t}'].append(dataset['observations'][t])
prediction_buffer[n][f'action_t{t}'].append(dataset['actions'][t])
prediction_buffer[n]['obs_t10'].append(dataset['observations'][10])
save_list_dict_h5py(prediction_buffer, join(data_dir, "predictions.h5"))
env.close()
if __name__ == "__main__":
generate_dataset(setting="random")
generate_dataset(setting="spurious")
generate_dataset(setting="expert")
```
|
{
"source": "JetNoLi/easymqtt",
"score": 3
}
|
#### File: easymqtt/db_and_broker/pyMongoSetUp.py
```python
import pymongo
from datetime import datetime
from pymongo.errors import CollectionInvalid
from collections import OrderedDict
from schema import switchColSchema
from schema import sensorColSchema
from schema import histColSchema
from schema import deviceColSchema
from schema import archiveColSchema
from schema import liveBroker
global client
global db
def connectDB(connectStr):
"""
Function to connect to the cloud db
:param connectStr: The string obtained from mongoDB for connection. Ensure that your details are contained in this
:type: String
:return: The new MongoClient
:rtype: MongoClient
"""
global client
client = pymongo.MongoClient(connectStr)
return client
def initDefault(client, database):
"""
Initialises the default documents in the database by calling the init functions for each of the collections
:param client: The client object
:type client: MongoClient
:param database: The name of the database you created
:type database: String
:return: Six collections are returned: switchCol, sensorCol, histCol, deviceCol, archiveCol,liveBrokerCol
:rtype: Tuple containing the collections returned
"""
db = client[database]
print("Initialising Database, this may take a while...")
initSwitch(db)
initSensor(db)
initHist(db)
initDevice(db)
initArchive(db)
initBrokerCheck(db)
print("Databases created")
switchCol = db["switchCol"]
sensorCol = db["sensorCol"]
histCol = db["historyCol"]
deviceCol = db["deviceCol"]
archiveCol = db['archiveCol']
liveBrokerCol = db['liveBroker']
return switchCol, sensorCol, histCol, deviceCol, archiveCol,liveBrokerCol
def initDevice(db):
"""
Method that initialises and validates the device collection.
:param db: The database needing to be accessed, which can be obtained using client["<Name of DB>"] or client.db
"""
collection = "deviceCol"
validator = {'$jsonSchema': {'bsonType': 'object', 'properties': {}}}
required = []
for fieldKey in deviceColSchema:
field = deviceColSchema[fieldKey]
props = {'bsonType': field['type']}
min = field.get("minlength")
if type(min) == int:
props["minimum"] = min
if field.get("required") is True: required.append(fieldKey)
validator['$jsonSchema']['properties'][fieldKey] = props
if len(required) > 0:
validator['$jsonSchema']['required'] = required
query = [('collMod', collection),
('validator', validator)]
try:
db.create_collection(collection)
except CollectionInvalid:
pass
command_result = db.command(OrderedDict(query))
print(command_result)
def initSwitch(db):
"""
Method that initialises and validates the switch collection.
:param db: The database needing to be accessed, which can be obtained using client["<Name of DB>"] or client.db
"""
collection = "switchCol"
validator = {'$jsonSchema': {'bsonType': 'object', 'properties': {}}}
required = []
for fieldKey in switchColSchema:
field = switchColSchema[fieldKey]
props = {'bsonType': field['type']}
min = field.get("minlength")
if type(min) == int:
props["minimum"] = min
if field.get("required") is True: required.append(fieldKey)
validator['$jsonSchema']['properties'][fieldKey] = props
if len(required) > 0:
validator['$jsonSchema']['required'] = required
query = [('collMod', collection),
('validator', validator)]
try:
db.create_collection(collection)
except CollectionInvalid:
pass
command_result = db.command(OrderedDict(query))
print(command_result)
def initSensor(db):
"""
Method that initialises and validates the sensor collection.
:param db: The database needing to be accessed, which can be obtained using client["<Name of DB>"] or client.db
"""
collection = "sensorCol"
validator = {'$jsonSchema': {'bsonType': 'object', 'properties': {}}}
required = []
for fieldKey in sensorColSchema:
field = sensorColSchema[fieldKey]
props = {'bsonType': field['type']}
min = field.get("minlength")
if type(min) == int:
props["minimum"] = min
if field.get("required") is True: required.append(fieldKey)
validator['$jsonSchema']['properties'][fieldKey] = props
if len(required) > 0:
validator['$jsonSchema']['required'] = required
query = [('collMod', collection),
('validator', validator)]
try:
db.create_collection(collection)
except CollectionInvalid:
pass
command_result = db.command(OrderedDict(query))
print(command_result)
def initHist(db):
"""
Method that initialises and validates the history collection.
:param db: The database needing to be accessed, which can be obtained using client["<Name of DB>"] or client.db
"""
collection = "historyCol"
validator = {'$jsonSchema': {'bsonType': 'object', 'properties': {}}}
required = []
for fieldKey in histColSchema:
field = histColSchema[fieldKey]
props = {'bsonType': field['type']}
min = field.get("minlength")
if type(min) == int:
props["minimum"] = min
if field.get("required") is True: required.append(fieldKey)
validator['$jsonSchema']['properties'][fieldKey] = props
if len(required) > 0:
validator['$jsonSchema']['required'] = required
query = [('collMod', collection),
('validator', validator)]
try:
db.create_collection(collection)
except CollectionInvalid:
pass
command_result = db.command(OrderedDict(query))
print(command_result)
def initArchive(db):
"""
Method that initialises and validates the archive collection.
:param db: The database needing to be accessed, which can be obtained using client["<Name of DB>"] or client.db
"""
collection = "archiveCol"
validator = {'$jsonSchema': {'bsonType': 'object', 'properties': {}}}
required = []
for fieldKey in archiveColSchema:
field = archiveColSchema[fieldKey]
props = {'bsonType': field['type']}
min = field.get("minlength")
if type(min) == int:
props["minimum"] = min
if field.get("required") is True: required.append(fieldKey)
validator['$jsonSchema']['properties'][fieldKey] = props
if len(required) > 0:
validator['$jsonSchema']['required'] = required
query = [('collMod', collection),
('validator', validator)]
try:
db.create_collection(collection)
except CollectionInvalid:
pass
command_result = db.command(OrderedDict(query))
print(command_result)
def initBrokerCheck(db):
"""
Method that initialises and validates the liveBroker collection.
:param db: The database needing to be accessed, which can be obtained using client["<Name of DB>"] or client.db
"""
collection = "liveBroker"
validator = {'$jsonSchema': {'bsonType': 'object', 'properties': {}}}
required = []
for fieldKey in liveBroker:
field = liveBroker[fieldKey]
props = {'bsonType': field['type']}
min = field.get("minlength")
if type(min) == int:
props["minimum"] = min
if field.get("required") is True: required.append(fieldKey)
validator['$jsonSchema']['properties'][fieldKey] = props
if len(required) > 0:
validator['$jsonSchema']['required'] = required
query = [('collMod', collection),
('validator', validator)]
try:
db.create_collection(collection)
except CollectionInvalid:
pass
command_result = db.command(OrderedDict(query))
print(command_result)
```
#### File: easymqtt/devices/functions.py
```python
def listen(pin, edge, callback):
'''
Triggers an interrupt on the given pin
param pin: pin configured as input which interrupt will be called on
type pin: Pin
param edge: edge which interrupt will be called on. 0 - Falling, 1 - Rising, 10 - either
type edge: string
param callback: function to call when interrupt triggers
type callback: function
'''
edge = int(edge)
#edge = 0 -> trigger on falling edge
if edge == 0:
pin.irq(trigger = Pin.IRQ_FALLING, handler = callback)
#edge = 1 -> trigger on rising edge
elif edge == 1:
pin.irq(trigger = Pin.IRQ_RISING, handler = callback)
#edge = 10 -> trigger on either a rising or falling edge
elif edge == 10:
pin.irq(trigger = Pin.IRQ_FALLING | Pin.IRQ_RISING, handler = callback)
else:
print("Error: Incorrect input paramaters, edge must = 0, 1, 10")
def switch(pin):
'''
toggles the value of the pin
param pin: The pin, which has been configured as an output, to toggle
type pin: Pin
'''
if pin.value():
pin.off()
else:
pin.on()
#schedule device to do function every x amount of milliseconds
#time is in milliseconds
#params is params to pass into function
def timedInterrupt(pinNum, function, time, timerFunction):
'''
Function which creates a timer to schedule tasks
param pinNum: pinNum of the pin to trigger function on
type pinNum: int
param function: Callback function which takes pinNum as param
type function: function
param time: time in milliseconds
type time: string
param timerFunction: timerCB, defualt value
type timerFunction: function
return: timer which stores the instance of Timer
rtype: timer
return: pinNum which was inputted
rtype:int
return: function which was inputted
rtype: function
'''
timer = Timer(-1) #initialize with ID of -1 as in docs
timer.init(mode = Timer.PERIODIC, period = int(time), callback = timerFunction)
return timer, pinNum, function
#end the timer i.e. deinitialize it
def endTimedInterrupt(timer):
'''
End the already existing Timer
param timer: is the Timer instance to end
timer type: Timer
'''
timer.deinit()
timer = None
#handle in main, update IOlist, timerFunction, pins final index stores timer Pin Number
#returns an ADC read of
def ADC(pin):
'''
Reads an analog value from the pin configured for ADC
param pin: pin to read from
pin type: Pin
return: The voltage reading from the pin, note max voltage = 1V
rtype: float
'''
bitRead = pin.read() #0-1024, 10 bit ADC 2^10 -1 = max = 1023, max = 1V
voltage = (bitRead/1023.0) #convert to analog reading
return voltage
def digitalRead(pin):
'''
Read whether the specified pin is a high or low
param pin: pin to read from
pin type: Pin
return: 1 if a High, 0 if low
rtype: int
'''
return pin.value()
#Returns an instance of the SPI class which will be loaded in the main
def SetupSPI(baudRate, CPOL, CPHA):
'''
Setup an instance of the SPI class
param baudRate: baudRate for SPI reading
type baudRate: int
param CPOL: clock polarity in accordance with SPI CPOL
type CPOL: int
param CPHA: clock phase in accordance with SPI CPHA
type CPHA: int
return: an instance of the SPI type, in accordance with paramaters
rtype: SPI
'''
#default pins MISO - GPIO12, MOSI - GPIO13, SCLK - GPIO14
return SPI(1, baudrate = baudRate, polarity = CPOL, phase = CPHA)
def SPIReadValue(byteSize, SPISetup):
'''
Read the given number of bytes from the setup SPI
param byteSize: number of bytes to read
type byteSize: int
param SPISetup: configured instance of SPI class
type SPISetup: SPI
return: Value read by SPI
rtype: string
'''
buffer = bytearray(byteSize) #stores bits read in as they have to be in bytes format
SPISetup.readinto(buffer)
return Utils.formatSPIBytes(buffer)
def SPIRead(baudRate, CPOL, CPHA, byteSize, SPISetup):
'''
Create SPIRead if necessary, write to scheduled SPI pins in pin File
To just read use format (0,0,0, byteSize, SPISetup)
Cannot set SPI from callback, only read from it
param baudRate: baudRate for SPI reading
type baudRate: int
param CPOL: clock polarity in accordance with SPI CPOL
type CPOL: int
param CPHA: clock phase in accordance with SPI CPHA
type CPHA: int
param byteSize: number of bytes to read
type byteSize: int
param SPISetup: configured instance of SPI class
type SPISetup: SPI
return: Value read by SPI
rtype: string
'''
if SPISetup == None:
SPISetup = SetupSPI(baudRate,CPOL,CPHA)
return SPIReadValue(int(byteSize),SPISetup)
```
#### File: easymqtt/tests/subTest.py
```python
import paho.mqtt.client as mqtt
client = mqtt.Client()
client.connect('localhost', 8883)
def on_connect(client, userdata, flags, rc):
print("Connected")
client.subscribe("test")
def on_message(client, userdata, message):
print(message.payload.decode())
client.on_connect = on_connect
client.on_message = on_message
client.loop_forever()
```
#### File: easymqtt/tests/testDevicePub.py
```python
import paho.mqtt.client as mqtt
client = mqtt.Client("test")
client.connect("localhost", 8883)
client.subscribe("test")
def on_message(client, userdata, message):
pass
client.on_message = on_message
client.loop_start()
while True:
client.publish(input("topic: ") , input("message: "))
```
|
{
"source": "Jetoky/discord_bot",
"score": 2
}
|
#### File: Jetoky/discord_bot/bot_test.py
```python
from _pytest.mark.structures import MARK_GEN
import Mafia_and_BR
import pytest
import unittest.mock
import os
@pytest.mark.asyncio
async def test_join_b():
ctx = unittest.mock.Mock()
ctx.author.id = 3
ctx.send = unittest.mock.AsyncMock()
Mafia_and_BR.users_bunker.clear()
await Mafia_and_BR.join_bunker(ctx)
ctx.send.assert_called_with('Вы зарегистрировались на игру. Ваш номер 1')
assert Mafia_and_BR.users_bunker == [3]
await Mafia_and_BR.join_bunker(ctx)
ctx.send.assert_called_with('Вы уже зарегистрированы.')
assert Mafia_and_BR.users_bunker == [3]
@pytest.mark.asyncio
async def test_join_m():
ctx = unittest.mock.Mock()
ctx.author.id = 3
ctx.send = unittest.mock.AsyncMock()
Mafia_and_BR.users_mafia.clear()
await Mafia_and_BR.join_mafia(ctx)
ctx.send.assert_called_with('Вы зарегистрировались на игру. Ваш номер 1')
assert Mafia_and_BR.users_mafia == [3]
await Mafia_and_BR.join_mafia(ctx)
ctx.send.assert_called_with('Вы уже зарегистрированы.')
assert Mafia_and_BR.users_mafia == [3]
@pytest.mark.asyncio
async def test_roles_cl():
ctx = unittest.mock.Mock()
ctx.send = unittest.mock.AsyncMock()
Mafia_and_BR.roles.append(3)
await Mafia_and_BR.roles_clear(ctx)
ctx.send.assert_called_with('Список ролей успешно очищен!')
assert Mafia_and_BR.roles == []
await Mafia_and_BR.roles_clear(ctx)
ctx.send.assert_called_with('Список ролей пуст!')
assert Mafia_and_BR.roles == []
@pytest.mark.asyncio
async def test_add_role():
ctx = unittest.mock.Mock()
ctx.send = unittest.mock.AsyncMock()
name = 'Mafia'
k = '1'
await Mafia_and_BR.add_role(ctx, name, k)
ctx.send.assert_called_with('Роль "Mafia" успешно добавлена!')
assert Mafia_and_BR.roles == ['Mafia']
@pytest.mark.asyncio
async def test_del_role():
ctx = unittest.mock.Mock()
ctx.send = unittest.mock.AsyncMock()
name = "Mirn"
Mafia_and_BR.roles.clear()
Mafia_and_BR.roles.append('Mirn')
await Mafia_and_BR.del_role(ctx, name)
ctx.send.assert_called_with('Роль с именем "Mirn" успешно удалена.')
assert Mafia_and_BR.roles == []
await Mafia_and_BR.del_role(ctx, name)
ctx.send.assert_called_with('Роль с именем "Mirn" не существует.')
assert Mafia_and_BR.roles == []
@pytest.mark.asyncio
async def test_users_bunker_clear():
ctx = unittest.mock.Mock()
ctx.author.id = 3
ctx.send = unittest.mock.AsyncMock()
Mafia_and_BR.users_bunker.append(3)
await Mafia_and_BR.users_bunker_clear(ctx)
ctx.send.assert_called_with('Список игроков в бункер успешно очищен!')
assert Mafia_and_BR.users_bunker == []
await Mafia_and_BR.users_bunker_clear(ctx)
ctx.send.assert_called_with('Список игроков пуст!')
assert Mafia_and_BR.users_bunker == []
@pytest.mark.asyncio
async def test_users_mafia_clear():
ctx = unittest.mock.Mock()
ctx.author.id = 3
ctx.send = unittest.mock.AsyncMock()
Mafia_and_BR.users_mafia.append(3)
await Mafia_and_BR.users_mafia_clear(ctx)
ctx.send.assert_called_with('Список игроков в мафию успешно очищен!')
assert Mafia_and_BR.users_mafia == []
await Mafia_and_BR.users_mafia_clear(ctx)
ctx.send.assert_called_with('Список игроков пуст!')
assert Mafia_and_BR.users_mafia == []
@pytest.mark.asyncio
async def test_bunker_stop():
ctx = unittest.mock.Mock()
ctx.author.id = 3
ctx.send = unittest.mock.AsyncMock()
m = Mafia_and_BR.path
os.makedirs(f"{m}/bunker/")
Mafia_and_BR.users_bunker.append(3)
await Mafia_and_BR.bunker_stop(ctx)
ctx.send.assert_called_with('Список игроков в бункер успешно очищен!')
assert Mafia_and_BR.users_bunker == []
@pytest.mark.asyncio
async def test_mafia_stop():
ctx = unittest.mock.Mock()
ctx.author.id = 3
ctx.send = unittest.mock.AsyncMock()
m = Mafia_and_BR.path
os.makedirs(f"{m}/mafia/")
Mafia_and_BR.users_mafia.append(3)
Mafia_and_BR.roles.append('Doctor')
await Mafia_and_BR.mafia_stop(ctx)
ctx.send.assert_called_with('Игра в мафию успешно завершена!')
assert Mafia_and_BR.users_mafia == [] and Mafia_and_BR.roles == []
@pytest.mark.asyncio
async def test_party_bunker():
ctx = unittest.mock.Mock()
ctx.author.id = 3
ctx.send = unittest.mock.AsyncMock()
Mafia_and_BR.users_bunker.append(3)
await Mafia_and_BR.party_bunker(ctx)
ctx.send.assert_called_with("Список игроков:\n" + "\n".join(
[f"<@{user}>" for user in Mafia_and_BR.users_bunker]))
assert Mafia_and_BR.users_bunker == [3]
@pytest.mark.asyncio
async def test_party_mafia():
ctx = unittest.mock.Mock()
ctx.author.id = 3
ctx.send = unittest.mock.AsyncMock()
Mafia_and_BR.users_mafia.append(3)
await Mafia_and_BR.party_mafia(ctx)
ctx.send.assert_called_with("Список игроков:\n" + "\n".join(
[f"<@{user}>" for user in Mafia_and_BR.users_mafia]))
assert Mafia_and_BR.users_mafia == [3]
```
#### File: Jetoky/discord_bot/file_creator.py
```python
from pathlib import Path
path = f"{Path.cwd()}"
def create():
""" Функция возвращает данные для создания файла, в котором хранится вся необходимая информация для игры "Бункер"
В данной функции создается и изменяется файл BabyFile.txt
"""
import random
s = ("инженер ", "химик ", "строитель", "музыкант", "программист", "поп", "врач", "пожарный", "полицейский",
"МЧСник", "уборщик", "офицант", "администратор", "икасатор", "учитель", "водитель", "космонавт", "электрик",
"ювелир", "артист", "продавец", "инвестор")
z = ("у вас Рахит", "у вас синдром Хрустального человека ", "у вас Булимия", "у вас Шизофриния",
"у вас Делирий", "у вас рак", "у вас Плоскостопие", "у вас Психоз",
"у вас СПИД", "у вас Covid-19", "у вас Гепатит-Б", "у вас Проказа", "у вас Ячмень", "у вас Альцгеймер",
"у вас ",
"у вас Грипп", "у вас Лешай")
p = ("мужской ", "женский ")
t = ("атлетичное", "полное", "худое")
ch = ("экспрессивность", "впечатлительность", "жизнерадостность", "повышенная эмоциональность",
"низкая эмоциональность", "импульсивность", "импрессивность", "неустойчивая эмоциональность",
"целенаправленность", "решительность", "настойчивость", "неуверенность", "смелость", "дисциплинированность",
"самостоятельность", "рассудительность", "глубина и гибкость интеллекта", "находчивость",
"математический склад ума", "легкомысленность", "сообразительность", "любознательность", "вдумчивость",
"жесткость", "доброта",
"отзывчивость")
hu = (
"лыжи", "пилатес", "футбол", "туризм", "компьютерные игры", "йога", "музыка", "готовка", "благотворительность",
"бокс", "оригами", "видеосъемка", "дайвинг", "клининг", "ремонт автомобилей", "чтение", "просмотр фильмов",
"изучение иностранных языков", "шахматы", "шашки", "кроссворды ", "настольные игры", "покер", "кубик рубика",
"блогерство", "программирование ", "разработка сайтов", "пчеловодство", "дрессировка собак", "цветоводство",
"астрология ", "выпечка", "виноделие", "дизайн", "аэрография", "писательская деятельность ", "ведение дневника",
"моделирование", "гончарное дело", "вязание", "шитье", "садоводство", "тикток", "психология", "электрика")
fs = ("Агризоофобия", "Аквафобия", "Акустикофобия", "Барофобия", "Блаттофобия", "Ботанофобия ", "Вагинофобия ",
"Вакцинофобия", "Вермифобия ", "Вомитофобия ", "Гексакосиойгексеконтагексафобия", "Герпетофобия ",
"Дементофобия",
"Зоофобия", "Ипохондрия ", "Криофобия ", "Липофобия ", "Микофобия ", "Музофобия ", "Сеплофобия ",
"Скиофобия ",
"Спидофобия", "Термофобия ", "Уринофобия ", "Фтириофобия ", "Ценофобия ", "Электрофобия ", "Ятрофобия ",
"Скотомафобия ", "Социофобия", "Гумафобия ")
i = ("Коробок спичек", "Солнечная зажигалка", "Нож", "Швейцарский нож", "Кочерга", "Кастрюля", "Горелка", "Аптечка",
"Салфетка", "Активированный Уголь", "Камуфляжный костюм", "Фильтр для воды", "Походное одеяло", "Зубная щетка",
"Туалетная бумага", "Медицинский спирт", "Веревка", "Клубок ниток", "Батон белого хлеба", "5л воды",
"Фрагмент карты", "Компас", "Часы", "Фонарь", "Бензин")
spec1 = ("Изменение/добавление характеристик одному игроку", "Изменение характеристик всем игрокам",
"Изменение катаклизма", "Изменения бункера", "Изменение еды в бункере", "Обмен характеристиками и кража",
"Защита от вылета", "Защита от спец. возможностей")
with open(f"{path}/bunker/BabyFile.txt", "w+") as my_file:
my_file.write("Пол - ")
my_file.write(random.choice(p))
my_file.write(" \nТелосложение - ")
my_file.write(random.choice(t))
my_file.write(" \nЧеловеческая черта - ")
my_file.write(random.choice(ch))
my_file.write(" \nСпециальность - ")
my_file.write(random.choice(s))
my_file.write(" \nЗдоровье - ")
my_file.write(random.choice(z))
my_file.write(" \nХобби / Увлечение - ")
my_file.write(random.choice(hu))
my_file.write(" \nФобия / Страх - ")
my_file.write(random.choice(fs))
my_file.write(" \nИнвентарь - ")
my_file.write(random.choice(i))
my_file.write(" \nСпец. возможность - ")
my_file.write(random.choice(spec1))
```
|
{
"source": "jetoslabs/event-processor",
"score": 3
}
|
#### File: processor/images/agents_helper.py
```python
from typing import Optional
class AgentNames:
AGENT_GATEWAY = "agent_gateway"
AGENT1 = "agent1"
AGENT_B = "agent_b"
AGENT_C = "agent_c"
AGENT_SAVE_TO_DISK = "agent_save_to_disk"
AGENT_TRANSFORMER_COLOR_BGR2GRAY = "agent_transformer_color_bgr2gray"
class AgentTopic:
@staticmethod
def get_agent_input_channel_name(agent_name: str) -> Optional[str]:
if agent_name == "":
return None
return AgentTopic._eval_agent_input_channel_name(agent_name)
@staticmethod
def _eval_agent_input_channel_name(agent_name: str) -> str:
input_channel_name = f"{agent_name.lower()}-input-topic"
return input_channel_name
```
#### File: processor/images/commands_helper.py
```python
from time import sleep
from typing import Any, Optional
import cv2 as cv
from loguru import logger
from numpy import ndarray
def video_capture(src: int = 0) -> Optional[ndarray]:
cap: cv.VideoCapture = cv.VideoCapture(src)
try:
sleep(0.1) # to get clear frame
ret, frame = cap.read()
if ret is True:
return frame
logger.bind().debug("capture_frame was not successful")
return None
except Exception as e:
logger.bind().error(f"Error in capture_frame:\n {e}")
finally:
if cap is not None:
cap.release()
```
#### File: processor/images/opencv_helper.py
```python
import cv2 as cv
import numpy
import numpy as np
import base64
from loguru import logger
class OpencvHelper:
@staticmethod
def ndarray_to_list(frame: np.ndarray) -> list:
im_list: list = frame.tolist()
return im_list
@staticmethod
def list_to_ndarray(im_list) -> np.ndarray:
frame = numpy.array(im_list, dtype='uint8')
return frame
# def opencv_to_bytes(frame: np.ndarray):
# # flatten multi-dim array (but still a ndarray type)
# ret, buffer = cv.imencode('.png', frame)
# # encode to bytes
# frame_ser = buffer.tobytes()
# return frame_ser
# def bytes_to_opencv(data_encode):
# # get flat ndarray from frame serialized to bytes
# image_array = np.asarray(bytearray(data_encode), dtype='uint8')
# # get multi-dim ndarray (original opencv frame format)
# frame_de = cv.imdecode(image_array, cv.IMREAD_COLOR)
# return frame_de
# def opencv_to_base64(frame: np.ndarray) -> str:
# ret, im_arr = cv.imencode('.png', frame)
# im_b64 = im_arr.tostring()
# print(f"type of im_64: {type(im_b64)}")
# # im_bytes = im_arr.tobytes()
# # im_b64 = base64.b64encode(im_bytes)
# # write_to_file("cv_to_b64", im_b64)
# logger.bind().info(f"type of im_b64: {type(im_b64)}")
# return im_b64
# # def base64_to_opencv(im_b64: bytes) -> np.ndarray:
# def base64_to_opencv(im_b64: str) -> np.ndarray:
# logger.bind().info(f"type of im_b64: {type(im_b64)}")
# # write_to_file("b64_to_cv", im_b64)
# # im_bytes = base64.b64decode(im_b64)
# # im_arr = np.frombuffer(im_bytes, dtype=np.uint8) # im_arr is one-dim Numpy array
# im_arr = np.fromstring(im_b64, np.uint8)
# frame = cv.imdecode(im_arr, flags=cv.IMREAD_COLOR)
# return frame
#
def write_to_file(file: str, data: bytes):
with open(file, "wb") as binary_file:
binary_file.write(data)
```
#### File: tests/core/test_logs.py
```python
import pytest
from processor.core.log import generate_trace_id
# @pytest.mark.asyncio
# async def test_generate_trace_id():
# trace_id = await generate_trace_id()
# print(f"trace_id: {trace_id}")
# assert trace_id is not None
```
|
{
"source": "jetoslabs/o365-manager",
"score": 2
}
|
#### File: app/api/deps.py
```python
import json
from typing import Generator
from fastapi import HTTPException
from fastapi.responses import Response
from app.core.auth import get_confidential_client_application, get_access_token
from app.core.config import configuration, AzureAuth
from app.db.db_session import get_tenant_db_engine, get_db_session
def assert_tenant(tenant: str) -> bool:
tenant_config = configuration.tenant_configurations.get(tenant)
if tenant_config is None:
raise HTTPException(status_code=401)
return True
def get_token(tenant: str):
# config_dict = json.load(open('../configuration/ms_auth_configs.json'))[tenant]
# config = MsAuthConfig(**config_dict)
# client_app = get_confidential_client_application(config)
tenant_azure_auth: AzureAuth = configuration.tenant_configurations.get(tenant).azure_auth
client_app = get_confidential_client_application(tenant_azure_auth)
token = get_access_token(tenant_azure_auth, client_app)
return token
def get_tenant_fit_db(tenant: str) -> Generator:
try:
session_local = get_db_session(
get_tenant_db_engine(
tenant,
configuration.tenant_configurations.get(tenant).db.db_fit_name
)
)
db = session_local()
yield db
finally:
db.close()
def get_tenant_sales97_db(tenant: str) -> Generator:
try:
session_local = get_db_session(
get_tenant_db_engine(
tenant,
configuration.tenant_configurations.get(tenant).db.db_sales97_name
)
)
db = session_local()
yield db
finally:
db.close()
def get_tenant_mailstore_db(tenant: str) -> Generator:
try:
session_local = get_db_session(
get_tenant_db_engine(
tenant,
configuration.tenant_configurations.get(tenant).db.db_mailstore_name
)
)
db = session_local()
yield db
finally:
db.close()
# def get_db() -> Generator:
# try:
# db = SessionLocal()
# yield db
# finally:
# db.close()
#
#
# def get_sales97_db() -> Generator:
# try:
# session_local = get_db_session(get_db_engine(global_config.db_sales97_name))
# db = session_local()
# yield db
# finally:
# db.close()
#
#
# def get_fit_db() -> Generator:
# try:
# session_local = get_db_session(get_db_engine(global_config.db_fit_name))
# db = session_local()
# yield db
# finally:
# db.close()
#
#
# def get_mailstore_db() -> Generator:
# try:
# session_local = get_db_session(get_db_engine(global_config.db_mailstore_name))
# db = session_local()
# yield db
# finally:
# db.close()
```
#### File: app/controllers/user.py
```python
from typing import Any, Optional, List
from loguru import logger
from sqlalchemy.orm import Session
from app.apiclients.api_client import ApiClient
from app.apiclients.endpoint_ms import MsEndpointsHelper, endpoints_ms, MsEndpointHelper
from app.crud.stored_procedures import StoredProcedures
from app.schemas.schema_ms_graph import UsersSchema, UserSchema, UserResponseSchema
from app.schemas.schema_sp import EmailTrackerGetEmailIDSchema
class UserController:
@staticmethod
async def get_users(token: Any, top: int, select: str, filter: str) -> Optional[UsersSchema]:
# ms graph api - https://docs.microsoft.com/en-us/graph/api/user-list?view=graph-rest-1.0&tabs=http
endpoint = MsEndpointsHelper.get_endpoint("user:list", endpoints_ms)
if top >= 0 or top <= 1000: endpoint.optional_query_params.top = top
endpoint.optional_query_params.select = select
endpoint.optional_query_params.filter = filter
# We can get url from endpoint as is. This is because this endpoint url is simple get
url = MsEndpointHelper.form_url(endpoint)
response, data = await ApiClient('get', url, headers=ApiClient.get_headers(token)).retryable_call()
if data is None: return None
users = UsersSchema(**data)
return users
@staticmethod
async def get_user(token: Any, user_id: str) -> Optional[UserResponseSchema]:
# ms graph api - https://docs.microsoft.com/en-us/graph/api/user-get?view=graph-rest-1.0&tabs=http
endpoint = MsEndpointsHelper.get_endpoint("user:get", endpoints_ms)
# update the endpoint request_params
endpoint.request_params["user_id"] = user_id
url = MsEndpointHelper.form_url(endpoint)
response, data = await ApiClient('get', url, headers=ApiClient.get_headers(token)).retryable_call()
return UserResponseSchema(**data)# if type(data) == 'dict' else None
@staticmethod
async def get_user_by_email(token: Any, user_email: str, select: str) -> Optional[UserSchema]:
endpoint = MsEndpointsHelper.get_endpoint("user:list", endpoints_ms)
endpoint.optional_query_params.top = 5
endpoint.optional_query_params.select = select
# endpoint.optional_query_params.filter = f"mail eq '{user_email}'"
endpoint.optional_query_params.filter = f"mail in ('{user_email}') or proxyAddresses/any(x:x eq 'smtp:{user_email}')"
url = MsEndpointHelper.form_url(endpoint)
response, data = await ApiClient('get', url, headers=ApiClient.get_headers(token)).retryable_call()
if data is None or "value" not in data or len(data["value"]) == 0:
logger.bind(user_email=user_email, data=data).debug("Empty response for user list from msgraph")
return None
users = UsersSchema(**data)
try:
return users.value[0]
except Exception as e:
logger.bind().error(e)
@staticmethod
async def get_users_to_track(
token: Any,
db_sales97: Session,
) -> List[UserSchema]:
# get list of trackable users
users_to_track: List[EmailTrackerGetEmailIDSchema] = \
await StoredProcedures.dhruv_EmailTrackerGetEmailID(db_sales97)
# get user ids for those email ids
users: List[UserSchema] = []
for user_to_track in users_to_track:
user = await UserController.get_user_by_email(token, user_to_track.EMailId, "")
if user is None:
logger.bind(user_to_track=user_to_track).error("Cannot find in Azure")
else:
logger.bind(user_to_track=user_to_track).debug("Found in Azure")
users.append(user)
return users
```
#### File: app/core/log.py
```python
import sys
import uuid
from loguru import logger
from app.core.settings import settings
def setup_logger():
logger.bind().info("Setting up logger")
logger.remove()
# prod mode
if settings.LOG_SERIALIZE:
logger.add(sys.stderr,
level=settings.LOG_LEVEL,
colorize=True,
serialize=settings.LOG_SERIALIZE)
# dev mode
else:
logger.add(sys.stderr,
level=settings.LOG_LEVEL,
format="<green>{time:YYYY-MM-DD at HH:mm:ss}</green> | <level>{level}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{extra}</level> - <yellow>{message}</yellow>",
colorize=True,
serialize=settings.LOG_SERIALIZE)
# setup_logger()
async def generate_trace_id() -> uuid.UUID:
# This function (uuid4) guarantees the random no. and doesn’t compromise with privacy.
trace_id: uuid.UUID = uuid.uuid4()
return trace_id
```
#### File: app/core/try_catch_final.py
```python
from typing import Optional, Union
from pydantic import BaseModel
def try_catch_final(
try_func: (),
catch_func: () = None,
final_func: () = None,
*,
try_args: Union[Optional[BaseModel], dict] = None,
catch_args: Union[Optional[BaseModel], dict] = None,
final_args: Union[Optional[BaseModel], dict] = None
):
try:
return try_func(try_args) if try_args else try_func()
except Exception as e:
if catch_func:
catch_func(catch_args) if catch_args else catch_func()
finally:
if final_func:
if 'e' in locals():
if final_args is None:
final_args = {"error": e}
elif type(final_args) == dict:
final_args["error"] = e
f = final_func(final_args) if final_args else final_func()
return f
```
#### File: app/app/scheduler.py
```python
import asyncio
import time
from app.apiclients.api_client import ApiClient
async def call_save_message_and_attachment():
print("Start call_save_message_and_attachment")
api = ApiClient(
method='get',
url="http://localhost:8050/v1/messagesAndAttachments/save?tenant=rbrgroup&top=500&filter=receivedDateTime%20gt%202022-04-11T01%3A00%3A00Z",
timeout_sec=3600,
)
await api.retryable_call()
print("End call_save_message_and_attachment")
async def scheduler(repeat_secs):
while True:
await call_save_message_and_attachment()
time.sleep(repeat_secs)
async def main(repeat_secs):
await scheduler(repeat_secs)
if __name__ == "__main__":
asyncio.run(main(repeat_secs=3600))
```
#### File: app/tests/conftest.py
```python
from typing import Generator
import pytest
from app.db.base_class import Base
from app.db.db_session import engine, SessionLocal
@pytest.fixture(scope="session")
def db() -> Generator:
db = SessionLocal()
Base.metadata.create_all(engine)
yield db
```
#### File: tests/crud/test_crud_correspondence_id.py
```python
from sqlalchemy.orm import Session
from app.crud.crud_correspondence_id import CRUDCorrespondenceId
from app.models import CorrespondenceId as CorrespondenceIdModel
from app.schemas.schema_db import CorrespondenceIdCreate as CorrespondenceIdCreateSchema
def test_create_record(db: Session):
message_id = "okokok"
correspondence_id_create_schema = CorrespondenceIdCreateSchema(message_id=message_id)
created = CRUDCorrespondenceId(CorrespondenceIdModel).create(db, obj_in=correspondence_id_create_schema)
assert created.id != 0 and created.message_id == message_id
```
|
{
"source": "jetoslabs/system-monitor",
"score": 2
}
|
#### File: api_v1/endpoints/twitter.py
```python
from fastapi import APIRouter
from client.controllers.twitter import Twitter
from client.schemas.schema_twitter import TweetReqSchema
router = APIRouter()
@router.post("/tweet")
async def tweet(tweet: TweetReqSchema):
data = Twitter.create_tweet(tweet)
return data
```
|
{
"source": "JetpackYoshi/PySignalBuilder",
"score": 3
}
|
#### File: PySignalBuilder/SignalBuilder/builder.py
```python
from SignalBuilder.functions import *
import numpy as np
class Node:
_time = None
_left = None
_right = None
_nType = 'normal'
def __init__(self, time=None, left_piece=None, right_piece=None, nType='normal'):
if left_piece is not None:
self.setLeft(left_piece)
else:
self._left = None
if right_piece is not None:
self.setRight(right_piece)
else:
self._right = None
self.nType = nType
self.time = time
@property
def time(self):
return self._time
@time.setter
def time(self, time):
self._time = time
@property
def nType(self):
return self._nType
@nType.setter
def nType(self, nType):
self._nType = nType
@property
def left(self):
return self._left
@left.setter
def left(self, left_piece):
self._left = left_piece
if self._left is not None:
assert type(left_piece) is Piece, "Invalid Type. Must be object of type 'Piece'"
self._left._end = self
@property
def right(self):
return self._right
@right.setter
def right(self, right_piece):
self._right = right_piece
if self._right is not None:
assert type(right_piece) is Piece, "Invalid Type. Must be object of type 'Piece'"
self._right._start = self
class Piece:
_fType = 'constant'
_start = None
_end = None
def __init__(self, start_node=None, end_node=None, fType='constant'):
self._funcs = {
'constant': Constant(),
'ramp': Ramp(),
'sinusoid': Sinusoid(),
'square': Square()
}
self.fType = fType
self.start = start_node
self.end = end_node
def addFunc(self, key, func):
self._funcs[key] = func
def getFunc(self, fType=None):
if fType is not None:
return self._funcs[fType]
else:
return self._funcs[self._fType]
@property
def func(self):
return self._funcs[self._fType]
@property
def fType(self):
return self._fType
@fType.setter
def fType(self, fType):
self._fType = fType
@property
def start(self):
return self._startNode
@start.setter
def start(self, start_node):
self._startNode = start_node
if self._startNode is not None:
assert type(start_node) is Node, "Invalid Type. Must be object of type 'Node'"
self._startNode._right = self
@property
def end(self):
return self._endNode
@end.setter
def end(self, end_node):
self._endNode = end_node
if self._endNode is not None:
assert type(end_node) is Node, "Invalid Type. Must be object of type 'Node'"
self._endNode._left = self
def valid(self, x):
return (x >= self._startNode.time) & (x <= self._endNode.time)
class SignalBuilder:
_startNode = Node(nType='start')
_endNode = Node(nType='end')
_nodes = [_startNode, _endNode]
_pieces = [Piece(_startNode, _endNode)]
_sampleFrequency = None
def __init__(self):
pass
@property
def sampleFrequency(self):
return self._sampleFrequency
@sampleFrequency.setter
def sampleFrequency(self, frequency):
self._sampleFrequency = frequency
@property
def signalStart(self):
return self._startNode.time
@signalStart.setter
def signalStart(self, t):
# assert t < self._nodes[1].time(), "Invalid Time"
self.setNodeTime(0, t)
@property
def signalEnd(self):
return self._endNode.time
@signalEnd.setter
def signalEnd(self, t):
# assert t > self._nodes[-2].time(), "Invalid Time"
self.setNodeTime(len(self._nodes) - 1, t)
def setNodeTime(self, index, t):
myNode = self._nodes[index]
left = None
right = None
for node in self._nodes[:index][::-1]:
if node.time is not None:
left = node
for node in self._nodes[index + 1:]:
if node.time is not None:
right = node
if left is not None:
assert t > left.time, "Invalid Time"
if right is not None:
assert t < right.time, "Invalid Time"
myNode.time = t
@property
def nodes(self):
return self._nodes
@property
def pieces(self):
return self._pieces
def insertNode(self, index, t=None):
assert 0 < index < len(self._nodes), "Invalid Node Index"
newNode = Node(time=t)
newPiece = Piece()
newPiece.start = newNode
self._nodes.insert(index, newNode)
self._pieces.insert(index, newPiece)
self._pieces[index - 1].end = newNode
newPiece.end = self._nodes[index + 1]
def deleteNode(self, index, right=True):
assert index != 0 and index != len(self._nodes)-1, "Cannot Delete Start or End Node"
delNode = self._nodes[index]
if right:
delPiece = delNode.right
oldPiece = delNode.left
oldNode = delPiece.end
# Link together remaining unlinked node and piece
oldPiece.end = oldNode
else:
delPiece = delNode.left
oldPiece = delNode.right
oldNode = delPiece.start
# Link together remaining unlinked node and piece
oldPiece.start = oldNode
self._nodes.remove(delNode)
self._pieces.remove(delPiece)
def trace(self, report=False):
obj = self._startNode
trace = []
while 1:
if type(obj) is Node:
trace.append(obj)
if obj.nType is 'end':
break
obj = obj.right
if type(obj) is Piece:
trace.append(obj)
obj = obj.end
return trace
def checkNodeTimes(self, verbose=False):
invalid = []
for item in self.trace():
if type(item) is Node:
if item.time is None:
invalid.append(item)
return invalid
def report(self):
for item in self.trace():
if type(item) is Node:
if item.nType is 'start':
print("Start Node:")
elif item.nType is 'end':
print("End Node:")
else:
print("Node:")
print(" {}".format(item))
print(" time: {}".format(item.time))
print("----\n")
if type(item) is Piece:
print("Piece:")
print(" {}".format(item))
print(" Type: {}".format(item.fType))
print("----\n")
def genPiecew(self):
num_samples = (self._endNode.time - self._startNode.time) * self._sampleFrequency
t = np.linspace(self._startNode.time, self._endNode.time, num=num_samples)
condlist = [piece.valid(t) for piece in self._pieces]
funclist = [piece.getFunc().exec_ for piece in self._pieces]
node_locations = [node.time for node in self._nodes]
return t, np.piecewise(t, condlist, funclist), node_locations
def chainConfig(self, start_node):
obj = start_node
nodes = []
pieces = []
while 1:
if type(obj) is Node:
nodes.append(obj)
if obj.nType is 'end':
break
obj = obj.right()
if type(obj) is Piece:
pieces.append(obj)
obj = obj.getEnd()
self._nodes = nodes
self._pieces = pieces
def listConfig(self, nodes, pieces):
pass
```
|
{
"source": "Jetpay/paymentpage-sdk-python",
"score": 3
}
|
#### File: paymentpage-sdk-python/payment_page_sdk/gate.py
```python
from payment_page_sdk.signature_handler import SignatureHandler
from payment_page_sdk.payment_page import PaymentPage
from payment_page_sdk.callback import Callback
from payment_page_sdk.payment import Payment
class Gate(object):
"""Class Gate
Attributes:
CURRENCY_RUB - Currency RUB
CURRENCY_USD - Currency USD
CURRENCY_EUR - Currency EUR
__paymentPageUrlBuilder - Builder for Payment page
__signatureHandler - Signature Handler (check, sign)
"""
CURRENCY_RUB = 'RUB'
CURRENCY_USD = 'USD'
CURRENCY_EUR = 'EUR'
__paymentPageUrlBuilder = None
__signatureHandler = None
def __init__(self, secret: str, base_url: str = ''):
"""
Gate constructor
:param str secret: Secret key
"""
self.__signatureHandler = SignatureHandler(secret)
self.__paymentPageUrlBuilder = PaymentPage(self.__signatureHandler, base_url)
def get_purchase_payment_page_url(self, payment: Payment) -> str:
"""
Get URL for purchase payment page
:param Payment payment:
:return:
"""
return self.__paymentPageUrlBuilder.get_url(payment)
def handle_callback(self, data):
"""
Callback handler
:param data:
:return:
"""
return Callback(data, self.__signatureHandler)
```
#### File: paymentpage-sdk-python/tests/test_callback.py
```python
from payment_page_sdk.signature_handler import SignatureHandler
from payment_page_sdk.callback import Callback
from payment_page_sdk.process_exception import ProcessException
import json
import unittest
class CallbackTest(unittest.TestCase):
secret = 'qwerty'
payment_data =\
{
"payment":
{
"id": "test-payment",
"status": "success"
},
"signature": "UGzKT0NC26f4u0niyJSQPx5q3kFFIndwLXeJVXahfCFwbY+Svg1WoXIxzrIyyjWUSLFhT8wAQ5SfBDRHnwm6Yg=="
}
payment_data_recursive =\
{
"body": {
"payment":
{
"id": "test-payment",
"status": "success"
},
"signature": "UGzKT0NC26f4u0niyJSQPx5q3kFFIndwLXeJVXahfCFwbY+Svg1WoXIxzrIyyjWUSLFhT8wAQ5SfBDRHnwm6Yg=="
}
}
payment_data_invalid_signature =\
{
"payment":
{
"id": "test-payment"
},
"signature": "UGzKT0NC26f4u0niyJSQPx5q3kFFIndwLXeJVXahfCFwbYg34h32gh3"
}
payment_data_without_sign =\
{
"payment":
{
"id": "test-payment"
}
}
cb_data_without_payment =\
{
"project_id": "123",
"recurring":
{
"id": 321,
"status": "active",
"type": "Y",
"currency": "EUR",
"exp_year": "2025",
"exp_month": "12",
"period": "D",
"time": "11",
},
"signature": "AThqkBCZ6WZtY3WrMV28o7SM/vq6OIVF9qiVbELN4e/Ux59Lb5LFFnEuTq6bHa5pRvaPIkQGABXdpIrNLaeJdQ=="
}
@classmethod
def setUp(cls):
signature_handler = SignatureHandler(cls.secret)
payment_data_raw = json.dumps(cls.payment_data)
cls.callback = Callback(payment_data_raw, signature_handler)
def test_get_payment(self):
self.assertEqual(self.callback.get_payment(), self.payment_data['payment'])
def test_get_payment_status(self):
self.assertEqual(self.callback.get_payment_status(), self.payment_data['payment']['status'])
def test_get_payment_id(self):
self.assertEqual(self.callback.get_payment_id(), self.payment_data['payment']['id'])
def test_get_signature(self):
self.assertEqual(self.callback.get_signature(), self.payment_data['signature'])
def test_decode_response(self):
with self.assertRaises(ProcessException):
self.callback.decode_response(json.dumps(self.payment_data)+'1')
def test_recursive_get(self):
with self.assertRaises(ProcessException):
Callback(json.dumps(self.payment_data_recursive), SignatureHandler(self.secret))
def test_invalid_signature(self):
with self.assertRaises(ProcessException):
signature_handler = SignatureHandler(self.secret)
payment_data_raw = json.dumps(self.payment_data_invalid_signature)
Callback(payment_data_raw, signature_handler)
def test_get_null_param(self):
signature_handler = SignatureHandler(self.secret)
payment_data_raw = json.dumps(self.cb_data_without_payment)
callback = Callback(payment_data_raw, signature_handler)
self.assertEqual(callback.get_payment_status(), None)
def test_undefined_sign(self):
with self.assertRaises(ProcessException):
signature_handler = SignatureHandler(self.secret)
payment_data_raw = json.dumps(self.payment_data_without_sign)
Callback(payment_data_raw, signature_handler)
```
|
{
"source": "jetperch/fitterbap",
"score": 2
}
|
#### File: comm/ui/resync.py
```python
import logging
from PySide6 import QtCore, QtGui, QtWidgets
from queue import Queue, Empty
log = logging.getLogger(__name__)
class _ResyncEvent(QtCore.QEvent):
"""An event containing a request for a resync function call."""
EVENT_TYPE = QtCore.QEvent.Type(QtCore.QEvent.registerEventType())
def __init__(self):
QtCore.QEvent.__init__(self, self.EVENT_TYPE)
def __str__(self):
return '_ResyncEvent()'
def __len__(self):
return 0
class Resync(QtCore.QObject):
"""Resynchronize to the Qt event thread.
:param parent: The parent QObject.
Qt does not easily support resynchronization from non-Qt threads. See
this [bug report](https://github.com/jetperch/pyjoulescope_ui/issues/69).
This class implements a resynchronization service that allows a non-Qt
thread to invoke a method on the main Qt event thread.
See [this page](https://doc.qt.io/qt-5/threads-qobject.html) for a
Qt threading overview.
"""
def __init__(self, parent=None):
super(Resync, self).__init__(parent)
self._resync_handlers = {}
self._resync_queue = Queue()
def event(self, event: QtCore.QEvent):
if event.type() == _ResyncEvent.EVENT_TYPE:
# process our resync calls.
event.accept()
try:
fn, args, kwargs, ev = self._resync_queue.get(timeout=0.0)
if id(event) != id(ev):
log.warning('event mismatch')
fn(*args, **kwargs)
except Empty:
log.warning('event signaled but not available')
except Exception:
log.exception('resync queue failed')
return True
else:
return super(Resync, self).event(event)
def _resync_handle(self, name, args, kwargs):
# safely resynchronize to the main Qt event thread
event = _ResyncEvent()
self._resync_queue.put((name, args, kwargs, event))
QtCore.QCoreApplication.postEvent(self, event)
def clear(self, target=None):
"""Clear handlers.
:param target: The target provided to :meth:`factory`. If None,
then clear all targets.
"""
if target is not None:
key = id(target)
self._resync_handlers.pop(key)
else:
self._resync_handlers.clear()
def wrap(self, target):
"""Get a function that will call target from the main Qt event loop.
:param target: The target callable(args, kwargs). This instance will
hold a reference to target.
:return: The resynchronization function that invokes target from the
main thread's Qt event loop. Calls to this function
complete immediately, but the actual processing is deferred.
"""
def fn(*args, **kwargs):
return self._resync_handle(target, args, kwargs)
key = id(target)
if key not in self._resync_handlers:
self._resync_handlers[key] = fn
return self._resync_handlers[key]
```
#### File: comm/ui/vertical_scroll_area.py
```python
from PySide6 import QtCore, QtGui, QtWidgets
import logging
class VerticalScrollArea(QtWidgets.QScrollArea):
def __init__(self, parent=None):
super(VerticalScrollArea, self).__init__(parent)
self.setWidgetResizable(True)
self.setHorizontalScrollBarPolicy(QtGui.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtGui.Qt.ScrollBarAsNeeded)
self.setSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Preferred)
self._log = logging.getLogger(__name__)
def setWidget(self, widget):
widget.installEventFilter(self)
return super(VerticalScrollArea, self).setWidget(widget)
def eventFilter(self, obj, event):
widget = self.widget()
if obj == widget and event.type() == QtCore.QEvent.Resize:
width = widget.minimumSizeHint().width() + self.verticalScrollBar().width()
self.setMinimumWidth(width)
self._log.debug('scroll: sizeHint=%s, minimumSizeHint=%s, minimumSize=%s',
self.sizeHint(), self.minimumSizeHint(), self.minimumSize())
return False
```
#### File: pyfitterbap/test/test_pubsub.py
```python
import unittest
from pyfitterbap.pubsub import PubSub
class PubSubTest(unittest.TestCase):
def setUp(self):
self.p = PubSub(topic_prefix='hello')
self.sub1 = []
self.sub2 = []
def sub1_fn(self, topic, value, retain=None):
self.sub1.append((topic, value))
def sub2_fn(self, topic, value, retain=None):
self.sub2.append((topic, value))
def test_sub_pub(self):
self.p.subscribe('hello/world', self.sub1_fn)
self.p.publish('hello/world', 'there')
self.assertEqual([('hello/world', 'there')], self.sub1)
def test_pub_sub_not_retained(self):
self.p.publish('hello/world', 'there')
self.p.subscribe('hello/world', self.sub1_fn)
self.assertEqual([], self.sub1)
def test_pub_sub_retained(self): # retained value
self.p.publish('hello/world', 'there', retain=True)
self.p.subscribe('hello/world', self.sub1_fn)
self.assertEqual([('hello/world', 'there')], self.sub1)
def test_retained_dedup(self):
self.p.publish('hello/world', 'there', retain=True)
self.p.subscribe('hello/world', self.sub1_fn)
self.p.publish('hello/world', 'there', retain=True)
self.assertEqual([('hello/world', 'there')], self.sub1)
def test_pub_src(self):
self.p.subscribe('hello/world', self.sub1_fn)
self.p.publish('hello/world', 'there', src_cbk=self.sub1_fn)
self.assertEqual([], self.sub1)
def test_sub_parent(self):
self.p.subscribe('', self.sub1_fn)
self.p.subscribe('hello/there', self.sub2_fn)
self.p.publish('hello/there/world', 'value')
self.assertEqual([('hello/there/world', 'value')], self.sub1)
self.assertEqual([('hello/there/world', 'value')], self.sub1)
def test_unsub(self):
self.p.subscribe('hello/world', self.sub1_fn)
self.p.unsubscribe('hello/world', self.sub1_fn)
self.p.publish('hello/world', 'there')
self.assertEqual([], self.sub1)
def test_get(self):
self.p.publish('hello/world', 'there', retain=True)
self.assertEqual('there', self.p.get('hello/world'))
self.p.publish('hello/world', 'new', retain=True)
self.assertEqual('new', self.p.get('hello/world'))
self.p.publish('hello/world', 'newer') # not retained!
self.assertIsNone(self.p.get('hello/world'))
def test_meta(self):
meta1 = {'type': 'u32'}
self.p.meta('hello/world', meta1)
self.p.subscribe('', self.sub1_fn, forward=True)
self.p.publish('$', None)
self.assertEqual([('hello/world$', meta1), ('$', None)], self.sub1)
def test_meta_other_subscribe_root(self):
self.p.subscribe('', self.sub1_fn, forward=True)
self.p.publish('other/$', None)
self.assertEqual([('other/$', None)], self.sub1)
def test_meta_other_subscribe_subtopic(self):
self.p.subscribe('other', self.sub1_fn, forward=True)
self.p.publish('other/$', None)
self.assertEqual([('other/$', None)], self.sub1)
# def test_query(self): # todo
```
#### File: fitterbap/pyfitterbap/time.py
```python
import dateutil.parser
import datetime
FBP_TIME_EPOCH_UNIX_OFFSET_SECONDS = dateutil.parser.parse('2018-01-01T00:00:00Z').timestamp()
Q_GAIN = 2 ** 30
def now():
k = datetime.datetime.utcnow().timestamp()
rel_s = k - FBP_TIME_EPOCH_UNIX_OFFSET_SECONDS
return int(rel_s * Q_GAIN)
```
|
{
"source": "jetperch/jls",
"score": 2
}
|
#### File: jls/example/annotate_stress.py
```python
from pyjls import Reader, Writer, SourceDef, SignalDef, AnnotationType, DataType, SignalType
import argparse
import logging
import numpy as np
import os
import sys
import time
def parser():
p = argparse.ArgumentParser(description='JLS generator.')
p.add_argument('filename',
help='The output JLS file path')
p.add_argument('--count',
type=int,
default=1000000,
help='The total number of annotations to write')
return p
def run():
args = parser().parse_args()
source = SourceDef(
source_id=1,
name='performance',
vendor='',
model='',
version='',
serial_number='',
)
signal = SignalDef(
signal_id=1,
source_id=1,
signal_type=SignalType.FSR,
data_type=DataType.F32,
sample_rate=1000000,
samples_per_data=100000,
sample_decimate_factor=1000,
entries_per_summary=20000,
summary_decimate_factor=100,
annotation_decimate_factor=100,
utc_decimate_factor=100,
name='current',
units='A',
)
dargs = vars(args)
for key in signal.__dict__.keys():
v = dargs.get(key)
if v is not None:
if key not in ['name', 'units']:
v = int(v)
setattr(signal, key, v)
# Write to file
data = bytes(range(256))
t_start = time.time()
t_finish = time.time()
count = 0
try:
with Writer(args.filename) as wr:
wr.source_def_from_struct(source)
wr.signal_def_from_struct(signal)
wr.user_data(0, 'string user data at start')
for count in range(args.count):
wr.annotation(1, count, AnnotationType.USER, 0, data)
t_finish = time.time()
except Exception:
logging.getLogger().exception('during write')
t_end = time.time()
print(f'{count + 1} annotations: duration={t_end - t_start:.3f} s, close={t_end - t_finish:.3f} s')
if __name__ == "__main__":
sys.exit(run())
```
#### File: jls/example/generate.py
```python
from pyjls import Reader, Writer, SourceDef, SignalDef, AnnotationType, DataType, SignalType
import argparse
import logging
import numpy as np
import os
import sys
def parser():
p = argparse.ArgumentParser(description='JLS generator.')
p.add_argument('filename',
help='The output JLS file path')
p.add_argument('--name', default='current', help='The signal name')
p.add_argument('--units', default='A', help='The signal value units (SI)')
p.add_argument('--sample_rate', type=int, default=1000000, help='The sample rate in Hz.')
p.add_argument('--length', type=int, default=1000000, help='The signal length in samples.')
p.add_argument('--samples_per_data', type=int, default=100000, help='The samples per data chunk.')
p.add_argument('--sample_decimate_factor', type=int, default=1000, help='The samples per summary entry.')
p.add_argument('--entries_per_summary', type=int, default=20000, help='The entries per summary chunk.')
p.add_argument('--summary_decimate_factor', type=int, default=100, help='The summaries per summary entry.')
p.add_argument('--add',
action='append',
help='The waveform definition to add, which is one of:'
'sine,{amplitude},{frequency} '
'ramp'
)
return p
def _waveform_factory(d):
if d is None or not len(d):
return None
parts = d.split(',')
name = parts[0].lower()
if name == 'ramp':
if len(parts) == 1:
return lambda x: x
elif len(parts) == 2:
amplitude = float(parts[1])
return lambda x: x * amplitude
else:
raise ValueError('Invalid ramp specification')
elif name in ['sin', 'sine', 'sinusoid', 'cos', 'cosine', 'freq', 'frequency', 'tone']:
if len(parts) != 3:
raise RuntimeError(f'Must specify {name},amplitude,frequency')
amplitude = float(parts[1])
freq = float(parts[2])
return lambda x: amplitude * np.sin((2.0 * np.pi * freq) * x)
else:
raise RuntimeError(f'Unknown waveform: {name}')
def run():
args = parser().parse_args()
source = SourceDef(
source_id=1,
name='performance',
vendor='',
model='',
version='',
serial_number='',
)
signal = SignalDef(
signal_id=1,
source_id=1,
signal_type=SignalType.FSR,
data_type=DataType.F32,
sample_rate=args.sample_rate,
samples_per_data=args.samples_per_data,
sample_decimate_factor=args.sample_decimate_factor,
entries_per_summary=args.entries_per_summary,
summary_decimate_factor=args.summary_decimate_factor,
annotation_decimate_factor=args.summary_decimate_factor,
utc_decimate_factor=args.summary_decimate_factor,
name=args.name,
units=args.units,
)
dargs = vars(args)
for key in signal.__dict__.keys():
v = dargs.get(key)
if v is not None:
if key not in ['name', 'units']:
v = int(v)
setattr(signal, key, v)
waveforms = []
for waveform_def in args.add:
fn = _waveform_factory(waveform_def)
if fn is not None:
waveforms.append(fn)
# generate waveform, 1 second chunk at a time
x = np.arange(signal.sample_rate, dtype=np.float64) * 1 / signal.sample_rate
# Write to file
y_len = len(x)
sample_id = 0
with Writer(args.filename) as wr:
wr.source_def_from_struct(source)
wr.signal_def_from_struct(signal)
wr.user_data(0, 'string user data at start')
length = args.length
while length > 0: # write data chunks
y = np.zeros(y_len, dtype=np.float64)
for waveform in waveforms:
y += waveform(x)
iter_len = y_len if y_len < length else length
wr.fsr_f32(1, sample_id, y[:iter_len].astype(dtype=np.float32))
sample_id += iter_len
length -= iter_len
x += 1.0 # increment
wr.user_data(42, b'binary data')
wr.user_data(43, {'my': 'data', 'json': [1, 2, 3]})
if __name__ == "__main__":
sys.exit(run())
```
|
{
"source": "jetperch/pyjoulescope_server",
"score": 2
}
|
#### File: pyjoulescope_server/joulescope_server/framer.py
```python
import struct
import json
TAG_AJS = b'AJS' # json payload
TAG_ABN = b'ABN' # binary payload
HEADER_LENGTH = 8 # tag + length
def payload_length_to_pad_length(payload_length):
p = payload_length % 8
if p > 0:
p = 8 - p
return p
def header_pack(tag, length):
if len(tag) != 3:
raise ValueError(f'invalid tag length {len(tag)}')
if not isinstance(tag, bytes):
raise ValueError(f'invalid tag type {type(tag)}')
length = int(length)
if length < 0 or length >= 2**24:
raise ValueError(f'length out of range: {length}')
length_bytes = struct.pack('<I', length)
return tag + b'\x00' + length_bytes
def header_unpack(header):
if len(header) < HEADER_LENGTH:
raise ValueError('header is too short')
tag = header[0:3]
length_bytes = header[4:8]
length = struct.unpack('<I', length_bytes)[0]
return tag, length
def pack(tag, payload):
if not isinstance(payload, bytes):
raise ValueError(f'invalid payload type {type(payload)}')
header_pack(tag, len(payload))
length = len(payload)
length_bytes = struct.pack('<I', len(payload))
pad = payload_length_to_pad_length(length)
pad_bytes = bytes([0] * pad)
return tag + b'\x00' + length_bytes + payload + pad_bytes
def tpack(payload):
if isinstance(payload, dict):
return pack(TAG_AJS, json.dumps(payload).encode('utf-8'))
else:
return pack(TAG_ABN, payload)
def unpack(data):
"""Unpack one message.
:param data: The bytes data to unpack.
:return: (tag, payload, data_remaining).
"""
tag, length = header_unpack(data)
pad = payload_length_to_pad_length(length)
total_length = HEADER_LENGTH + length + pad
if len(data) < total_length:
raise ValueError('insufficient data length')
payload = data[HEADER_LENGTH:(HEADER_LENGTH + length)]
return tag, payload, data[total_length:]
async def receive(reader):
header = await reader.readexactly(HEADER_LENGTH)
tag, length = header_unpack(header)
pad = payload_length_to_pad_length(length)
data = await reader.readexactly(length + pad)
if not pad:
payload = data
else:
payload = data[:-pad]
return tag, payload
def ajs_receive(payload):
return json.loads(payload.decode('utf-8'))
async def treceive(reader):
tag, payload = await receive(reader)
if tag == TAG_AJS:
return ajs_receive(payload)
elif tag == TAG_ABN:
return payload
else:
raise ValueError('unsupported tag: tag=%s, payload=%s' % (tag, payload))
```
#### File: joulescope_server/test/test_framer.py
```python
from joulescope_server import framer
import unittest
class TestFramer(unittest.TestCase):
def test_pad(self):
a = [0, 7, 6, 5, 4, 3, 2, 1, 0, 7, 6, 5, 4, 3, 2, 1, 0, 7, 6, 5, 4, 3, 2, 1, 0]
for length, k in enumerate(a):
self.assertEqual(k, framer.payload_length_to_pad_length(length))
def test_header(self):
tag1, len1 = b'ABN', 8
header = framer.header_pack(tag1, len1)
self.assertEqual(b'ABN\x00\x08\x00\x00\x00', header)
tag2, len2 = framer.header_unpack(header)
self.assertEqual(tag1, tag2)
self.assertEqual(len1, len2)
def test_pack_no_pad(self):
payload = b'12345678'
data = framer.pack(framer.TAG_ABN, b'12345678')
self.assertEqual(b'ABN\x00\x08\x00\x00\x0012345678', data)
tag, length = framer.header_unpack(data)
self.assertEqual(b'ABN', tag)
self.assertEqual(8, len(payload))
def test_pack_with_pad(self):
data = framer.pack(framer.TAG_ABN, b'hello')
self.assertEqual(b'ABN\x00\x05\x00\x00\x00hello\x00\x00\x00', data)
def test_unpack_multiple(self):
d1 = framer.pack(framer.TAG_ABN, b'hello 1')
d2 = framer.pack(framer.TAG_ABN, b'hello there 2')
d = b''.join([d1, d2])
t1, p1, d = framer.unpack(d)
t2, p2, d = framer.unpack(d)
self.assertEqual(t1, framer.TAG_ABN)
self.assertEqual(t2, framer.TAG_ABN)
self.assertEqual(p1, b'hello 1')
self.assertEqual(p2, b'hello there 2')
self.assertEqual(0, len(d))
```
|
{
"source": "jetperch/pyjoulescope_ui",
"score": 2
}
|
#### File: pyjoulescope_ui/joulescope_ui/exporter.py
```python
from joulescope_ui.file_dialog import FileDialog
from joulescope_ui.paths import data_path, data_path_saved_set
from joulescope.data_recorder import DataRecorder, construct_record_filename
import numpy as np
import os
import logging
log = logging.getLogger(__name__)
def _filetype(filename):
if filename is None:
return None
_, filetype = os.path.splitext(filename)
if filetype and filetype[0] == '.':
filetype = filetype[1:]
return filetype
class Exporter:
def __init__(self):
self._filename = None
def run_pre(self, data): # RangeToolInvocation
path = data_path(data.cmdp)
self._filename = self._filename_select(data.parent(), path)
if self._filename is None:
return 'Cancelled'
def run_post(self, data):
data.cmdp.publish('!General/mru_add', self._filename)
data_path_saved_set(data.cmdp, os.path.dirname(self._filename))
def run(self, data): # RangeToolInvocation
registry = {
'bin': self._export_bin,
'csv': self._export_csv,
'jls': self._export_jls,
'raw': self._export_raw,
}
filetype = _filetype(self._filename)
fn = registry.get(filetype)
if fn is None:
return f'Invalid export file type: {filetype}'
rv = fn(data)
if data.is_cancelled:
if os.path.isfile(self._filename):
os.unlink(self._filename)
elif filetype == 'jls':
annofile = self._filename[:-4] + '.anno.jls'
t_min, t_max = data.time_range
data.cmdp.publish('!Widgets/Waveform/annotation/save', [annofile, t_min, t_max])
return rv
def _filename_select(self, parent, path):
filename = construct_record_filename()
filename = os.path.join(path, filename)
filters = [
'Joulescope Data (*.jls)',
'Binary 32-bit float (*.bin)',
'Comma Separated Values (*.csv)',
'Raw 16-bit samples (*.raw)',
]
filter_str = ';;'.join(filters)
dialog = FileDialog(parent, 'Save Joulescope Data', filename, 'any')
dialog.setNameFilter(filter_str)
filename = dialog.exec_()
if bool(filename):
log.info('save filename selected: %s', filename)
filename = str(filename)
else:
filename = None
return filename
def _export_bin(self, data):
with open(self._filename, 'wb') as f:
for block in data:
current = block['signals']['current']['value'].reshape((-1, 1))
voltage = block['signals']['voltage']['value'].reshape((-1, 1))
values = np.hstack((current, voltage))
f.write(values.tobytes())
def _export_csv(self, data):
sampling_frequency = data.sample_frequency
sampling_period = 1.0 / sampling_frequency
time_offset = 0.0
with open(self._filename, 'wt') as f:
# f.write('#time (s),current (A),voltage (V)\n')
for block in data.iterate(sampling_frequency):
current = block['signals']['current']['value'].reshape((-1, 1))
voltage = block['signals']['voltage']['value'].reshape((-1, 1))
x = np.arange(len(current), dtype=np.float64).reshape((-1, 1))
x *= sampling_period
x += time_offset
time_offset += 1.0
values = np.hstack((x, current, voltage))
np.savetxt(f, values, ['%.7f', '%.4e', '%.4f'], delimiter=',')
def _export_jls(self, data):
data_recorder = DataRecorder(
self._filename,
calibration=data.calibration.data)
try:
for block in data:
log.info('export_jls iteration')
data_recorder.insert(block)
finally:
data_recorder.close()
def _export_raw(self, data):
with open(self._filename, 'wb') as f:
for block in data:
if 'raw' not in block['signals']:
raise ValueError('Source does have RAW data')
values = block['signals']['raw']['value']
f.write(values.tobytes())
```
#### File: widgets/waveform/xaxis.py
```python
from PySide2 import QtCore, QtWidgets
from .marker import Marker, Z_MARKER_NORMAL, Z_MARKER_ACTIVE
from .marker_area import MarkerArea
import numpy as np
from typing import Dict, List, Tuple
import pyqtgraph as pg
from . axis_item_patch import AxisItemPatch
import logging
log = logging.getLogger(__name__)
class AxisMenu(QtWidgets.QMenu):
def __init__(self):
QtWidgets.QMenu.__init__(self)
self.annotations = self.addMenu('&Annotations')
self.single_marker = QtWidgets.QAction('&Single marker')
self.annotations.addAction(self.single_marker)
self.dual_markers = QtWidgets.QAction('&Dual markers')
self.annotations.addAction(self.dual_markers)
self.clear_all_markers = QtWidgets.QAction('&Clear all')
self.annotations.addAction(self.clear_all_markers)
def int_to_alpha(i):
result = ''
while True:
k = i % 26
result = chr(ord('A') + k) + result
i = (i // 26)
if i <= 0:
return result
i = i - 1
class XAxis(AxisItemPatch):
sigMarkerMoving = QtCore.Signal(str, float)
def __init__(self, cmdp):
pg.AxisItem.__init__(self, orientation='top')
self._cmdp = cmdp
self.menu = AxisMenu()
self.menu.single_marker.triggered.connect(self.on_singleMarker)
self.menu.dual_markers.triggered.connect(self.on_dualMarkers)
self.menu.clear_all_markers.triggered.connect(self.on_clearAllMarkers)
self._markers: Dict[str, Marker] = {}
self._marker_area = MarkerArea(self)
self._proxy = None
self._popup_menu_pos = None
cmdp.subscribe('Widgets/Waveform/grid_x', self._on_grid_x, update_now=True)
cmdp.register('!Widgets/Waveform/Markers/single_add', self._cmd_waveform_marker_single_add,
brief='Add a single marker to the waveform widget.',
detail='value is x-axis time coordinate in seconds for the marker.')
cmdp.register('!Widgets/Waveform/Markers/dual_add', self._cmd_waveform_marker_dual_add,
brief='Add a dual marker pair to the waveform widget.',
detail='value is a list containing:\n' +
'x1: The initial x-axis time coordinate in seconds for the left marker.\n' +
'x2: The initial x-axis time coordinate in seconds for the right marker.\n')
cmdp.register('!Widgets/Waveform/Markers/remove', self._cmd_waveform_marker_remove,
brief='Remove a single marker or dual marker pair from the waveform widget.',
detail='The value is the list of marker names lists to remove which is either length 1' +
'for single markers and length 2 for dual markers.')
cmdp.register('!Widgets/Waveform/Markers/clear', self._cmd_waveform_marker_clear,
brief='Remove all markers.')
cmdp.register('!Widgets/Waveform/Markers/activate', self._cmd_waveform_marker_activate,
brief='Activate the list of markers')
cmdp.register('!Widgets/Waveform/Markers/restore', self._cmd_waveform_marker_restore,
brief='Restore removed markers (for undo support).')
cmdp.register('!Widgets/Waveform/Markers/move', self._cmd_waveform_marker_move,
brief='Move list of markers given as [name, new_pos, old_pos].')
def add_to_scene(self):
self._marker_area.add_to_scene()
def _on_grid_x(self, topic, value):
self.setGrid(128 if bool(value) else 0)
def _find_first_unused_marker_index(self):
idx = 1
while True:
name = str(idx)
name1 = name + 'a'
if name not in self._markers and name1 not in self._markers:
return idx
idx += 1
def _marker_color(self, idx):
idx = 1 + ((idx - 1) % 6) # have 6 colors
colors = self._cmdp['Appearance/__index__']['colors']
color = f'waveform_marker{idx}'
return colors.get(color, '#808080')
def _position_markers(self, positions):
"""Position markers to avoid overlaying existing markers.
:param positions: The list of desired marker locations.
:return: The list of actual marker locations.
"""
positions_start = [k for k in positions]
m = np.array([m.get_pos() for m in self._markers.values()])
x1, x2 = self.range
incr = (x2 - x1) / 80
while max(positions) < x2:
if all([np.all(np.abs(m - p) > incr) for p in positions]):
return positions
positions = [k + incr for k in positions]
return positions_start
def _cmd_waveform_marker_single_add(self, topic, value):
log.info('marker_single_add(%s)', value)
x1, x2 = self.range
if value is None:
x = self._position_markers([(x1 + x2) / 2])[0]
else:
x = value
x = min(max(x, x1), x2)
idx = self._find_first_unused_marker_index()
name = str(idx)
color = self._marker_color(idx)
self._marker_add(name, shape='full', pos=x, color=color, statistics='right')
self.marker_moving_emit(name, x)
self._cmd_waveform_marker_activate(None, [name])
self._cmdp.publish('Widgets/Waveform/#requests/refresh_markers', [name])
return '!Widgets/Waveform/Markers/remove', [[name]]
def _cmd_waveform_marker_dual_add(self, topic, value):
log.info('marker_dual_add(%s)', value)
if value is None:
x1, x2 = self.range
xc = (x1 + x2) / 2
xs = (x2 - x1) / 10
x1, x2 = xc - xs, xc + xs
x1, x2 = self._position_markers([x1, x2])
elif len(value) == 1:
x = value[0]
xa, xb = self.range
xr = (xb - xa) * 0.05
x1, x2 = x - xr, x + xr
elif len(value) == 2:
x1, x2 = value
else:
raise ValueError(f'unsupported dual marker value: {value}')
idx = self._find_first_unused_marker_index()
name = str(idx)
name1, name2 = name + 'a', name + 'b'
color = self._marker_color(idx)
mleft = self._marker_add(name1, shape='left', pos=x1, color=color, statistics='off')
mright = self._marker_add(name2, shape='right', pos=x2, color=color, statistics='right')
mleft.pair = mright
mright.pair = mleft
self.marker_moving_emit(name1, x1)
self.marker_moving_emit(name2, x2)
self._cmd_waveform_marker_activate(None, [name1, name2])
self._cmdp.publish('Widgets/Waveform/#requests/refresh_markers', [name1, name2])
return '!Widgets/Waveform/Markers/remove', [[name1, name2]]
def _cmd_waveform_marker_remove(self, topic, value):
log.info('marker_remove(%s)', value)
states = []
for v in value:
states.append(self.marker_remove(*v))
self._cmdp.publish('Widgets/Waveform/#requests/refresh_markers', None)
return '!Widgets/Waveform/Markers/restore', states
def _cmd_waveform_marker_restore(self, topic, value):
log.info('marker_restore(%s)', value)
names = []
for state in value:
if state is None or len(state) != 2:
continue
markers = [self._marker_add(**s) for s in state if s is not None]
if len(markers) == 2:
markers[0].pair = markers[1]
markers[1].pair = markers[0]
for m in markers:
self.marker_moving_emit(m.name, m.get_pos())
names.append([x.name for x in markers])
return '!Widgets/Waveform/Markers/remove', names
def _cmd_waveform_marker_clear(self, topic, value):
log.info('marker_clear(%s)', value)
removal = []
for marker in self._markers.values():
if marker.pair is not None:
if marker.is_left:
removal.append([marker, marker.pair])
else:
removal.append([marker])
return self._cmd_waveform_marker_remove(None, removal)
def _cmd_waveform_marker_activate(self, topic, value):
active = []
for name, marker in self._markers.items():
if marker.zValue() >= Z_MARKER_ACTIVE:
active.append(name)
z = Z_MARKER_ACTIVE if name in value else Z_MARKER_NORMAL
marker.setZValue(z)
return '!Widgets/Waveform/Markers/activate', active
def _cmd_waveform_marker_move(self, topic, value):
undo = []
for name, new_pos, old_pos in value:
self._markers[name].set_pos(new_pos)
undo.append([name, old_pos, new_pos])
return '!Widgets/Waveform/Markers/move', undo
def on_singleMarker(self):
x = self._popup_menu_pos.x()
self._cmdp.invoke('!Widgets/Waveform/Markers/single_add', x)
def on_dualMarkers(self):
x = self._popup_menu_pos.x()
self._cmdp.invoke('!Widgets/Waveform/Markers/dual_add', [x])
def on_clearAllMarkers(self):
self._cmdp.invoke('!Widgets/Waveform/Markers/clear', None)
def linkedViewChanged(self, view, newRange=None):
pg.AxisItem.linkedViewChanged(self, view=view, newRange=newRange)
for marker in self._markers.values():
marker.viewTransformChanged()
def _marker_add(self, name, **state):
if name in self._markers:
raise RuntimeError('_marker_add internal error: name %s already exists', name)
marker = Marker(cmdp=self._cmdp, name=name, x_axis=self, state=state)
for item in [marker] + marker.graphic_items:
item.setParentItem(self._marker_area)
self._markers[name] = marker
marker.show()
if self._proxy is None:
self._proxy = pg.SignalProxy(self.scene().sigMouseMoved, rateLimit=60, slot=self._mouseMoveEvent)
return marker
def marker_get(self, name):
if name is None:
return None
elif isinstance(name, Marker):
name = name.name
return self._markers.get(name)
def _marker_remove_one(self, m):
if m is None:
return None
self._markers.pop(m.name)
m.setVisible(False)
state = m.remove()
# marker.prepareGeometryChange()
# self.scene().removeItem(marker) # removing from scene causes crash... ugh
# ViewBox has crash workaround for this case - incorporate here?
return state
def marker_remove(self, m1, m2=None):
m1 = self.marker_get(m1)
m2 = self.marker_get(m2)
if m1 is not None and m2 is not None:
if m1.pair is not None and m1.pair != m2:
log.error('dual marker mismatch')
self._marker_remove_one(m1.pair)
if m2.pair is not None and m2.pair != m1:
log.error('dual marker mismatch')
self._marker_remove_one(m2.pair)
return [self._marker_remove_one(m1),
self._marker_remove_one(m2)]
@property
def markers(self) -> Dict[str, Marker]:
# WARNING: for reference only
return self._markers
def markers_single(self) -> List[Marker]:
return [m for m in self._markers.values() if m.is_single]
def markers_dual(self) -> List[Tuple[Marker, Marker]]:
return [(m.pair, m) for m in self._markers.values() if m.is_right]
def markers_clear(self):
while self._markers:
m = next(iter(self._markers.values()))
self.marker_remove(m)
def marker_moving_emit(self, marker_name, marker_pos):
self.sigMarkerMoving.emit(marker_name, marker_pos)
def _mouseMoveEvent(self, ev):
"""Handle mouse movements for every mouse movement within the widget"""
pos = ev[0]
b1 = self.geometry()
if pos.y() < b1.top():
return
p = self.linkedView().mapSceneToView(pos)
x = p.x()
x_min, x_max = self.range
if x < x_min:
x = x_min
elif x > x_max:
x = x_max
for marker in self._markers.values():
if marker.moving:
marker.set_pos(x + marker.moving_offset)
def mouseClickEvent(self, event):
if self.linkedView() is None:
return
pos = event.scenePos()
if self.geometry().contains(pos):
log.info('mouseClickEvent(%s)', event)
if event.button() == QtCore.Qt.RightButton:
self._popup_menu_pos = self.linkedView().mapSceneToView(pos)
event.accept()
# self.scene().addParentContextMenus(self, self.menu, event)
self.menu.popup(event.screenPos().toPoint())
def wheelEvent(self, event, axis=None):
pos = event.scenePos()
vb = self.linkedView()
if vb is not None and self.geometry().contains(pos):
vb.process_wheel_event(event)
else:
event.setAccepted(False)
```
|
{
"source": "jetperch/pytation",
"score": 2
}
|
#### File: pytation/entry_points/cli.py
```python
from pytation import loader
from pytation import cli_runner
def parser_config(p):
"""Graphical user interface runner."""
loader.parser_config(p)
p.add_argument('--iterations',
default=1,
type=int,
help='The number of iterations. 0=infinite')
return on_cmd
def on_cmd(args):
station = loader.load(args)
obj = cli_runner.CliStation(station)
iterations = args.iterations
if iterations <= 0:
iterations = count
return obj.run(count=iterations)
```
#### File: pytation/pytation_examples/simple.py
```python
import os
import logging
import time
from pytation import Context
MYPATH = os.path.dirname(os.path.abspath(__file__))
class Eq1:
NAME = 'Equipment Example 1'
def __init__(self):
self._log = logging.getLogger(__name__ + '.Eq1')
def setup(self, context: Context, config=None):
self._log.info('setup')
def restore(self):
self._log.info('restore')
def teardown(self):
self._log.info('teardown')
class Dut1:
NAME = 'Device under Test Example 1'
def __init__(self):
self._log = logging.getLogger(__name__ + '.Dut1')
def setup(self, context: Context, config=None):
self._log.info('setup')
def restore(self):
self._log.info('restore')
def teardown(self):
self._log.info('teardown')
def suite_setup(context, config=None):
context.state = 'wait_for_dut'
context.wait_for_user()
context.state = 'in_progress'
def suite_teardown(context, config=None):
if context.result == 0:
context.state = 'pass'
else:
context.state = 'fail'
context.wait_for_user()
def enter_serial_number(context, config=None):
serial_number = context.prompt('Enter serial number')
context.env['name'] = serial_number
context.env['serial_number'] = serial_number
return 0, {'serial_number': serial_number}
def test1(context, config=None):
config = {} if config is None else config
_log = logging.getLogger(__name__ + '.test1')
mode = config.get('mode', 'normal')
delay = float(config.get('delay', 0.01))
count = int(config.get('count', 50))
_log.info('start: mode=%s', mode)
for i in range(count):
time.sleep(delay)
context.progress((i + 1) / count)
_log.info('stop')
return 0, {'hello': 'world'}
STATION = {
'name': 'simple',
'full_name': 'Simple test station example',
'env': {},
'suite_setup': {'fn': suite_setup, 'config': {}},
'suite_teardown': {'fn': suite_teardown, 'config': {}},
'states': {
'initialize': {
'pixmap': ':/station/initialize.jpg',
'style': 'QLabel { background-color : yellow; color : black; font-size : 12pt; }',
'html': '<html><body><h1>Connect Equipment</h1></body></html>',
},
'wait_for_dut': {
'pixmap': ':/station/wait_for_dut.jpg',
'style': 'QLabel { background-color : #8080ff; color : black; font-size : 12pt; }',
'html': '<html><body><h1>Connect Device Under Test and press any key</h1></body></html>',
},
'in_progress': {
'pixmap': ':/station/in_progress.jpg',
'style': 'QLabel { background-color : white; color : black; font-size : 12pt; }',
'html': '<html><body><h1>Test in Progress</h1></body></html>',
},
'pass': {
'pixmap': ':/station/pass.jpg',
'style': 'QLabel { background-color : green; color : black; font-size : 12pt; }',
'html': '<html><body><h1>PASS</h1><p>Disconnect the device and press any key.</p></body></html>',
},
'fail': {
'pixmap': ':/station/fail.jpg',
'style': 'QLabel { background-color : red; color : black; font-size : 12pt; }',
'html': '<html><body><h1>FAILED</h1><p>Disconnect the device and press any key.</p></body></html>',
},
'abort': {
'pixmap': ':/station/abort.jpg',
'style': 'QLabel { background-color : red; color : black; font-size : 12pt; }',
'html': '<html><body><h1>ABORT</h1><p>Internal error - close & restart</p></body></html>',
},
},
'tests': [
{'fn': enter_serial_number},
{'fn': test1},
{'name': 'long_iter', 'fn': test1, 'config': {'delay': 0.5, 'count': 4}},
],
'devices': [
{'name': 'eq1', 'clz': Eq1},
{'name': 'dut', 'clz': Dut1, 'lifecycle': 'suite', 'config': {'mode': 'test'}},
],
'gui_resources': [['pytation_examples', 'pytation_examples.rcc']] # list of [package, resource]
}
```
#### File: pytation/pytation/gui_runner.py
```python
import sys
from pytation import __version__, Context
from PySide6 import QtCore, QtWidgets, QtGui
from time import sleep
import pkgutil
import queue
import threading
import logging
LOG_COLOR = {
logging.CRITICAL: QtGui.QColor(255, 0, 0),
logging.ERROR: QtGui.QColor(128, 0, 0),
logging.WARNING: QtGui.QColor(255, 165, 0),
logging.INFO: QtGui.QColor(0, 0, 0),
logging.DEBUG: QtGui.QColor(128, 128, 128),
}
class Handler(logging.Handler):
def __init__(self, cbk):
logging.Handler.__init__(self)
self._cbk = cbk
def emit(self, record):
self._cbk(record)
class Formatter(logging.Formatter):
def formatException(self, ei):
result = super(Formatter, self).formatException(ei)
return result
def format(self, record):
s = super(Formatter, self).format(record)
if record.exc_text:
s = s.replace('\n', '')
return s
class QResyncEvent(QtCore.QEvent):
"""An event containing a request for python message processing."""
EVENT_TYPE = QtCore.QEvent.Type(QtCore.QEvent.registerEventType())
def __init__(self):
QtCore.QEvent.__init__(self, self.EVENT_TYPE)
def __str__(self):
return 'QResyncEvent()'
def __len__(self):
return 0
class StationObject:
def __init__(self, parent, station):
self._context = Context(station)
self._parent = parent
self._log = logging.getLogger('station')
self._context.callback_register('progress', self._on_progress_cbk)
self._context.callback_register('state', self._on_state_cbk)
self._context.callback_register('wait_for_user', self._on_wait_for_user_cbk)
self._context.callback_register('prompt', self._on_prompt_cbk)
self.wait_for_user = False
self.prompt_result_str = None
def _on_progress_cbk(self, progress):
self._parent.on_message({'type': 'progress', 'data': progress})
def _on_state_cbk(self, state):
self._parent.on_message({'type': 'state', 'data': state})
def _on_wait_for_user_cbk(self):
self.wait_for_user = False
while True:
if self._context.do_quit:
raise KeyboardInterrupt('do_quit while wait_for_user')
elif self.wait_for_user:
return
sleep(0.05)
def _on_prompt_cbk(self, prompt_str):
self.prompt_result_str = None
self._parent.on_message({'type': 'prompt', 'data': prompt_str})
while True:
if self._context.do_quit:
raise KeyboardInterrupt('do_quit while prompt')
elif self.prompt_result_str is False:
return None
elif self.prompt_result_str is not None:
return self.prompt_result_str
sleep(0.05)
def run(self):
self._log.info('Station thread starting')
self._context.station_run()
self._log.info('Station thread stopping')
@QtCore.Slot()
def quit_request(self):
self._context.do_quit = True
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, app, station):
super(MainWindow, self).__init__()
self.setObjectName('MainWindow')
self._app = app
self._handler = Handler(self._on_log_cbk)
self._formatter = Formatter('%(asctime)s %(levelname)s %(message)s', '%Y%m%d %H:%M:%S')
self._log = logging.getLogger()
self._station_thread = None
self._station = None
self._queue = queue.Queue()
self._pixmap_bin = None
self.resize(800, 600)
#window_icon = station.get('window_icon')
#if window_icon is not None:
# self._icon = QIcon()
# self._icon.addFile(window_icon, QSize(), QIcon.Normal, QIcon.Off)
# self.setWindowIcon(self._icon)
self._central_widget = QtWidgets.QWidget(self)
self._central_widget.setObjectName('_central_widget')
self.setCentralWidget(self._central_widget)
self._vertical_layout = QtWidgets.QVBoxLayout(self._central_widget)
self._vertical_layout.setObjectName('_vertical_layout')
self._frame = QtWidgets.QFrame(self._central_widget)
self._frame.setObjectName('_frame')
self._frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
self._frame.setFrameShadow(QtWidgets.QFrame.Raised)
self._vertical_layout.addWidget(self._frame)
self._horizontal_layout = QtWidgets.QHBoxLayout(self._frame)
self._horizontal_layout.setObjectName('_horizontal_layout')
self._image_label = QtWidgets.QLabel(self._frame)
self._image_label.setObjectName('_image_label')
size_policy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
size_policy.setHorizontalStretch(1)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(self._image_label.sizePolicy().hasHeightForWidth())
self._image_label.setSizePolicy(size_policy)
self._image_label.setAlignment(QtGui.Qt.AlignCenter)
self._horizontal_layout.addWidget(self._image_label)
self._stage_text = QtWidgets.QLabel(self._frame)
self._stage_text.setObjectName('_stage_text')
size_policy.setHeightForWidth(self._stage_text.sizePolicy().hasHeightForWidth())
self._stage_text.setSizePolicy(size_policy)
self._stage_text.setAlignment(QtGui.Qt.AlignCenter)
self._horizontal_layout.addWidget(self._stage_text)
self._logging_textEdit = QtWidgets.QTextEdit(self._central_widget)
self._logging_textEdit.setObjectName('_logging_textEdit')
self._logging_textEdit.setUndoRedoEnabled(False)
self._logging_textEdit.setReadOnly(True)
self._logging_textEdit.setTextInteractionFlags(QtGui.Qt.NoTextInteraction)
self._vertical_layout.addWidget(self._logging_textEdit)
self._progress_bar = QtWidgets.QProgressBar(self._central_widget)
self._progress_bar.setObjectName('_progress_bar')
self._progress_bar.setRange(0, 1000)
self._vertical_layout.addWidget(self._progress_bar)
self._logging_configure()
self._log.info('\n**************************************' +
'\n* STATION=%s' +
'\n* VERSION=%s' +
'\n**************************************',
station['name'], __version__)
self._log_demo()
self._shortcut_spacebar = QtGui.QShortcut(QtGui.QKeySequence(QtCore.Qt.Key_Space), self)
self._shortcut_spacebar.activated.connect(self._on_spacebar)
# self.showFullScreen()
self.showMaximized()
self._station_start(station)
def _station_start(self, station):
self._station = StationObject(self, station)
self._station_thread = threading.Thread(target=self._station.run)
self._station_thread.start()
def _station_stop(self):
if self._station_thread is not None:
self._station.quit_request()
self._station_thread.join()
self._station = None
self._station_thread = None
@QtCore.Slot(float)
def _on_progress(self, progress):
if progress <= 0:
self._logging_textEdit.clear()
self._progress_bar.setValue(round(progress * 1000))
@QtCore.Slot(float)
def _on_state(self, state):
pixmap = state.get('pixmap')
style = state.get('style', 'QLabel { background-color : white; color : black; font-size : 12pt; }')
html = state.get('html', '')
if pixmap is None:
self._image_label.clear()
self._pixmap_bin = None
else:
try:
pixmap_bin = QtGui.QPixmap(pixmap)
self._log.info('image_label pixmap: %s => %s', pixmap, pixmap_bin.size())
if pixmap_bin is None:
self._log.warning('QPixmap failed for resource %s', state.get('pixmap'))
self._image_label.setPixmap(pixmap_bin)
self._pixmap_bin = pixmap_bin
except Exception:
self._log.warning('Could not load image')
if style is not None:
self._stage_text.setStyleSheet(style)
if html is not None:
self._stage_text.setText(html)
@QtCore.Slot(str)
def _on_prompt(self, prompt_str):
s, status = QtWidgets.QInputDialog.getText(self, "Input data", prompt_str)
if s is None or not status:
self._station.prompt_result_str = False
else:
self._station.prompt_result_str = s
def _logging_configure(self):
self._handler.setLevel(logging.INFO)
self._log.addHandler(self._handler)
self._log.setLevel(logging.DEBUG)
def _log_demo(self):
self._log.critical('critical')
self._log.error('error')
self._log.warning('warning')
self._log.info('info')
self._log.debug('debug')
def keyPressEvent(self, event: QtGui.QKeyEvent):
key = event.key()
if key in [QtCore.Qt.Key_Escape]:
self.close()
else:
self._station.wait_for_user = True
event.accept()
def _on_spacebar(self):
self._station.wait_for_user = True
def event(self, event: QtCore.QEvent):
if event.type() == QResyncEvent.EVENT_TYPE:
# process resync_handler resync calls.
event.accept()
self._message_process()
return True
else:
return super(MainWindow, self).event(event)
def _message_process(self):
while True:
try:
msg = self._queue.get(block=False)
msg_type = msg['type']
if msg_type == 'log':
self.on_logRecord(msg['data'])
elif msg_type == 'progress':
self._on_progress(msg['data'])
elif msg_type == 'state':
self._on_state(msg['data'])
elif msg_type == 'prompt':
self._on_prompt(msg['data'])
except queue.Empty:
break
def on_message(self, msg):
self._queue.put(msg)
event = QResyncEvent()
QtCore.QCoreApplication.postEvent(self, event)
def _on_log_cbk(self, record):
msg = {
'type': 'log',
'data': record
}
self.on_message(msg)
@QtCore.Slot(object)
def on_logRecord(self, record: logging.LogRecord):
txt = self._formatter.format(record)
color = LOG_COLOR[record.levelno]
self._logging_textEdit.setTextColor(color)
self._logging_textEdit.append(txt)
def closeEvent(self, event: QtGui.QCloseEvent):
self._log.info('MainWindow.closeEvent')
self._station_stop()
event.accept()
def run(station):
#if sys.platform.startswith('win'):
# ctypes.windll.user32.SetProcessDPIAware()
#QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling)
app = QtWidgets.QApplication(sys.argv)
resources = []
log = logging.getLogger()
for package, data in station['gui_resources']:
b = pkgutil.get_data(package, data)
log.info(f'resource {package} {data} => {len(b)} bytes')
if b is None or not len(b):
log.warning('Could not find resource: %s %s', package, data)
if not QtCore.QResource.registerResourceData(b):
log.warning('Could not register resource: %s %s', package, data)
resources.append(b)
try:
ui = MainWindow(app, station)
rc = app.exec_()
except Exception:
log.exception('while running MainWindow')
raise
return rc
```
#### File: jetperch/pytation/setup.py
```python
import setuptools
import setuptools.dist
from setuptools.command.sdist import sdist
import distutils.cmd
from distutils.errors import DistutilsExecError
import os
import sys
from pytation import qt_util
MYPATH = os.path.dirname(os.path.abspath(__file__))
VERSION_PATH = os.path.join(MYPATH, 'pytation', 'version.py')
about = {}
with open(VERSION_PATH, 'r', encoding='utf-8') as f:
exec(f.read(), about)
# Get the long description from the README file
with open(os.path.join(MYPATH, 'README.md'), 'r', encoding='utf-8') as f:
long_description = f.read()
if sys.platform.startswith('win'):
PLATFORM_INSTALL_REQUIRES = ['pypiwin32>=223']
else:
PLATFORM_INSTALL_REQUIRES = []
def _version_get():
return about['__version__']
def _build_qt():
paths = [
os.path.join(MYPATH, 'pytation'),
os.path.join(MYPATH, 'pytation_examples'),
]
for path in paths:
targets = qt_util.convert_rcc(path)
targets = [os.path.relpath(t, path).replace('\\', '/') for t in targets]
with open(os.path.join(path, '.gitignore'), 'w', encoding='utf-8') as f:
f.write('# AUTOMATICALLY GENERATED BY setup.py - DO NOT EDIT\n')
f.write('\n'.join(targets))
f.write('\n')
class CustomBuildQt(distutils.cmd.Command):
"""Custom command to build Qt resource file and Qt user interface modules."""
description = 'Build Qt resource file and Qt user interface modules.'
user_options = []
def initialize_options(self):
pass
def finalize_options(self):
pass
def run(self):
_build_qt()
class CustomSdistCommand(sdist):
def run(self):
_build_qt()
sdist.run(self)
class CustomBuildDocs(distutils.cmd.Command):
"""Custom command to build docs locally."""
description = 'Build docs.'
user_options = []
def initialize_options(self):
pass
def finalize_options(self):
pass
def run(self):
# sphinx-build -b html docs build\docs_html
# defer import so not all setups require sphinx
from sphinx.application import Sphinx
from sphinx.util.console import nocolor, color_terminal
nocolor()
source_dir = os.path.join(MYPATH, 'docs')
target_dir = os.path.join(MYPATH, 'build', 'docs_html')
doctree_dir = os.path.join(target_dir, '.doctree')
app = Sphinx(source_dir, source_dir, target_dir, doctree_dir, 'html')
app.build()
if app.statuscode:
raise DistutilsExecError(
'caused by %s builder.' % app.builder.name)
setuptools.setup(
name=about['__title__'],
version=about['__version__'],
description=about['__description__'],
long_description=long_description,
long_description_content_type='text/markdown',
url=about['__url__'],
author=about['__author__'],
author_email=about['__author_email__'],
license=about['__license__'],
cmdclass={
'qt': CustomBuildQt,
'sdist': CustomSdistCommand
},
# Classifiers help users find your project by categorizing it.
#
# For a list of valid classifiers, see https://pypi.org/classifiers/
classifiers=[ # Optional
'Development Status :: 3 - Alpha',
# Indicate who your project is intended for
'Intended Audience :: Developers',
'Intended Audience :: End Users/Desktop',
'Intended Audience :: Science/Research',
'Intended Audience :: Manufacturing',
# Pick your license as you wish
'License :: OSI Approved :: Apache Software License',
# Operating systems
'Operating System :: Microsoft :: Windows :: Windows 10',
'Operating System :: MacOS :: MacOS X',
'Operating System :: POSIX :: Linux',
# Supported Python versions
'Programming Language :: Python',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.9',
'Programming Language :: Python :: Implementation :: CPython',
# Language
'Natural Language :: English',
# Topics
'Topic :: Scientific/Engineering',
'Topic :: Software Development :: Embedded Systems',
'Topic :: Software Development :: Testing',
'Topic :: System :: Hardware',
'Topic :: Utilities',
],
keywords='hardware validation manufacturing test station',
packages=setuptools.find_packages(exclude=['native', 'docs', 'test', 'dist', 'build']),
include_package_data=True,
include_dirs=[],
# See https://packaging.python.org/guides/distributing-packages-using-setuptools/#python-requires
python_requires='~=3.9',
setup_requires=[
# https://developercommunity.visualstudio.com/content/problem/1207405/fmod-after-an-update-to-windows-2004-is-causing-a.html
'wheel',
],
# See https://packaging.python.org/en/latest/requirements.html
# https://numpy.org/neps/nep-0029-deprecation_policy.html
install_requires=[
'fs',
'PySide6',
] + PLATFORM_INSTALL_REQUIRES,
extras_require={
'dev': ['check-manifest', 'coverage', 'sphinx', 'm2r'],
},
entry_points={
'console_scripts': [
'pytation=pytation.__main__:run',
],
},
project_urls={
'Bug Reports': 'https://github.com/jetperch/pytation/issues',
'Source': 'https://github.com/jetperch/pytation',
},
)
```
|
{
"source": "jetpotion/Python-Algorithms",
"score": 4
}
|
#### File: Python-Algorithms/AMS326/Strassen.py
```python
"@author: <NAME>"
"@email:<EMAIL>"
import numpy as np
from Needle import Needle
#This method will call all the other functions
def main():
pinlength = 1
pinlength2 = 0.5
pinlength3 = (1/3)
pinlength4 = 0.25
linedistance = 20
probability1 = montecarlo(linedistance,pinlength)
probability2 = montecarlo(linedistance, pinlength2)
probability3 = montecarlo(linedistance,pinlength3)
probability4 = montecarlo(linedistance,pinlength4)
print("Approximation with a pinlength 1: " + str(probability1))
print("Approximation with a pinlength 0.5: " +str( probability2))
print("Approximation with a pinlength 0.333:" +str( probability3))
print("Approximation with a pinlength 0.25: " +str( probability4))
#This will throw the needle randomly
def throwneedle(length,spacebetween):
return length,np.random.uniform(0,spacebetween),np.random.uniform(0,np.pi)
#Check intersections
def checkintersections(center,length,angle,linedistance):
#Check if the needle is intersecting the right wall
if center + length / 2 * np.sin(angle) >= linedistance :
return True
#Check if the needle is intersecting the left wall
elif center + length /2 * np.sin(angle) <= 0:
return True
#THe needle doesnt intersect at all
else:
return False
def montecarlo(linedistance, pinlength):
#This will be the number of iterations for our simulations
numberofiterations = 3000000
counter = 0
for x in range(numberofiterations):
#Count the ones that do intersect
length,center,angle = throwneedle(pinlength,linedistance)
if(checkintersections(center,length,angle,linedistance)) :
counter += 1
return (counter * 100) / (numberofiterations * 100)
if __name__ == "__main__":
main()
```
#### File: Python-Algorithms/AMS326/TimeofDeath.py
```python
import numpy as np
#This will use the forward euler method
def main():
#This will increment the time by minutes we will increment by 1 since my k is in terms of minutes
h = 1;
#We can calculate the time before he died
#This guy died 20.533397 minutes before we found the body We calculate via the given K
deltabeforedeath = np.log((np.power(91.11, 0.999)- 34.44) / (np.power(97.88,0.999) -34.44)) / -0.005504671;
print(deltabeforedeath)
#This means this guy died at this time 11:39.466603
print("This guy died at " + str(11) + ":" + str(39.466603) )
#Now we everything to calculate for when this guy will reach 55.55 degrees
initialtemperature = 97.88
initialtime = 0
#Now we perform the newton euler method and will take a walk across the solution of the differential equation till we get a number close to 44.44
while initialtemperature >= 44.44:
print("Temperature: " + str(initialtemperature) +" " +"time: " + str(initialtime))
initialtime += h
initialtemperature += h * newtonlawofcooling(initialtime,initialtemperature)
print("The amount of time till the body reaches 44.44 from a body temperature of 97.88: " +str(initialtime)+ "minutes")
#Temperature of death
#We need to find the time we died
def newtonlawofcooling(time,temperature):
#Solving for the DE we simply only need to raise the temperature to the 0.999 power
#Solving for the rate of cooling per minute we have constant cooling factor and we solve into terms of minutes.
return -0.0055046671 * (np.power(temperature,0.999) - 34.44);
if __name__ == "__main__":
main()
```
#### File: Python-Algorithms/ComputationalFinance/AkunaQuestion1.py
```python
def initial(low,high):
counter = 0;
for x in range(low,high+1):
if recursion(x) is True:
counter += 1;
return counter;
def recursion(targetnumber):
flag = True;
currentnumber = targetnumber
while currentnumber != 1:
if currentnumber % 3 == 0:
currentnumber = currentnumber/3
elif currentnumber % 5 == 0:
currentnumber = currentnumber/5
else:
return False;
return flag;
print(initial(1,15))
```
#### File: Python-Algorithms/ComputationalFinance/BinomialPricing.py
```python
import math
import numpy as np
def main():
array = []
newarray = []
filename = input("What is your file name: ")
with open(filename,'r') as f:
for line in f:
array.append(line)
for x in range(0, len(array)):
if "\n" in array[x]:
cleanedatafield = array[x].replace("\n", "")
field = cleanedatafield.split("\t")
datafield = tuple(field)
newarray.append(datafield)
else :
field = array[x].split("\t")
datafield = tuple(field)
newarray.append(datafield)
# to see if we are going to use this
for element in newarray:
#Extract information that is necessary
IR = float(element[0])
TimetoMaturity = float(element[1])
numberofpayments = float (element[2])
volatility = float(element[3])
stockprice = float(element[4])
strikeprice = float(element[5])
deltaT = TimetoMaturity / numberofpayments
Uscalar = math.exp(volatility * math.sqrt(deltaT))
Vscalar = 1/Uscalar
a = math.exp(IR * deltaT)
numerator = a -Vscalar
denominator = Uscalar - Vscalar
p = numerator / denominator
invp = 1-p
rows = int(numberofpayments) + 1
roundedint = int(numberofpayments)
columns = int(numberofpayments) + 1
binomialmodel = np.zeros((rows,columns))
optionmodel = np.zeros((rows,columns))
binomialmodel[0,0] = stockprice
for x in range(1,rows):
binomialmodel[x,0] = binomialmodel[x-1,0] * Uscalar
for j in range(1, columns):
binomialmodel[x,j] = binomialmodel[x-1,j-1] * Vscalar
for j in range(rows):
optionmodel[roundedint,j] = max(strikeprice - binomialmodel[roundedint,j], 0 )
for m in range(roundedint):
i = roundedint - m -1
for j in range(i + 1):
optionmodel[i,j] = (p * optionmodel[i+1 , j ] + invp * optionmodel[i + 1,j+1 ]) * math.exp(-IR * deltaT)
optionmodel[i,j] = max(optionmodel[i,j] ,strikeprice - binomialmodel[i,j])
print(str(element) + "The optionvalue is " + str(optionmodel[0,0]))
if __name__ == "__main__":
main()
```
#### File: Python-Algorithms/ComputationalFinance/LeetCodeProblem12.py
```python
class Solution:
def intToRoman(self, num: int) -> str:
switcher = {1 : "I",
5 : "V",
10 : "X",
50 : "L",
100 : "C",
500 : "D",
1000: "M",
4 : "IV",
9 : "IX",
40 : "XL",
90: "XC",
900 : "CM",
400: "CD"}
output = ""
conversion = str(num)
powersoften = pow(10,len(conversion) - 1)
for x in conversion:
character = x
basedigits = int(character) * powersoften
if basedigits in switcher:
output += switcher[basedigits]
powersoften = powersoften//10
continue
else:
substring = ""
#If this number is not a ones digits or ten it self but this will never happen because 10 will be located before it all began
#Keep substracting nearest local power 600 then becomes 600 - 100 = 500 From which 500 will be located. This will reduce the problem down to the 5,500.,500
while basedigits is not 0 :
basedigits = basedigits - powersoften
substring += switcher[powersoften]
#Check as we reduce it
if basedigits in switcher:
substring += switcher[basedigits]
basedigits = 0
powersoften = powersoften // 10
output += substring[::-1]
return output
```
#### File: Python-Algorithms/ComputationalFinance/LeetCodeProblem2.py
```python
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
#Reconstruct integers for l1
#Reconstruct integers for l1
powersoften = 1
sumtotalone = 0
while l1:
sumtotalone = sumtotalone + l1.val * powersoften
powersoften = powersoften * 10
l1 = l1.next
sumtotaltwo = 0
powersoften = 1
while l2:
sumtotaltwo = sumtotaltwo + l2.val * powersoften
powersoften = powersoften * 10
l2 = l2.next
total = list(str(sumtotalone + sumtotaltwo))
total = total[::-1]
total = [int(i) for i in total]
print(total)
Head = ListNode(total[0])
cursor = Head
for x in range(1,len(total)):
newNode = ListNode(total[x])
cursor.next = newNode
cursor = cursor.next
return Head
```
#### File: Python-Algorithms/ComputationalFinance/subsetsum.py
```python
def subsetsum(array:[int],n:int,total:int) -> bool:
#I know subset sum if very confusing. Dont get me dynamic programming is very poorly taught in computer science education because we take specific instances of problems and try to shove it down te curriclum
#Rather dynamic programming is a huge aspect of operation research espeically tabulation.
table =([[False for i in range(sum+1)]
for i in range(n+1)])
#Set the first column to be true because any sum that is zero
for i in range(n+1):
table[i][0] = True
#set the first row to false.
# Except the sum that equals == array[0]. Beause we can certainly create a sum with only that element. If we can only pick 1 element
#Let f_i(s) be a recurrence relation to denote the element subset with remainin sum(s)
#let a say a very simple example s = {1,2,3} and target = 5
#f_i(s) is f_1(0) f_1(1),f_1(2) , f_1(3),f_1(4), f_1(5)
#f_2(0).....f_2(5)
#f_3(0).....f_3(5)
#As you can seee f_1(0),f_2(0),f_3(0) are all True because we have achieved our ojective based on some set
#Now we will begin
#f_3(5) = false because we cannot createa sum with size 1 with 5
#f_3(4) = false because we cannot create a sum with with just 1 element
#f_3(3) = True because we cann create a sum with 3
#f_3(2) = false ebecause we cannot create a sum with 2
#f_3(1) = false because we cannot create a sum with just 1
#f_3(0) = True because our decision is with just 0. And we achieves our object
#What about length 2?
#f_2(5) but this time you will have to think what he will be deciding from just the elements of size 3. His decision based on f_3(3),f_3(0). Basically choose True
#f_2(4) He will choose between f_3(4) or f_3(2) basically false
#f_2(3) he will choose between f_3(3) or f_3(1) basically True
#f_2(2) he will choose between f_3(0) or f_3(2) which is false
#f_2(1) = cant select the current one because he has 1 left. This person is decision is f_3(1) because he cant go further. So its false
#f_2(0) = true because we have reached object
#What aobut length(3)? Same process.. on the memmoization. We couldve started at the end of the array or the beginning and weill have the same answer. With the same decisions
#Basically this memoization implies an algorithm.
# We can either choose to exclude the current element or not. Carrying over the sum on previous index.
# # Our decision is binary is based on decision if we take the current index or not
#loop through everything except for the first array
for x in range(len(1,n+1)):
for j in range(len(1,total+1)):
if array[x -1 ] > j:
#This would mean from our current at the currentindex
#subset then we will be screwed if our sum is zero
array[x][j] = array[x-1][j]
#This case occurs if current sum remaining is greater or equal to the element provided at the current index
else:
#The first part of our statement say that we can choose to exclude the current current index. And our decision was based on the previous step
#Or we can choose to include it based on the decision
array[x][j] = array[x-1][j] or T[i-1][j-array[i-1]
for z in range(len(0,n)):
for j in len(0,total):
print(array[z][j], end = " ")
print("\n")
return table[n][total]
arr = [1,2,3]
total =5
length = len(arr)
subsetsum(arr,total,length)
```
|
{
"source": "JetRunner/transformers",
"score": 2
}
|
#### File: src/transformers/modeling_roberta.py
```python
import logging
import warnings
import torch
import torch.nn as nn
from torch.nn import CrossEntropyLoss, MSELoss
from .configuration_roberta import RobertaConfig
from .file_utils import add_start_docstrings, add_start_docstrings_to_callable
from .modeling_bert import BertEmbeddings, BertLayerNorm, BertModel, BertPreTrainedModel, gelu
from .modeling_utils import create_position_ids_from_input_ids
logger = logging.getLogger(__name__)
ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST = [
"roberta-base",
"roberta-large",
"roberta-large-mnli",
"distilroberta-base",
"roberta-base-openai-detector",
"roberta-large-openai-detector",
# See all RoBERTa models at https://huggingface.co/models?filter=roberta
]
class RobertaEmbeddings(BertEmbeddings):
"""
Same as BertEmbeddings with a tiny tweak for positional embeddings indexing.
"""
def __init__(self, config):
super().__init__(config)
self.padding_idx = config.pad_token_id
self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=self.padding_idx)
self.position_embeddings = nn.Embedding(
config.max_position_embeddings, config.hidden_size, padding_idx=self.padding_idx
)
def forward(self, input_ids=None, token_type_ids=None, position_ids=None, inputs_embeds=None):
if position_ids is None:
if input_ids is not None:
# Create the position ids from the input token ids. Any padded tokens remain padded.
position_ids = create_position_ids_from_input_ids(input_ids, self.padding_idx).to(input_ids.device)
else:
position_ids = self.create_position_ids_from_inputs_embeds(inputs_embeds)
return super().forward(
input_ids, token_type_ids=token_type_ids, position_ids=position_ids, inputs_embeds=inputs_embeds
)
def create_position_ids_from_inputs_embeds(self, inputs_embeds):
""" We are provided embeddings directly. We cannot infer which are padded so just generate
sequential position ids.
:param torch.Tensor inputs_embeds:
:return torch.Tensor:
"""
input_shape = inputs_embeds.size()[:-1]
sequence_length = input_shape[1]
position_ids = torch.arange(
self.padding_idx + 1, sequence_length + self.padding_idx + 1, dtype=torch.long, device=inputs_embeds.device
)
return position_ids.unsqueeze(0).expand(input_shape)
ROBERTA_START_DOCSTRING = r"""
This model is a PyTorch `torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>`_ sub-class.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general
usage and behavior.
Parameters:
config (:class:`~transformers.RobertaConfig`): Model configuration class with all the parameters of the
model. Initializing with a config file does not load the weights associated with the model, only the configuration.
Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model weights.
"""
ROBERTA_INPUTS_DOCSTRING = r"""
Args:
input_ids (:obj:`torch.LongTensor` of shape :obj:`{0}`):
Indices of input sequence tokens in the vocabulary.
Indices can be obtained using :class:`transformers.RobertaTokenizer`.
See :func:`transformers.PreTrainedTokenizer.encode` and
:func:`transformers.PreTrainedTokenizer.encode_plus` for details.
`What are input IDs? <../glossary.html#input-ids>`__
attention_mask (:obj:`torch.FloatTensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`):
Mask to avoid performing attention on padding token indices.
Mask values selected in ``[0, 1]``:
``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens.
`What are attention masks? <../glossary.html#attention-mask>`__
token_type_ids (:obj:`torch.LongTensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`):
Segment token indices to indicate first and second portions of the inputs.
Indices are selected in ``[0, 1]``: ``0`` corresponds to a `sentence A` token, ``1``
corresponds to a `sentence B` token
`What are token type IDs? <../glossary.html#token-type-ids>`_
position_ids (:obj:`torch.LongTensor` of shape :obj:`{0}`, `optional`, defaults to :obj:`None`):
Indices of positions of each input sequence tokens in the position embeddings.
Selected in the range ``[0, config.max_position_embeddings - 1]``.
`What are position IDs? <../glossary.html#position-ids>`_
head_mask (:obj:`torch.FloatTensor` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`, defaults to :obj:`None`):
Mask to nullify selected heads of the self-attention modules.
Mask values selected in ``[0, 1]``:
:obj:`1` indicates the head is **not masked**, :obj:`0` indicates the head is **masked**.
inputs_embeds (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`, defaults to :obj:`None`):
Optionally, instead of passing :obj:`input_ids` you can choose to directly pass an embedded representation.
This is useful if you want more control over how to convert `input_ids` indices into associated vectors
than the model's internal embedding lookup matrix.
output_attentions (:obj:`bool`, `optional`, defaults to :obj:`None`):
If set to ``True``, the attentions tensors of all attention layers are returned. See ``attentions`` under returned tensors for more detail.
"""
@add_start_docstrings(
"The bare RoBERTa Model transformer outputting raw hidden-states without any specific head on top.",
ROBERTA_START_DOCSTRING,
)
class RobertaModel(BertModel):
"""
This class overrides :class:`~transformers.BertModel`. Please check the
superclass for the appropriate documentation alongside usage examples.
"""
config_class = RobertaConfig
base_model_prefix = "roberta"
def __init__(self, config):
super().__init__(config)
self.embeddings = RobertaEmbeddings(config)
self.init_weights()
def get_input_embeddings(self):
return self.embeddings.word_embeddings
def set_input_embeddings(self, value):
self.embeddings.word_embeddings = value
@add_start_docstrings("""RoBERTa Model with a `language modeling` head on top. """, ROBERTA_START_DOCSTRING)
class RobertaForMaskedLM(BertPreTrainedModel):
config_class = RobertaConfig
base_model_prefix = "roberta"
def __init__(self, config):
super().__init__(config)
self.roberta = RobertaModel(config)
self.lm_head = RobertaLMHead(config)
self.init_weights()
def get_output_embeddings(self):
return self.lm_head.decoder
@add_start_docstrings_to_callable(ROBERTA_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
def forward(
self,
input_ids=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
labels=None,
output_attentions=None,
**kwargs
):
r"""
labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Labels for computing the masked language modeling loss.
Indices should be in ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring)
Tokens with indices set to ``-100`` are ignored (masked), the loss is only computed for the tokens with labels
in ``[0, ..., config.vocab_size]``
kwargs (:obj:`Dict[str, any]`, optional, defaults to `{}`):
Used to hide legacy arguments that have been deprecated.
Returns:
:obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.RobertaConfig`) and inputs:
masked_lm_loss (`optional`, returned when ``labels`` is provided) ``torch.FloatTensor`` of shape ``(1,)``:
Masked language modeling loss.
prediction_scores (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, config.vocab_size)`)
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``config.output_hidden_states=True``):
Tuple of :obj:`torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer)
of shape :obj:`(batch_size, sequence_length, hidden_size)`.
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or ``config.output_attentions=True``):
Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape
:obj:`(batch_size, num_heads, sequence_length, sequence_length)`.
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.
Examples::
from transformers import RobertaTokenizer, RobertaForMaskedLM
import torch
tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaForMaskedLM.from_pretrained('roberta-base')
input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0) # Batch size 1
outputs = model(input_ids, labels=input_ids)
loss, prediction_scores = outputs[:2]
"""
if "masked_lm_labels" in kwargs:
warnings.warn(
"The `masked_lm_labels` argument is deprecated and will be removed in a future version, use `labels` instead.",
DeprecationWarning,
)
labels = kwargs.pop("masked_lm_labels")
assert kwargs == {}, f"Unexpected keyword arguments: {list(kwargs.keys())}."
outputs = self.roberta(
input_ids,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=output_attentions,
)
sequence_output = outputs[0]
prediction_scores = self.lm_head(sequence_output)
outputs = (prediction_scores,) + outputs[2:] # Add hidden states and attention if they are here
if labels is not None:
loss_fct = CrossEntropyLoss()
masked_lm_loss = loss_fct(prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
outputs = (masked_lm_loss,) + outputs
return outputs # (masked_lm_loss), prediction_scores, (hidden_states), (attentions)
class RobertaLMHead(nn.Module):
"""Roberta Head for masked language modeling."""
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.layer_norm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
self.bias = nn.Parameter(torch.zeros(config.vocab_size))
# Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
self.decoder.bias = self.bias
def forward(self, features, **kwargs):
x = self.dense(features)
x = gelu(x)
x = self.layer_norm(x)
# project back to size of vocabulary with bias
x = self.decoder(x)
return x
@add_start_docstrings(
"""RoBERTa Model transformer with a sequence classification/regression head on top (a linear layer
on top of the pooled output) e.g. for GLUE tasks. """,
ROBERTA_START_DOCSTRING,
)
class RobertaForSequenceClassification(BertPreTrainedModel):
config_class = RobertaConfig
base_model_prefix = "roberta"
def __init__(self, config):
super().__init__(config)
self.num_labels = config.num_labels
self.roberta = RobertaModel(config)
self.classifier = RobertaClassificationHead(config)
self.init_weights()
@add_start_docstrings_to_callable(ROBERTA_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
def forward(
self,
input_ids=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
labels=None,
output_attentions=None,
):
r"""
labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
Labels for computing the sequence classification/regression loss.
Indices should be in :obj:`[0, ..., config.num_labels - 1]`.
If :obj:`config.num_labels == 1` a regression loss is computed (Mean-Square loss),
If :obj:`config.num_labels > 1` a classification loss is computed (Cross-Entropy).
Returns:
:obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.RobertaConfig`) and inputs:
loss (:obj:`torch.FloatTensor` of shape :obj:`(1,)`, `optional`, returned when :obj:`label` is provided):
Classification (or regression if config.num_labels==1) loss.
logits (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, config.num_labels)`):
Classification (or regression if config.num_labels==1) scores (before SoftMax).
hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``config.output_hidden_states=True``):
Tuple of :obj:`torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer)
of shape :obj:`(batch_size, sequence_length, hidden_size)`.
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or ``config.output_attentions=True``):
Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape
:obj:`(batch_size, num_heads, sequence_length, sequence_length)`.
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.
Examples::
from transformers import RobertaTokenizer, RobertaForSequenceClassification
import torch
tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaForSequenceClassification.from_pretrained('roberta-base')
input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0) # Batch size 1
labels = torch.tensor([1]).unsqueeze(0) # Batch size 1
outputs = model(input_ids, labels=labels)
loss, logits = outputs[:2]
"""
outputs = self.roberta(
input_ids,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=output_attentions,
)
sequence_output = outputs[0]
logits = self.classifier(sequence_output)
outputs = (logits,) + outputs[2:]
if labels is not None:
if self.num_labels == 1:
# We are doing regression
loss_fct = MSELoss()
loss = loss_fct(logits.view(-1), labels.view(-1))
else:
loss_fct = CrossEntropyLoss()
loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
outputs = (loss,) + outputs
return outputs # (loss), logits, (hidden_states), (attentions)
@add_start_docstrings(
"""Roberta Model with a multiple choice classification head on top (a linear layer on top of
the pooled output and a softmax) e.g. for RocStories/SWAG tasks. """,
ROBERTA_START_DOCSTRING,
)
class RobertaForMultipleChoice(BertPreTrainedModel):
config_class = RobertaConfig
base_model_prefix = "roberta"
def __init__(self, config):
super().__init__(config)
self.roberta = RobertaModel(config)
self.dropout = nn.Dropout(config.hidden_dropout_prob)
self.classifier = nn.Linear(config.hidden_size, 1)
self.init_weights()
@add_start_docstrings_to_callable(ROBERTA_INPUTS_DOCSTRING.format("(batch_size, num_choices, sequence_length)"))
def forward(
self,
input_ids=None,
token_type_ids=None,
attention_mask=None,
labels=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
output_attentions=None,
):
r"""
labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
Labels for computing the multiple choice classification loss.
Indices should be in ``[0, ..., num_choices]`` where `num_choices` is the size of the second dimension
of the input tensors. (see `input_ids` above)
Returns:
:obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.RobertaConfig`) and inputs:
loss (:obj:`torch.FloatTensor`` of shape `(1,)`, `optional`, returned when :obj:`labels` is provided):
Classification loss.
classification_scores (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, num_choices)`):
`num_choices` is the second dimension of the input tensors. (see `input_ids` above).
Classification scores (before SoftMax).
hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``config.output_hidden_states=True``):
Tuple of :obj:`torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer)
of shape :obj:`(batch_size, sequence_length, hidden_size)`.
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or ``config.output_attentions=True``):
Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape
:obj:`(batch_size, num_heads, sequence_length, sequence_length)`.
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.
Examples::
from transformers import RobertaTokenizer, RobertaForMultipleChoice
import torch
tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaForMultipleChoice.from_pretrained('roberta-base')
choices = ["Hello, my dog is cute", "Hello, my cat is amazing"]
input_ids = torch.tensor([tokenizer.encode(s, add_special_tokens=True) for s in choices]).unsqueeze(0) # Batch size 1, 2 choices
labels = torch.tensor(1).unsqueeze(0) # Batch size 1
outputs = model(input_ids, labels=labels)
loss, classification_scores = outputs[:2]
"""
num_choices = input_ids.shape[1] if input_ids is not None else inputs_embeds.shape[1]
flat_input_ids = input_ids.view(-1, input_ids.size(-1)) if input_ids is not None else None
flat_position_ids = position_ids.view(-1, position_ids.size(-1)) if position_ids is not None else None
flat_token_type_ids = token_type_ids.view(-1, token_type_ids.size(-1)) if token_type_ids is not None else None
flat_attention_mask = attention_mask.view(-1, attention_mask.size(-1)) if attention_mask is not None else None
flat_inputs_embeds = (
inputs_embeds.view(-1, inputs_embeds.size(-2), inputs_embeds.size(-1))
if inputs_embeds is not None
else None
)
outputs = self.roberta(
flat_input_ids,
position_ids=flat_position_ids,
token_type_ids=flat_token_type_ids,
attention_mask=flat_attention_mask,
head_mask=head_mask,
inputs_embeds=flat_inputs_embeds,
output_attentions=output_attentions,
)
pooled_output = outputs[1]
pooled_output = self.dropout(pooled_output)
logits = self.classifier(pooled_output)
reshaped_logits = logits.view(-1, num_choices)
outputs = (reshaped_logits,) + outputs[2:] # add hidden states and attention if they are here
if labels is not None:
loss_fct = CrossEntropyLoss()
loss = loss_fct(reshaped_logits, labels)
outputs = (loss,) + outputs
return outputs # (loss), reshaped_logits, (hidden_states), (attentions)
@add_start_docstrings(
"""Roberta Model with a token classification head on top (a linear layer on top of
the hidden-states output) e.g. for Named-Entity-Recognition (NER) tasks. """,
ROBERTA_START_DOCSTRING,
)
class RobertaForTokenClassification(BertPreTrainedModel):
config_class = RobertaConfig
base_model_prefix = "roberta"
def __init__(self, config):
super().__init__(config)
self.num_labels = config.num_labels
self.roberta = RobertaModel(config)
self.dropout = nn.Dropout(config.hidden_dropout_prob)
self.classifier = nn.Linear(config.hidden_size, config.num_labels)
self.init_weights()
@add_start_docstrings_to_callable(ROBERTA_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
def forward(
self,
input_ids=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
labels=None,
output_attentions=None,
):
r"""
labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Labels for computing the token classification loss.
Indices should be in ``[0, ..., config.num_labels - 1]``.
Returns:
:obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.RobertaConfig`) and inputs:
loss (:obj:`torch.FloatTensor` of shape :obj:`(1,)`, `optional`, returned when ``labels`` is provided) :
Classification loss.
scores (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, config.num_labels)`)
Classification scores (before SoftMax).
hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``config.output_hidden_states=True``):
Tuple of :obj:`torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer)
of shape :obj:`(batch_size, sequence_length, hidden_size)`.
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or ``config.output_attentions=True``):
Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape
:obj:`(batch_size, num_heads, sequence_length, sequence_length)`.
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.
Examples::
from transformers import RobertaTokenizer, RobertaForTokenClassification
import torch
tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaForTokenClassification.from_pretrained('roberta-base')
input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0) # Batch size 1
labels = torch.tensor([1] * input_ids.size(1)).unsqueeze(0) # Batch size 1
outputs = model(input_ids, labels=labels)
loss, scores = outputs[:2]
"""
outputs = self.roberta(
input_ids,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=output_attentions,
)
sequence_output = outputs[0]
sequence_output = self.dropout(sequence_output)
logits = self.classifier(sequence_output)
outputs = (logits,) + outputs[2:] # add hidden states and attention if they are here
if labels is not None:
loss_fct = CrossEntropyLoss()
# Only keep active parts of the loss
if attention_mask is not None:
active_loss = attention_mask.view(-1) == 1
active_logits = logits.view(-1, self.num_labels)
active_labels = torch.where(
active_loss, labels.view(-1), torch.tensor(loss_fct.ignore_index).type_as(labels)
)
loss = loss_fct(active_logits, active_labels)
else:
loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
outputs = (loss,) + outputs
return outputs # (loss), scores, (hidden_states), (attentions)
class RobertaClassificationHead(nn.Module):
"""Head for sentence-level classification tasks."""
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.dropout = nn.Dropout(config.hidden_dropout_prob)
self.out_proj = nn.Linear(config.hidden_size, config.num_labels)
def forward(self, features, **kwargs):
x = features[:, 0, :] # take <s> token (equiv. to [CLS])
x = self.dropout(x)
x = self.dense(x)
x = torch.tanh(x)
x = self.dropout(x)
x = self.out_proj(x)
return x
@add_start_docstrings(
"""Roberta Model with a span classification head on top for extractive question-answering tasks like SQuAD (a linear layers on top of
the hidden-states output to compute `span start logits` and `span end logits`). """,
ROBERTA_START_DOCSTRING,
)
class RobertaForQuestionAnswering(BertPreTrainedModel):
config_class = RobertaConfig
base_model_prefix = "roberta"
def __init__(self, config):
super().__init__(config)
self.num_labels = config.num_labels
self.roberta = RobertaModel(config)
self.qa_outputs = nn.Linear(config.hidden_size, config.num_labels)
self.init_weights()
@add_start_docstrings_to_callable(ROBERTA_INPUTS_DOCSTRING.format("(batch_size, sequence_length)"))
def forward(
self,
input_ids=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
start_positions=None,
end_positions=None,
output_attentions=None,
):
r"""
start_positions (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
Labels for position (index) of the start of the labelled span for computing the token classification loss.
Positions are clamped to the length of the sequence (`sequence_length`).
Position outside of the sequence are not taken into account for computing the loss.
end_positions (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
Labels for position (index) of the end of the labelled span for computing the token classification loss.
Positions are clamped to the length of the sequence (`sequence_length`).
Position outside of the sequence are not taken into account for computing the loss.
Returns:
:obj:`tuple(torch.FloatTensor)` comprising various elements depending on the configuration (:class:`~transformers.RobertaConfig`) and inputs:
loss (:obj:`torch.FloatTensor` of shape :obj:`(1,)`, `optional`, returned when :obj:`labels` is provided):
Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.
start_scores (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length,)`):
Span-start scores (before SoftMax).
end_scores (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length,)`):
Span-end scores (before SoftMax).
hidden_states (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``config.output_hidden_states=True``):
Tuple of :obj:`torch.FloatTensor` (one for the output of the embeddings + one for the output of each layer)
of shape :obj:`(batch_size, sequence_length, hidden_size)`.
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (:obj:`tuple(torch.FloatTensor)`, `optional`, returned when ``output_attentions=True`` is passed or ``config.output_attentions=True``):
Tuple of :obj:`torch.FloatTensor` (one for each layer) of shape
:obj:`(batch_size, num_heads, sequence_length, sequence_length)`.
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.
Examples::
# The checkpoint roberta-large is not fine-tuned for question answering. Please see the
# examples/question-answering/run_squad.py example to see how to fine-tune a model to a question answering task.
from transformers import RobertaTokenizer, RobertaForQuestionAnswering
import torch
tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaForQuestionAnswering.from_pretrained('roberta-base')
question, text = "Who was <NAME>?", "<NAME> was a nice puppet"
input_ids = tokenizer.encode(question, text)
start_scores, end_scores = model(torch.tensor([input_ids]))
all_tokens = tokenizer.convert_ids_to_tokens(input_ids)
answer = ' '.join(all_tokens[torch.argmax(start_scores) : torch.argmax(end_scores)+1])
"""
outputs = self.roberta(
input_ids,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=output_attentions,
)
sequence_output = outputs[0]
logits = self.qa_outputs(sequence_output)
start_logits, end_logits = logits.split(1, dim=-1)
start_logits = start_logits.squeeze(-1)
end_logits = end_logits.squeeze(-1)
outputs = (start_logits, end_logits,) + outputs[2:]
if start_positions is not None and end_positions is not None:
# If we are on multi-GPU, split add a dimension
if len(start_positions.size()) > 1:
start_positions = start_positions.squeeze(-1)
if len(end_positions.size()) > 1:
end_positions = end_positions.squeeze(-1)
# sometimes the start/end positions are outside our model inputs, we ignore these terms
ignored_index = start_logits.size(1)
start_positions.clamp_(0, ignored_index)
end_positions.clamp_(0, ignored_index)
loss_fct = CrossEntropyLoss(ignore_index=ignored_index)
start_loss = loss_fct(start_logits, start_positions)
end_loss = loss_fct(end_logits, end_positions)
total_loss = (start_loss + end_loss) / 2
outputs = (total_loss,) + outputs
return outputs # (loss), start_logits, end_logits, (hidden_states), (attentions)
```
#### File: src/transformers/tokenization_marian.py
```python
import json
import re
import warnings
from pathlib import Path
from shutil import copyfile
from typing import Dict, List, Optional, Tuple, Union
import sentencepiece
from .tokenization_utils import BatchEncoding, PreTrainedTokenizer
vocab_files_names = {
"source_spm": "source.spm",
"target_spm": "target.spm",
"vocab": "vocab.json",
"tokenizer_config_file": "tokenizer_config.json",
}
# Example URL https://s3.amazonaws.com/models.huggingface.co/bert/Helsinki-NLP/opus-mt-en-de/vocab.json
class MarianTokenizer(PreTrainedTokenizer):
"""Sentencepiece tokenizer for marian. Source and target languages have different SPM models.
The logic is use the relevant source_spm or target_spm to encode txt as pieces, then look up each piece in a vocab dictionary.
Examples::
from transformers import MarianTokenizer
tok = MarianTokenizer.from_pretrained('Helsinki-NLP/opus-mt-en-de')
src_texts = [ "I am a small frog.", "Tom asked his teacher for advice."]
tgt_texts = ["Ich bin ein kleiner Frosch.", "Tom bat seinen Lehrer um Rat."] # optional
batch_enc: BatchEncoding = tok.prepare_translation_batch(src_texts, tgt_texts=tgt_texts)
# keys [input_ids, attention_mask, decoder_input_ids, decoder_attention_mask].
# model(**batch) should work
"""
vocab_files_names = vocab_files_names
model_input_names = ["attention_mask"] # actually attention_mask, decoder_attention_mask
language_code_re = re.compile(">>.+<<") # type: re.Pattern
def __init__(
self,
vocab,
source_spm,
target_spm,
source_lang=None,
target_lang=None,
unk_token="<unk>",
eos_token="</s>",
pad_token="<pad>",
model_max_length=512,
**kwargs
):
super().__init__(
# bos_token=bos_token, unused. Start decoding with config.decoder_start_token_id
model_max_length=model_max_length,
eos_token=eos_token,
unk_token=unk_token,
pad_token=pad_token,
**kwargs,
)
assert Path(source_spm).exists(), f"cannot find spm source {source_spm}"
self.encoder = load_json(vocab)
if self.unk_token not in self.encoder:
raise KeyError("<unk> token must be in vocab")
assert self.pad_token in self.encoder
self.decoder = {v: k for k, v in self.encoder.items()}
self.source_lang = source_lang
self.target_lang = target_lang
self.supported_language_codes: list = [k for k in self.encoder if k.startswith(">>") and k.endswith("<<")]
self.spm_files = [source_spm, target_spm]
# load SentencePiece model for pre-processing
self.spm_source = load_spm(source_spm)
self.spm_target = load_spm(target_spm)
self.current_spm = self.spm_source
# Multilingual target side: default to using first supported language code.
self._setup_normalizer()
def _setup_normalizer(self):
try:
from mosestokenizer import MosesPunctuationNormalizer
self.punc_normalizer = MosesPunctuationNormalizer(self.source_lang)
except ImportError:
warnings.warn("Recommended: pip install mosestokenizer")
self.punc_normalizer = lambda x: x
def normalize(self, x: str) -> str:
"""Cover moses empty string edge case. They return empty list for '' input!"""
return self.punc_normalizer(x) if x else ""
def _convert_token_to_id(self, token):
return self.encoder.get(token, self.encoder[self.unk_token])
def remove_language_code(self, text: str):
"""Remove language codes like <<fr>> before sentencepiece"""
match = self.language_code_re.match(text)
code: list = [match.group(0)] if match else []
return code, self.language_code_re.sub("", text)
def _tokenize(self, text: str) -> List[str]:
code, text = self.remove_language_code(text)
pieces = self.current_spm.EncodeAsPieces(text)
return code + pieces
def _convert_id_to_token(self, index: int) -> str:
"""Converts an index (integer) in a token (str) using the encoder."""
return self.decoder.get(index, self.unk_token)
def convert_tokens_to_string(self, tokens: List[str]) -> str:
"""Uses target language sentencepiece model"""
return self.spm_target.DecodePieces(tokens)
def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None) -> List[int]:
"""Build model inputs from a sequence by appending eos_token_id."""
if token_ids_1 is None:
return token_ids_0 + [self.eos_token_id]
# We don't expect to process pairs, but leave the pair logic for API consistency
return token_ids_0 + token_ids_1 + [self.eos_token_id]
def prepare_translation_batch(
self,
src_texts: List[str],
tgt_texts: Optional[List[str]] = None,
max_length: Optional[int] = None,
pad_to_max_length: bool = True,
return_tensors: str = "pt",
) -> BatchEncoding:
"""Prepare model inputs for translation. For best performance, translate one sentence at a time.
Arguments:
src_texts: list of src language texts
tgt_texts: list of tgt language texts
max_length: (None) defer to config (1024 for mbart-large-en-ro)
pad_to_max_length: (bool)
return_tensors: (str) default "pt" returns pytorch tensors, pass None to return lists.
Returns:
BatchEncoding: with keys [input_ids, attention_mask, decoder_input_ids, decoder_attention_mask]
all shaped bs, seq_len. (BatchEncoding is a dict of string -> tensor or lists).
If no tgt_text is specified, the only keys will be input_ids and attention_mask.
"""
if "" in src_texts:
raise ValueError(f"found empty string in src_texts: {src_texts}")
self.current_spm = self.spm_source
src_texts = [self.normalize(t) for t in src_texts] # this does not appear to do much
model_inputs: BatchEncoding = self.batch_encode_plus(
src_texts,
add_special_tokens=True,
return_tensors=return_tensors,
max_length=max_length,
pad_to_max_length=pad_to_max_length,
)
if tgt_texts is None:
return model_inputs
self.current_spm = self.spm_target
decoder_inputs: BatchEncoding = self.batch_encode_plus(
tgt_texts,
add_special_tokens=True,
return_tensors=return_tensors,
max_length=max_length,
pad_to_max_length=pad_to_max_length,
)
for k, v in decoder_inputs.items():
model_inputs[f"decoder_{k}"] = v
self.current_spm = self.spm_source
return model_inputs
@property
def vocab_size(self) -> int:
return len(self.encoder)
def save_vocabulary(self, save_directory: str) -> Tuple[str]:
"""save vocab file to json and copy spm files from their original path."""
save_dir = Path(save_directory)
assert save_dir.is_dir(), f"{save_directory} should be a directory"
save_json(self.encoder, save_dir / self.vocab_files_names["vocab"])
for orig, f in zip(["source.spm", "target.spm"], self.spm_files):
dest_path = save_dir / Path(f).name
if not dest_path.exists():
copyfile(f, save_dir / orig)
return tuple(save_dir / f for f in self.vocab_files_names)
def get_vocab(self) -> Dict:
vocab = self.encoder.copy()
vocab.update(self.added_tokens_encoder)
return vocab
def __getstate__(self) -> Dict:
state = self.__dict__.copy()
state.update({k: None for k in ["spm_source", "spm_target", "current_spm", "punc_normalizer"]})
return state
def __setstate__(self, d: Dict) -> None:
self.__dict__ = d
self.spm_source, self.spm_target = (load_spm(f) for f in self.spm_files)
self.current_spm = self.spm_source
self._setup_normalizer()
def num_special_tokens_to_add(self, **unused):
"""Just EOS"""
return 1
def _special_token_mask(self, seq):
all_special_ids = set(self.all_special_ids) # call it once instead of inside list comp
all_special_ids.remove(self.unk_token_id) # <unk> is only sometimes special
return [1 if x in all_special_ids else 0 for x in seq]
def get_special_tokens_mask(
self, token_ids_0: List, token_ids_1: Optional[List] = None, already_has_special_tokens: bool = False
) -> List[int]:
"""Get list where entries are [1] if a token is [eos] or [pad] else 0."""
if already_has_special_tokens:
return self._special_token_mask(token_ids_0)
elif token_ids_1 is None:
return self._special_token_mask(token_ids_0) + [1]
else:
return self._special_token_mask(token_ids_0 + token_ids_1) + [1]
def load_spm(path: str) -> sentencepiece.SentencePieceProcessor:
spm = sentencepiece.SentencePieceProcessor()
spm.Load(path)
return spm
def save_json(data, path: str) -> None:
with open(path, "w") as f:
json.dump(data, f, indent=2)
def load_json(path: str) -> Union[Dict, List]:
with open(path, "r") as f:
return json.load(f)
```
|
{
"source": "JetRunner/unihan-lm",
"score": 3
}
|
#### File: unihan-lm/unihan/unihan_union_find.py
```python
import sys
def decode_unicode(code):
if code.startswith('U+'):
code = code[2:]
return chr(int(code.split('<')[0], 16))
def get_vocabs(vocab_path):
f = open(vocab_path)
l = []
for line in f:
l.append(line.strip().split()[0])
return l
def char_to_id(file_path='./Unihan_Variants.txt'):
vocabs = get_vocabs()
f = open(file_path)
d, d_r = {}, {}
cnt = 0
for line in f:
if line.startswith('#') or line.strip() == '': # comment line
continue
src, typ, tgt = line.strip().split('\t')
if decode_unicode(src) in vocabs and decode_unicode(src) not in d:
d[decode_unicode(src)] = cnt
d_r[cnt] = decode_unicode(src)
cnt += 1
for dec in tgt.split():
if decode_unicode(dec) in vocabs and decode_unicode(dec) not in d:
d[decode_unicode(dec)] = cnt
d_r[cnt] = decode_unicode(dec)
cnt += 1
return d, d_r, cnt
def unihan_to_conn(char_id,
replace_type='kSemanticVariant&kSimplifiedVariant&kTraditionalVariant&kZVariant',
file_path='./Unihan_Variants.txt'):
replace_types = replace_type.strip().split('&')
f = open(file_path)
l = []
for line in f:
if line.startswith('#') or line.strip() == '': # comment line
continue
src, typ, tgt = line.strip().split('\t')
if typ not in replace_types:
continue
if decode_unicode(src) not in char_id:
continue
src_id = char_id[decode_unicode(src)]
for dec in tgt.split():
if decode_unicode(dec) not in char_id:
continue
dec_id = char_id[decode_unicode(dec)]
l.append((dec_id, src_id))
return l
def get_convert_dict(replace_type, file_path='./Unihan_Variants.txt'):
replace_type = replace_type.strip()
f = open(file_path)
d = {}
# compositional dict
if '_' in replace_type:
type_1, type_2 = replace_type.split('_')
d_1 = get_convert_dict(type_1, file_path)
d_2 = get_convert_dict(type_2, file_path)
for k, v in d_1.items():
if v in d_2:
d[k] = d_2[v]
return dict(d, **d_2)
for line in f:
if line.startswith('#') or line.strip() == '': # comment line
continue
src, typ, tgt = line.strip().split('\t')
if typ == replace_type:
src_ch = decode_unicode(src)
tgt_ch = decode_unicode(tgt)
d[src_ch] = tgt_ch
return d
def find(data, i):
if i != data[i]:
data[i] = find(data, data[i])
return data[i]
def union(data, i, j):
pi, pj = find(data, i), find(data, j)
if pi != pj:
data[pi] = pj
def connected(data, i, j):
return find(data, i) == find(data, j)
def get_char_union_id(file_path='./Unihan_Variants.txt'):
d, d_r, n = char_to_id()
d_resort = {}
d_result = {}
conn = unihan_to_conn(d)
data = [i for i in range(n)]
# union
for i, j in conn:
union(data, i, j)
# find
cnt = 0
for i in range(n):
found = find(data, i)
if found not in d_resort:
d_resort[found] = cnt
cnt += 1
# if need id
d_result[d_r[i]] = d_resort[found]
# if need substituted char
# d_result[d_r[i]] = d_r[found]
return d_result, cnt
def check_if_all_chars_in_vocab(char_union_id):
l = get_vocabs()
for key in char_union_id:
assert key in l
if __name__ == '__main__':
char_union_id, cnt = get_char_union_id()
check_if_all_chars_in_vocab(char_union_id, '/path/to/vocab')
print(cnt, char_union_id)
```
|
{
"source": "Jetsetter/graphyte",
"score": 3
}
|
#### File: Jetsetter/graphyte/graphyte.py
```python
import atexit
import logging
try:
import queue
except ImportError:
import Queue as queue # Python 2.x compatibility
import socket
import threading
import time
__all__ = ['Sender', 'init', 'send']
__version__ = '1.7.1'
default_sender = None
logger = logging.getLogger(__name__)
def _has_whitespace(value):
return not value or value.split(None, 1)[0] != value
class Sender:
def __init__(self, host, port=2003, prefix=None, timeout=5, interval=None,
queue_size=None, log_sends=False, protocol='tcp',
batch_size=1000, tags={}, raise_send_errors=False):
"""Initialize a Sender instance, starting the background thread to
send messages at given interval (in seconds) if "interval" is not
None. Send at most "batch_size" messages per socket send operation.
Default protocol is TCP; use protocol='udp' for UDP.
Use "tags" to specify common or default tags for this Sender, which
are sent with each metric along with any tags passed to send().
"""
self.host = host
self.port = port
self.prefix = prefix
self.timeout = timeout
self.interval = interval
self.log_sends = log_sends
self.protocol = protocol
self.batch_size = batch_size
self.tags = tags
self.raise_send_errors = raise_send_errors
if self.interval is not None:
if raise_send_errors:
raise ValueError('raise_send_errors must be disabled when interval is set')
if queue_size is None:
queue_size = int(round(interval)) * 100
self._queue = queue.Queue(maxsize=queue_size)
self._thread = threading.Thread(target=self._thread_loop)
self._thread.daemon = True
self._thread.start()
atexit.register(self.stop)
def __del__(self):
self.stop()
def stop(self):
"""Tell the sender thread to finish and wait for it to stop sending
(should be at most "timeout" seconds).
"""
if self.interval is not None:
self._queue.put_nowait(None)
self._thread.join()
self.interval = None
def build_message(self, metric, value, timestamp, tags={}):
"""Build a Graphite message to send and return it as a byte string."""
if _has_whitespace(metric):
raise ValueError('"metric" must not have whitespace in it')
if not isinstance(value, (int, float)):
raise TypeError('"value" must be an int or a float, not a {}'.format(
type(value).__name__))
all_tags = self.tags.copy()
all_tags.update(tags)
tags_strs = [u';{}={}'.format(k, v) for k, v in sorted(all_tags.items())]
if any(_has_whitespace(t) for t in tags_strs):
raise ValueError('"tags" keys and values must not have whitespace in them')
tags_suffix = ''.join(tags_strs)
message = u'{}{}{} {} {}\n'.format(
self.prefix + '.' if self.prefix else '',
metric,
tags_suffix,
value,
int(round(timestamp))
)
message = message.encode('utf-8')
return message
def send(self, metric, value, timestamp=None, tags={}):
"""Send given metric and (int or float) value to Graphite host.
Performs send on background thread if "interval" was specified when
creating this Sender.
If a "tags" dict is specified, send the tags to the Graphite host along
with the metric, in addition to any default tags passed to Sender() --
the tags argument here overrides any default tags.
"""
if timestamp is None:
timestamp = time.time()
message = self.build_message(metric, value, timestamp, tags=tags)
if self.interval is None:
self.send_socket(message)
else:
try:
self._queue.put_nowait(message)
except queue.Full:
logger.error('queue full when sending {!r}'.format(message))
def send_message(self, message):
if self.protocol == 'tcp':
sock = socket.create_connection((self.host, self.port), self.timeout)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
sock.sendall(message)
finally: # sockets don't support "with" statement on Python 2.x
sock.close()
elif self.protocol == 'udp':
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
sock.sendto(message, (self.host, self.port))
finally:
sock.close()
else:
raise ValueError('"protocol" must be \'tcp\' or \'udp\', not {!r}'.format(self.protocol))
def send_socket(self, message):
"""Low-level function to send message bytes to this Sender's socket.
You should usually call send() instead of this function (unless you're
subclassing or writing unit tests).
"""
if self.log_sends:
start_time = time.time()
try:
self.send_message(message)
except Exception as error:
if self.raise_send_errors:
raise
logger.error('error sending message {!r}: {}'.format(message, error))
else:
if self.log_sends:
elapsed_time = time.time() - start_time
logger.info('sent message {!r} to {}:{} in {:.03f} seconds'.format(
message, self.host, self.port, elapsed_time))
def _thread_loop(self):
"""Background thread used when Sender is in asynchronous/interval mode."""
last_check_time = time.time()
messages = []
while True:
# Get first message from queue, blocking until the next time we
# should be sending
time_since_last_check = time.time() - last_check_time
time_till_next_check = max(0, self.interval - time_since_last_check)
try:
message = self._queue.get(timeout=time_till_next_check)
except queue.Empty:
pass
else:
if message is None:
# None is the signal to stop this background thread
break
messages.append(message)
# Get any other messages currently on queue without blocking,
# paying attention to None ("stop thread" signal)
should_stop = False
while True:
try:
message = self._queue.get_nowait()
except queue.Empty:
break
if message is None:
should_stop = True
break
messages.append(message)
if should_stop:
break
# If it's time to send, send what we've collected
current_time = time.time()
if current_time - last_check_time >= self.interval:
last_check_time = current_time
for i in range(0, len(messages), self.batch_size):
batch = messages[i:i + self.batch_size]
self.send_socket(b''.join(batch))
messages = []
# Send any final messages before exiting thread
for i in range(0, len(messages), self.batch_size):
batch = messages[i:i + self.batch_size]
self.send_socket(b''.join(batch))
def init(*args, **kwargs):
"""Initialize default Sender instance with given args."""
global default_sender
default_sender = Sender(*args, **kwargs)
def send(*args, **kwargs):
"""Send message using default Sender instance."""
default_sender.send(*args, **kwargs)
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('metric',
help='name of metric to send')
parser.add_argument('value', type=float,
help='numeric value to send')
parser.add_argument('-s', '--server', default='localhost',
help='hostname of Graphite server to send to, default %(default)s')
parser.add_argument('-p', '--port', type=int, default=2003,
help='port to send message to, default %(default)d')
parser.add_argument('-u', '--udp', action='store_true',
help='send via UDP instead of TCP')
parser.add_argument('-t', '--timestamp', type=int,
help='Unix timestamp for message (defaults to current time)')
parser.add_argument('-q', '--quiet', action='store_true',
help="quiet mode (don't log send to stdout)")
args = parser.parse_args()
if not args.quiet:
logging.basicConfig(level=logging.INFO, format='%(message)s')
sender = Sender(args.server, port=args.port, log_sends=not args.quiet,
protocol='udp' if args.udp else 'tcp')
sender.send(args.metric, args.value, timestamp=args.timestamp)
```
|
{
"source": "Jetsie/HeroVNC-master",
"score": 2
}
|
#### File: Jetsie/HeroVNC-master/app.py
```python
from flask import Flask, render_template, send_from_directory
app = Flask(__name__, static_folder='static')
@app.route('/', strict_slashes=False)
def index():
return render_template('index.html')
@app.route('/<path:filename>', strict_slashes=False)
def send_file(filename):
return send_from_directory(app.static_folder, filename)
@app.route('/sw.js', strict_slashes=False)
def sw():
return send_from_directory(app.static_folder, 'sw.js')
@app.route('/manifest.json', strict_slashes=False)
def manifest():
return send_from_directory(app.static_folder, 'manifest.json')
@app.route('/app/static/app.js', strict_slashes=False)
def app_js():
return send_from_directory(app.static_folder, 'app.js')
if __name__ == '__main__': app.run(debug=True)
```
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.