hexsha stringlengths 40 40 | size int64 3 1.03M | ext stringclasses 10
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 3 972 | max_stars_repo_name stringlengths 6 130 | max_stars_repo_head_hexsha stringlengths 40 78 | max_stars_repo_licenses listlengths 1 10 | max_stars_count int64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 3 972 | max_issues_repo_name stringlengths 6 130 | max_issues_repo_head_hexsha stringlengths 40 78 | max_issues_repo_licenses listlengths 1 10 | max_issues_count int64 1 116k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 3 972 | max_forks_repo_name stringlengths 6 130 | max_forks_repo_head_hexsha stringlengths 40 78 | max_forks_repo_licenses listlengths 1 10 | max_forks_count int64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 3 1.03M | avg_line_length float64 1.13 941k | max_line_length int64 2 941k | alphanum_fraction float64 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
85249d1653061e169c5b067e78d369387f6c900c | 21,522 | py | Python | adaptations/train_ssl.py | jamycheung/Trans4PASS | 54a0daea740ae1f2483e1402e3a7a42d0dead822 | [
"Apache-2.0"
] | 7 | 2022-03-03T22:35:53.000Z | 2022-03-30T06:48:36.000Z | adaptations/train_ssl.py | jamycheung/Trans4PASS | 54a0daea740ae1f2483e1402e3a7a42d0dead822 | [
"Apache-2.0"
] | null | null | null | adaptations/train_ssl.py | jamycheung/Trans4PASS | 54a0daea740ae1f2483e1402e3a7a42d0dead822 | [
"Apache-2.0"
] | null | null | null | import glob
import shutil
import torch
import torch.nn as nn
from torch.utils import data, model_zoo
import numpy as np
from torch.autograd import Variable
import torch.optim as optim
import torch.backends.cudnn as cudnn
import torch.nn.functional as F
import logging, sys
import time
from tensorboardX import SummaryWriter
from model.trans4pass import Trans4PASS_v1, Trans4PASS_v2
from model.discriminator import FCDiscriminator
from dataset.cs_dataset_src import CSSrcDataSet
from dataset.densepass_dataset import densepassDataSet, densepassTestDataSet
from compute_iou import compute_mIoU
import argparse
import os
import os.path as osp
from PIL import Image
from torchvision import transforms
from compute_iou import fast_hist, per_class_iu
IMG_MEAN = np.array((104.00698793, 116.66876762, 122.67891434), dtype=np.float32)
MODEL = 'Trans4PASS_v1'
EMB_CHANS = 128
BATCH_SIZE = 2
ITER_SIZE = 1
NUM_WORKERS = 0
SOURCE_NAME = 'CS'
TARGET_NAME = 'DensePASS'
DATA_DIRECTORY = 'datasets/cityscapes'
DATA_LIST_PATH = 'dataset/cityscapes_list/train.txt'
IGNORE_LABEL = 255
INPUT_SIZE = '1024,512'
DATA_DIRECTORY_TARGET = 'datasets/DensePASS'
DATA_LIST_PATH_TARGET = 'dataset/densepass_list/train.txt'
SSL_DIR = './pseudo_{}_{}_ms'.format(TARGET_NAME, MODEL)
DATA_LIST_PATH_TARGET_TEST = 'dataset/densepass_list/val.txt'
INPUT_SIZE_TARGET = '2048,400'
TARGET_TRANSFORM = 'FixScaleRandomCropWH'
INPUT_SIZE_TARGET_TEST = '2048,400'
LEARNING_RATE = 2.5e-6
MOMENTUM = 0.9
NUM_CLASSES = 19
NUM_STEPS = 100000
NUM_STEPS_STOP = 80000 # early stopping
NUM_PROTOTYPE = 50
POWER = 0.9
RANDOM_SEED = 1234
RESTORE_FROM = 'snapshots/CS2DensePASS_Trans4PASS_v1_WarmUp/BestCS2DensePASS_G.pth'
SAVE_NUM_IMAGES = 2
SAVE_PRED_EVERY = 100
DIR_NAME = '{}2{}_{}_SSL/'.format(SOURCE_NAME, TARGET_NAME, MODEL)
SNAPSHOT_DIR = './snapshots/' + DIR_NAME
WEIGHT_DECAY = 0.0005
# LOG_DIR = './log'
LOG_DIR = SNAPSHOT_DIR
SAVE_PATH = './result/' + DIR_NAME
LEARNING_RATE_D = 1e-4
LAMBDA_ADV_TARGET = 0.001
LAMBDA_SSL = 1
TARGET = 'densepass'
SET = 'train'
NAME_CLASSES = [
"road",
"sidewalk",
"building",
"wall",
"fence",
"pole",
"light",
"sign",
"vegetation",
"terrain",
"sky",
"person",
"rider",
"car",
"truck",
"bus",
"train",
"motocycle",
"bicycle"]
def get_arguments():
"""Parse all the arguments provided from the CLI.
Returns:
A list of parsed arguments.
"""
parser = argparse.ArgumentParser(description="Network")
parser.add_argument("--model", type=str, default=MODEL,
help="available options : Trans4PASS_v1, Trans4PASS_v2")
parser.add_argument("--emb-chans", type=int, default=EMB_CHANS,
help="Number of channels in decoder head.")
parser.add_argument("--target", type=str, default=TARGET,
help="available options : cityscapes")
parser.add_argument("--batch-size", type=int, default=BATCH_SIZE,
help="Number of images sent to the network in one step.")
parser.add_argument("--iter-size", type=int, default=ITER_SIZE,
help="Accumulate gradients for ITER_SIZE iterations.")
parser.add_argument("--num-workers", type=int, default=NUM_WORKERS,
help="number of workers for multithread dataloading.")
parser.add_argument("--data-dir", type=str, default=DATA_DIRECTORY,
help="Path to the directory containing the source dataset.")
parser.add_argument("--data-list", type=str, default=DATA_LIST_PATH,
help="Path to the file listing the images in the source dataset.")
parser.add_argument("--ignore-label", type=int, default=IGNORE_LABEL,
help="The index of the label to ignore during the training.")
parser.add_argument("--input-size", type=str, default=INPUT_SIZE,
help="Comma-separated string with height and width of source images.")
parser.add_argument("--data-dir-target", type=str, default=DATA_DIRECTORY_TARGET,
help="Path to the directory containing the target dataset.")
parser.add_argument("--data-list-target", type=str, default=DATA_LIST_PATH_TARGET,
help="Path to the file listing the images in the target dataset.")
parser.add_argument("--data-list-target-test", type=str, default=DATA_LIST_PATH_TARGET_TEST,
help="Path to the file listing the images in the target val dataset.")
parser.add_argument("--input-size-target", type=str, default=INPUT_SIZE_TARGET,
help="Comma-separated string with height and width of target images.")
parser.add_argument("--is-training", action="store_true",
help="Whether to updates the running means and variances during the training.")
parser.add_argument("--learning-rate", type=float, default=LEARNING_RATE,
help="Base learning rate for training with polynomial decay.")
parser.add_argument("--learning-rate-D", type=float, default=LEARNING_RATE_D,
help="Base learning rate for discriminator.")
parser.add_argument("--lambda-adv-target", type=float, default=LAMBDA_ADV_TARGET,
help="lambda_adv for adversarial training.")
parser.add_argument("--momentum", type=float, default=MOMENTUM,
help="Momentum component of the optimiser.")
parser.add_argument("--not-restore-last", action="store_true",
help="Whether to not restore last (FC) layers.")
parser.add_argument("--num-classes", type=int, default=NUM_CLASSES,
help="Number of classes to predict (including background).")
parser.add_argument("--num-steps", type=int, default=NUM_STEPS,
help="Number of training steps.")
parser.add_argument("--num-steps-stop", type=int, default=NUM_STEPS_STOP,
help="Number of training steps for early stopping.")
parser.add_argument("--num-prototype", type=int, default=NUM_PROTOTYPE,
help="Number of prototypes.")
parser.add_argument("--power", type=float, default=POWER,
help="Decay parameter to compute the learning rate.")
parser.add_argument("--random-mirror", action="store_true",
help="Whether to randomly mirror the inputs during the training.")
parser.add_argument("--random-scale", action="store_true",
help="Whether to randomly scale the inputs during the training.")
parser.add_argument("--random-seed", type=int, default=RANDOM_SEED,
help="Random seed to have reproducible results.")
parser.add_argument("--restore-from", type=str, default=RESTORE_FROM,
help="Where restore model parameters from.")
parser.add_argument("--save-num-images", type=int, default=SAVE_NUM_IMAGES,
help="How many images to save.")
parser.add_argument("--save-pred-every", type=int, default=SAVE_PRED_EVERY,
help="Save summaries and checkpoint every often.")
parser.add_argument("--snapshot-dir", type=str, default=SNAPSHOT_DIR,
help="Where to save snapshots of the model.")
parser.add_argument("--weight-decay", type=float, default=WEIGHT_DECAY,
help="Regularisation parameter for L2-loss.")
parser.add_argument("--cpu", action='store_true', help="choose to use cpu device.")
parser.add_argument("--tensorboard", action='store_false', help="choose whether to use tensorboard.")
parser.add_argument("--log-dir", type=str, default=LOG_DIR,
help="Path to the directory of log.")
parser.add_argument("--set", type=str, default=SET,
help="choose adaptation set.")
parser.add_argument("--continue-train", action="store_true",
help="continue training")
parser.add_argument("--save", type=str, default=SAVE_PATH,
help="Path to save result.")
return parser.parse_args()
args = get_arguments()
def setup_logger(name, save_dir, filename="log.txt", mode='w'):
logging.root.name = name
logging.root.setLevel(logging.INFO)
# don't log results for the non-master process
formatter = logging.Formatter("%(levelname)s: %(message)s")
if save_dir:
if not os.path.exists(save_dir):
os.makedirs(save_dir)
fh = logging.FileHandler(os.path.join(save_dir, filename), mode=mode) # 'a+' for add, 'w' for overwrite
fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
logging.root.addHandler(fh)
# else:
ch = logging.StreamHandler(stream=sys.stdout)
ch.setLevel(logging.DEBUG)
ch.setFormatter(formatter)
logging.root.addHandler(ch)
setup_logger('Trans4PASS', SNAPSHOT_DIR)
def lr_poly(base_lr, iter, max_iter, power):
return base_lr * ((1 - float(iter) / max_iter) ** (power))
def adjust_learning_rate(optimizer, i_iter):
lr = lr_poly(args.learning_rate, i_iter, args.num_steps, args.power)
optimizer.param_groups[0]['lr'] = lr
if len(optimizer.param_groups) > 1:
optimizer.param_groups[1]['lr'] = lr * 10
def adjust_learning_rate_D(optimizer, i_iter):
lr = lr_poly(args.learning_rate_D, i_iter, args.num_steps, args.power)
optimizer.param_groups[0]['lr'] = lr
if len(optimizer.param_groups) > 1:
optimizer.param_groups[1]['lr'] = lr * 10
def amp_backward(loss, optimizer, retain_graph=False):
loss.backward(retain_graph=retain_graph)
def load_my_state_dict(model, state_dict): # custom function to load model when not all dict elements
own_state = model.state_dict()
for name, param in state_dict.items():
if name not in own_state:
if name.startswith("module."):
own_state[name.split("module.")[-1]].copy_(param)
else:
logging.info(name, " not loaded")
continue
else:
own_state[name].copy_(param)
return model
def main():
"""Create the model and start the training."""
device = torch.device("cuda" if not args.cpu else "cpu")
cudnn.benchmark = True
cudnn.enabled = True
w, h = map(int, args.input_size.split(','))
input_size = (w, h)
w, h = map(int, args.input_size_target.split(','))
input_size_target = (w, h)
w, h = map(int, INPUT_SIZE_TARGET_TEST.split(','))
input_size_target_test = (w, h)
Iter = 0
bestIoU = 0
mIoU = 0
# Create network
# init G
if args.model == 'Trans4PASS_v1':
model = Trans4PASS_v1(num_classes=args.num_classes, emb_chans=args.emb_chans)
elif args.model == 'Trans4PASS_v2':
model = Trans4PASS_v2(num_classes=args.num_classes, emb_chans=args.emb_chans)
else:
raise ValueError
saved_state_dict = torch.load(args.restore_from, map_location=lambda storage, loc: storage)
if 'state_dict' in saved_state_dict.keys():
saved_state_dict = saved_state_dict['state_dict']
if args.continue_train:
if list(saved_state_dict.keys())[0].split('.')[0] == 'module':
for key in saved_state_dict.keys():
saved_state_dict['.'.join(key.split('.')[1:])] = saved_state_dict.pop(key)
model.load_state_dict(saved_state_dict)
else:
# model = load_my_state_dict(model, saved_state_dict)
msg = model.load_state_dict(saved_state_dict, strict=False)
logging.info(msg)
# init D
model_D = FCDiscriminator(num_classes=args.num_classes).to(device)
model.train()
model.to(device)
model_D.train()
model_D.to(device)
if not os.path.exists(args.snapshot_dir):
os.makedirs(args.snapshot_dir)
else:
script = os.path.abspath(__file__)
shutil.copy(script, args.snapshot_dir)
# init data loader
trainset = CSSrcDataSet(args.data_dir, args.data_list, max_iters=args.num_steps * args.iter_size * args.batch_size,
crop_size=input_size, scale=args.random_scale, mirror=args.random_mirror, mean=IMG_MEAN, set=args.set)
trainloader = data.DataLoader(trainset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers,
pin_memory=True)
trainloader_iter = enumerate(trainloader)
# --- SSL_DIR
targetset = densepassDataSet(args.data_dir_target, args.data_list_target, max_iters=args.num_steps * args.iter_size * args.batch_size,
crop_size=input_size_target, scale=False, mirror=args.random_mirror, mean=IMG_MEAN, set=args.set,
ssl_dir=SSL_DIR, trans=TARGET_TRANSFORM)
targetloader = data.DataLoader(targetset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers,
pin_memory=True)
targetloader_iter = enumerate(targetloader)
logging.info('\n--- load TEST dataset ---')
# test_h, test_w = 400, 2048
test_w, test_h = input_size_target_test
targettestset = densepassTestDataSet(args.data_dir_target, args.data_list_target_test, crop_size=(test_w, test_h),
mean=IMG_MEAN, scale=False, mirror=False, set='val')
testloader = data.DataLoader(targettestset, batch_size=1, shuffle=False, pin_memory=True)
# test_interp = nn.Upsample(size=(test_h, test_w), mode='bilinear', align_corners=True)
model.train()
# init optimizer
optimizer = optim.SGD(model.optim_parameters(args),
lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay)
optimizer.zero_grad()
optimizer_D = optim.Adam(model_D.parameters(), lr=args.learning_rate_D, betas=(0.9, 0.99))
optimizer_D.zero_grad()
# init loss
weight = torch.ones(NUM_CLASSES)
weight[0] = 2.8149201869965
weight[1] = 6.9850029945374
weight[2] = 3.7890393733978
weight[3] = 9.9428062438965
weight[4] = 9.7702074050903
weight[5] = 9.5110931396484
weight[6] = 10.311357498169
weight[7] = 10.026463508606
weight[8] = 4.6323022842407
weight[9] = 9.5608062744141
weight[10] = 7.8698215484619
weight[11] = 9.5168733596802
weight[12] = 10.373730659485
weight[13] = 6.6616044044495
weight[14] = 10.260489463806
weight[15] = 10.287888526917
weight[16] = 10.289801597595
weight[17] = 10.405355453491
weight[18] = 10.138095855713
# weight[19] = 0
weight = weight.to(device)
bce_loss = torch.nn.BCEWithLogitsLoss()
seg_loss = torch.nn.CrossEntropyLoss(ignore_index=255, weight=weight)
seg_loss_target = torch.nn.CrossEntropyLoss(ignore_index=255)
# L1_loss = torch.nn.L1Loss(reduction='none')
interp = nn.Upsample(size=(input_size[1], input_size[0]), mode='bilinear', align_corners=True)
interp_target = nn.Upsample(size=(input_size_target[1], input_size_target[0]), mode='bilinear', align_corners=True)
# test_interp = nn.Upsample(size=(1024, 2048), mode='bilinear', align_corners=True)
# labels for adversarial training
source_label = 0
target_label = 1
# set up tensor board
if args.tensorboard:
if not os.path.exists(args.log_dir):
os.makedirs(args.log_dir)
writer = SummaryWriter(args.log_dir)
# start training
for i_iter in range(Iter, args.num_steps):
loss_seg_value = 0
loss_seg_value_t = 0
loss_adv_target_value = 0
loss_D_value = 0
optimizer.zero_grad()
adjust_learning_rate(optimizer, i_iter)
optimizer_D.zero_grad()
adjust_learning_rate_D(optimizer_D, i_iter)
for sub_i in range(args.iter_size):
# train G
for param in model_D.parameters():
param.requires_grad = False
# train with source
_, batch = trainloader_iter.__next__()
images, labels, _, _ = batch
images = images.to(device)
labels = labels.long().to(device)
src_features, pred = model(images) # src_feature = [c1, c2, c3, c4]
src_feature = sum(src_features)
pred = interp(pred)
loss_seg = seg_loss(pred, labels)
loss = loss_seg
# proper normalization
loss = loss / args.iter_size
amp_backward(loss, optimizer)
loss_seg_value += loss_seg.item() / args.iter_size
# === train with target
_, batch = targetloader_iter.__next__()
images, trg_labels, _, _ = batch
images = images.to(device)
trg_labels = trg_labels.long().to(device)
trg_features, pred_target = model(images)
trg_feature = sum(trg_features)
pred_target = interp_target(pred_target)
loss_seg_trg = seg_loss_target(pred_target, trg_labels)
D_out = model_D(F.softmax(pred_target, dim=1))
loss_adv_target = bce_loss(D_out, torch.FloatTensor(D_out.data.size()).fill_(source_label).to(device))
loss = loss_seg_trg * LAMBDA_SSL
loss = loss / args.iter_size
amp_backward(loss, optimizer)
loss_seg_value_t += loss_seg_trg.item() / args.iter_size
loss_adv_target_value += loss_adv_target.item() / args.iter_size
# === train D
for param in model_D.parameters():
param.requires_grad = True
# train with source
pred = pred.detach()
D_out = model_D(F.softmax(pred, dim=1))
loss_D = bce_loss(D_out, torch.FloatTensor(D_out.data.size()).fill_(source_label).to(device))
loss_D = loss_D / args.iter_size / 2
amp_backward(loss_D, optimizer_D)
loss_D_value += loss_D.item()
# train with target
pred_target = pred_target.detach()
D_out = model_D(F.softmax(pred_target, dim=1))
loss_D = bce_loss(D_out, torch.FloatTensor(D_out.data.size()).fill_(target_label).to(device))
loss_D = loss_D / args.iter_size / 2
amp_backward(loss_D, optimizer_D)
loss_D_value += loss_D.item()
optimizer.step()
optimizer_D.step()
if args.tensorboard:
scalar_info = {
'loss_seg': loss_seg_value,
'loss_seg_t': loss_seg_value_t,
'loss_adv_target': loss_adv_target_value,
'loss_D': loss_D_value,
'miou_T': mIoU
}
if i_iter % 10 == 0:
for key, val in scalar_info.items():
writer.add_scalar(key, val, i_iter)
if i_iter % 10 == 0:
logging.info('iter={0:8d}/{1:8d}, l_seg={2:.3f}, l_seg_t={5:.3f}, l_adv={3:.3f} l_D={4:.3f}'.format(
i_iter, args.num_steps, loss_seg_value, loss_adv_target_value, loss_D_value, loss_seg_value_t))
if i_iter >= args.num_steps_stop - 1:
logging.info('save model ...')
torch.save(model.state_dict(), osp.join(args.snapshot_dir, 'CS_' + str(args.num_steps_stop) + '.pth'))
torch.save(model_D.state_dict(), osp.join(args.snapshot_dir, 'CS_' + str(args.num_steps_stop) + '_D.pth'))
break
if i_iter % args.save_pred_every == 0 and i_iter != 0:
logging.info('taking snapshot ...')
# if not os.path.exists(args.save):
# os.makedirs(args.save)
model.eval()
hist = np.zeros((args.num_classes, args.num_classes))
for index, batch in enumerate(testloader):
image, label, _, name = batch
with torch.no_grad():
output1, output2 = model(Variable(image).to(device))
# output = test_interp(output2).cpu().data[0].numpy()
output = output2.cpu().data[0].numpy()
output = output.transpose(1,2,0)
output = np.asarray(np.argmax(output, axis=2), dtype=np.uint8)
label = label.cpu().data[0].numpy()
hist += fast_hist(label.flatten(), output.flatten(), args.num_classes)
mIoUs = per_class_iu(hist)
for ind_class in range(args.num_classes):
logging.info('===>{:<15}:\t{}'.format(NAME_CLASSES[ind_class], str(round(mIoUs[ind_class] * 100, 2))))
mIoU = round(np.nanmean(mIoUs) * 100, 2)
logging.info('===> mIoU: ' + str(mIoU))
if mIoU > bestIoU:
bestIoU = mIoU
pre_filename = osp.join(args.snapshot_dir, 'Best*.pth')
pre_filename = glob.glob(pre_filename)
try:
for p in pre_filename:
os.remove(p)
except OSError as e:
logging.info(e)
torch.save(model.state_dict(), osp.join(args.snapshot_dir, 'Best{}2{}_{}iter_{}miou.pth'.format(
SOURCE_NAME, TARGET_NAME, str(i_iter), str(bestIoU))))
torch.save(model_D.state_dict(), osp.join(args.snapshot_dir, 'Best{}2{}_{}iter_D_{}miou.pth'.format(
SOURCE_NAME, TARGET_NAME, str(i_iter), str(bestIoU))))
model.train()
if args.tensorboard:
writer.close()
if __name__ == '__main__':
main()
| 41.871595 | 138 | 0.636651 |
cee042c2d9d24bc3eee06652c2b4ab69fd446792 | 2,430 | py | Python | wolframclient/tests/externalevaluate/ev_loop.py | jldohmann/WolframClientForPython | 15cb8ba21f8a08ab17f041f2cbf46ae165e64004 | [
"MIT"
] | null | null | null | wolframclient/tests/externalevaluate/ev_loop.py | jldohmann/WolframClientForPython | 15cb8ba21f8a08ab17f041f2cbf46ae165e64004 | [
"MIT"
] | null | null | null | wolframclient/tests/externalevaluate/ev_loop.py | jldohmann/WolframClientForPython | 15cb8ba21f8a08ab17f041f2cbf46ae165e64004 | [
"MIT"
] | 1 | 2020-05-16T13:18:02.000Z | 2020-05-16T13:18:02.000Z | from __future__ import absolute_import, print_function, unicode_literals
from threading import Thread
import zmq
from wolframclient.language import wl
from wolframclient.serializers import export
from wolframclient.utils.externalevaluate import EXPORT_KWARGS, StdoutProxy, start_zmq_loop
from wolframclient.utils.tests import TestCase as BaseTestCase
STRING = "foo"
STRING_NEWLINE = "abc\nABC"
STRING_MULTILINE = """first
second
third
"""
class TestCase(BaseTestCase):
def compare(self, string_version, result):
self.assertEqual(string_version, export(result, **EXPORT_KWARGS))
def test_zmq_loop(self):
port = 9000
messages = [("a = 2", wl.Null), ("a", 2)]
def threaded_function(port=port, message_limit=len(messages)):
start_zmq_loop(port=port, message_limit=message_limit, write_to_stdout=False)
thread = Thread(target=threaded_function)
thread.start()
client = zmq.Context().socket(zmq.PAIR)
client.connect("tcp://127.0.0.1:%s" % port)
for message, result in messages:
client.send(export({"input": message}, target_format="wxf"))
msg = client.recv()
self.compare(msg, result)
def test_stdout_proxy(self):
output = []
class TestStdoutProxy(StdoutProxy):
def send_lines(self, *lines):
# this custom class makes us test that strings are sent correctly
# without dealing with Print and exported code
output.extend(lines)
proxy = TestStdoutProxy(None)
proxy.write(STRING)
self.assertEqual(output, [])
proxy.write("\n")
self.assertEqual(output, ["foo"])
proxy.write(STRING)
self.assertEqual(output, ["foo"])
proxy.write(STRING_NEWLINE)
self.assertEqual(output, ["foo", "fooabc"])
proxy.write(STRING_NEWLINE)
self.assertEqual(output, ["foo", "fooabc", "ABCabc"])
proxy.write(STRING_MULTILINE)
self.assertEqual(output, ["foo", "fooabc", "ABCabc", "ABCfirst", "second", "third"])
proxy.write(STRING_NEWLINE)
self.assertEqual(
output, ["foo", "fooabc", "ABCabc", "ABCfirst", "second", "third", "abc"]
)
proxy.flush()
self.assertEqual(
output, ["foo", "fooabc", "ABCabc", "ABCfirst", "second", "third", "abc", "ABC"]
)
| 26.129032 | 92 | 0.62963 |
93f2bb78b98d78120a03c3ea12ce0f7ab13ed604 | 85,436 | py | Python | tests/app/main/views/test_send.py | karlchillmaid/notifications-admin | 9ef6da4ef9e2fa97b7debb4b573cb035a5cb8880 | [
"MIT"
] | null | null | null | tests/app/main/views/test_send.py | karlchillmaid/notifications-admin | 9ef6da4ef9e2fa97b7debb4b573cb035a5cb8880 | [
"MIT"
] | null | null | null | tests/app/main/views/test_send.py | karlchillmaid/notifications-admin | 9ef6da4ef9e2fa97b7debb4b573cb035a5cb8880 | [
"MIT"
] | null | null | null | # -*- coding: utf-8 -*-
import sys
import uuid
from functools import partial
from glob import glob
from io import BytesIO
from itertools import repeat
from os import path
from zipfile import BadZipFile
import pytest
from bs4 import BeautifulSoup
from flask import url_for
from notifications_python_client.errors import HTTPError
from notifications_utils.recipients import RecipientCSV
from notifications_utils.template import (
LetterImageTemplate,
LetterPreviewTemplate,
)
from xlrd.biffh import XLRDError
from xlrd.xldate import (
XLDateAmbiguous,
XLDateError,
XLDateNegative,
XLDateTooLarge,
)
from tests import (
validate_route_permission,
validate_route_permission_with_client,
)
from tests.conftest import (
SERVICE_ONE_ID,
active_caseworking_user,
active_user_with_permissions,
fake_uuid,
mock_get_international_service,
mock_get_live_service,
mock_get_service,
mock_get_service_email_template,
mock_get_service_letter_template,
mock_get_service_template,
mock_get_service_template_with_placeholders,
multiple_reply_to_email_addresses,
multiple_sms_senders,
multiple_sms_senders_no_inbound,
multiple_sms_senders_with_diff_default,
no_reply_to_email_addresses,
no_sms_senders,
normalize_spaces,
)
template_types = ['email', 'sms']
unchanging_fake_uuid = uuid.uuid4()
# The * ignores hidden files, eg .DS_Store
test_spreadsheet_files = glob(path.join('tests', 'spreadsheet_files', '*'))
test_non_spreadsheet_files = glob(path.join('tests', 'non_spreadsheet_files', '*'))
@pytest.mark.parametrize('template_mock, sender_data, expected_title, expected_description', [
(
mock_get_service_email_template,
multiple_reply_to_email_addresses,
'Where should replies come back to?',
'Where should replies come back to?',
),
(
mock_get_service_template,
multiple_sms_senders,
'Who should the message come from?',
'Who should the message come from?',
)
])
def test_show_correct_title_and_description_for_sender_type(
client_request,
service_one,
fake_uuid,
template_mock,
sender_data,
expected_title,
expected_description,
mocker
):
template_mock(mocker)
sender_data(mocker)
page = client_request.get(
'.set_sender',
service_id=service_one['id'],
template_id=fake_uuid
)
assert page.select_one('h1').text == expected_title
for element in ('legend', 'legend .visually-hidden'):
assert normalize_spaces(page.select_one(element).text) == expected_description
@pytest.mark.parametrize('template_mock, sender_data', [
(
mock_get_service_email_template,
multiple_reply_to_email_addresses,
),
(
mock_get_service_template,
multiple_sms_senders_with_diff_default
),
(
mock_get_service_template,
multiple_sms_senders_no_inbound
)
])
def test_default_sender_is_checked_and_has_hint(
client_request,
service_one,
fake_uuid,
template_mock,
sender_data,
mocker
):
template_mock(mocker)
sender_data(mocker)
page = client_request.get(
'.set_sender',
service_id=service_one['id'],
template_id=fake_uuid
)
assert page.select('.multiple-choice input')[0].has_attr('checked')
assert normalize_spaces(page.select_one('.multiple-choice label .block-label-hint').text) == "(Default)"
assert not page.select('.multiple-choice input')[1].has_attr('checked')
def test_default_inbound_sender_is_checked_and_has_hint_with_default_and_receives_text(
client_request,
service_one,
fake_uuid,
mock_get_service_template,
multiple_sms_senders
):
page = client_request.get(
'.set_sender',
service_id=service_one['id'],
template_id=fake_uuid
)
assert page.select('.multiple-choice input')[0].has_attr('checked')
assert normalize_spaces(
page.select_one('.multiple-choice label .block-label-hint').text) == "(Default and receives replies)"
assert not page.select('.multiple-choice input')[1].has_attr('checked')
assert not page.select('.multiple-choice input')[2].has_attr('checked')
def test_sms_sender_has_receives_replies_hint(
client_request,
service_one,
fake_uuid,
mock_get_service_template,
multiple_sms_senders
):
page = client_request.get(
'.set_sender',
service_id=service_one['id'],
template_id=fake_uuid
)
assert page.select('.multiple-choice input')[0].has_attr('checked')
assert normalize_spaces(
page.select_one('.multiple-choice label .block-label-hint').text) == "(Default and receives replies)"
assert not page.select('.multiple-choice input')[1].has_attr('checked')
assert not page.select('.multiple-choice input')[2].has_attr('checked')
@pytest.mark.parametrize('template_mock, sender_data', [
(
mock_get_service_email_template,
multiple_reply_to_email_addresses,
),
(
mock_get_service_template,
multiple_sms_senders
)
])
def test_sender_session_is_present_after_selected(
logged_in_client,
service_one,
fake_uuid,
template_mock,
sender_data,
mocker
):
template_mock(mocker)
sender_data(mocker)
logged_in_client.post(
url_for('.set_sender', service_id=service_one['id'], template_id=fake_uuid),
data={'sender': '1234'}
)
with logged_in_client.session_transaction() as session:
assert session['sender_id'] == '1234'
@pytest.mark.parametrize('template_mock, sender_data', [
(
mock_get_service_email_template,
no_reply_to_email_addresses,
),
(
mock_get_service_template,
no_sms_senders
)
])
def test_set_sender_redirects_if_no_sender_data(
logged_in_client,
service_one,
fake_uuid,
template_mock,
sender_data,
mocker
):
template_mock(mocker)
sender_data(mocker)
response = logged_in_client.get(
url_for('.set_sender', service_id=service_one['id'], template_id=fake_uuid)
)
assert response.status_code == 302
expected_url = url_for(
'.send_one_off',
service_id=service_one['id'],
template_id=fake_uuid,
_external=True,
)
assert response.location == expected_url
def test_that_test_files_exist():
assert len(test_spreadsheet_files) == 8
assert len(test_non_spreadsheet_files) == 6
def test_should_not_allow_files_to_be_uploaded_without_the_correct_permission(
logged_in_client,
mock_get_service_template,
service_one,
fake_uuid,
):
template_id = fake_uuid
service_one['permissions'] = []
response = logged_in_client.get(url_for(
'.send_messages',
service_id=service_one['id'],
template_id=template_id),
follow_redirects=True)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert response.status_code == 200
assert page.select('main p')[0].text.strip() == "Sending text messages has been disabled for your service."
assert page.select(".page-footer-back-link")[0].text == "Back to the template"
assert page.select(".page-footer-back-link")[0]['href'] == url_for(
'.view_template',
service_id=service_one['id'],
template_id=template_id,
)
def test_example_spreadsheet(
client_request,
mock_get_service_template_with_placeholders_same_as_recipient,
fake_uuid,
):
page = client_request.get(
'.send_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid
)
assert normalize_spaces(
page.select_one('tbody tr').text
) == (
'1 phone number name date'
)
@pytest.mark.parametrize(
"filename, acceptable_file",
list(zip(test_spreadsheet_files, repeat(True))) +
list(zip(test_non_spreadsheet_files, repeat(False)))
)
def test_upload_files_in_different_formats(
filename,
acceptable_file,
logged_in_client,
service_one,
mocker,
mock_get_service_template,
mock_s3_upload,
fake_uuid,
):
with open(filename, 'rb') as uploaded:
response = logged_in_client.post(
url_for('main.send_messages', service_id=service_one['id'], template_id=fake_uuid),
data={'file': (BytesIO(uploaded.read()), filename)},
content_type='multipart/form-data'
)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
if acceptable_file:
assert mock_s3_upload.call_args[0][1]['data'].strip() == (
"phone number,name,favourite colour,fruit\r\n"
"07739 468 050,Pete,Coral,tomato\r\n"
"07527 125 974,Not Pete,Magenta,Avacado\r\n"
"07512 058 823,Still Not Pete,Crimson,Pear"
)
else:
assert not mock_s3_upload.called
assert normalize_spaces(page.select_one('.banner-dangerous').text) == (
'Couldn’t read {}. Try using a different file format.'.format(filename)
)
@pytest.mark.parametrize('exception, expected_error_message', [
(partial(UnicodeDecodeError, 'codec', b'', 1, 2, 'reason'), (
'Couldn’t read example.xlsx. Try using a different file format.'
)),
(BadZipFile, (
'Couldn’t read example.xlsx. Try using a different file format.'
)),
(XLRDError, (
'Couldn’t read example.xlsx. Try using a different file format.'
)),
(XLDateError, (
'example.xlsx contains numbers or dates that Notify can’t understand. '
'Try formatting all columns as ‘text’ or export your file as CSV.'
)),
(XLDateNegative, (
'example.xlsx contains numbers or dates that Notify can’t understand. '
'Try formatting all columns as ‘text’ or export your file as CSV.'
)),
(XLDateAmbiguous, (
'example.xlsx contains numbers or dates that Notify can’t understand. '
'Try formatting all columns as ‘text’ or export your file as CSV.'
)),
(XLDateTooLarge, (
'example.xlsx contains numbers or dates that Notify can’t understand. '
'Try formatting all columns as ‘text’ or export your file as CSV.'
)),
])
def test_shows_error_if_parsing_exception(
logged_in_client,
mocker,
mock_get_service_template,
exception,
expected_error_message,
):
def _raise_exception_or_partial_exception(file_content, filename):
raise exception()
mocker.patch(
'app.main.views.send.Spreadsheet.from_file',
side_effect=_raise_exception_or_partial_exception
)
response = logged_in_client.post(
url_for('main.send_messages', service_id=SERVICE_ONE_ID, template_id=fake_uuid),
data={'file': (BytesIO(b'example'), 'example.xlsx')},
content_type='multipart/form-data'
)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert normalize_spaces(page.select_one('.banner-dangerous').text) == (
expected_error_message
)
def test_upload_csvfile_with_errors_shows_check_page_with_errors(
logged_in_client,
service_one,
mocker,
mock_get_service_template_with_placeholders,
mock_s3_upload,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
fake_uuid,
):
mocker.patch(
'app.main.views.send.s3download',
return_value="""
phone number,name
+447700900986
+447700900986
"""
)
response = logged_in_client.post(
url_for('main.send_messages', service_id=service_one['id'], template_id=fake_uuid),
data={'file': (BytesIO(''.encode('utf-8')), 'invalid.csv')},
content_type='multipart/form-data',
follow_redirects=True
)
with logged_in_client.session_transaction() as session:
assert 'file_uploads' not in session
assert response.status_code == 200
content = response.get_data(as_text=True)
assert 'There is a problem with invalid.csv' in content
assert '+447700900986' in content
assert 'Missing' in content
assert 'Re-upload your file' in content
@pytest.mark.parametrize('file_contents, expected_error,', [
(
"""
telephone,name
+447700900986
""",
(
'Your file needs a column called ‘phone number’ '
'Right now it has columns called ‘telephone’ and ‘name’. '
'Skip to file contents'
)
),
(
"""
phone number
+447700900986
""",
(
'The columns in your file need to match the double brackets in your template '
'Your file is missing a column called ‘name’. '
'Skip to file contents'
)
),
(
"""
phone number, phone number, PHONE_NUMBER
+447700900111,+447700900222,+447700900333,
""",
(
'Your file has more than one column called ‘phone number’ or ‘PHONE_NUMBER’ '
'Delete or rename one of these columns and try again. '
'Skip to file contents'
)
),
(
"""
phone number, name
""",
(
'Your file is missing some rows '
'It needs at least one row of data. '
'Skip to file contents'
)
),
(
"+447700900986",
(
'Your file is missing some rows '
'It needs at least one row of data, and columns called ‘name’ and ‘phone number’. '
'Skip to file contents'
)
),
(
"",
(
'Your file is missing some rows '
'It needs at least one row of data, and columns called ‘name’ and ‘phone number’. '
'Skip to file contents'
)
),
(
"""
phone number, name
+447700900986, example
, example
+447700900986, example
""",
(
'There is a problem with invalid.csv '
'You need to enter missing data in 1 row '
'Skip to file contents'
)
),
(
"""
phone number, name
+447700900986, example
+447700900986,
+447700900986, example
""",
(
'There is a problem with invalid.csv '
'You need to enter missing data in 1 row '
'Skip to file contents'
)
),
])
def test_upload_csvfile_with_missing_columns_shows_error(
client_request,
mocker,
mock_get_service_template_with_placeholders,
mock_s3_upload,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
service_one,
fake_uuid,
file_contents,
expected_error,
):
mocker.patch('app.main.views.send.s3download', return_value=file_contents)
page = client_request.post(
'main.send_messages', service_id=service_one['id'], template_id=fake_uuid,
_data={'file': (BytesIO(''.encode('utf-8')), 'invalid.csv')},
_follow_redirects=True,
)
with client_request.session_transaction() as session:
assert 'file_uploads' not in session
assert normalize_spaces(page.select('.banner-dangerous')[0].text) == expected_error
def test_upload_csv_invalid_extension(
logged_in_client,
mock_login,
service_one,
mock_get_service_template,
fake_uuid,
):
resp = logged_in_client.post(
url_for('main.send_messages', service_id=service_one['id'], template_id=fake_uuid),
data={'file': (BytesIO('contents'.encode('utf-8')), 'invalid.txt')},
content_type='multipart/form-data',
follow_redirects=True
)
assert resp.status_code == 200
assert "invalid.txt isn’t a spreadsheet that Notify can read" in resp.get_data(as_text=True)
def test_upload_valid_csv_redirects_to_check_page(
client_request,
mock_get_service_template_with_placeholders,
mock_s3_upload,
fake_uuid,
):
client_request.post(
'main.send_messages', service_id=SERVICE_ONE_ID, template_id=fake_uuid,
_data={'file': (BytesIO(''.encode('utf-8')), 'valid.csv')},
_expected_status=302,
expected_redirect='foo'
)
@pytest.mark.parametrize('extra_args, expected_link_in_first_row, expected_recipient, expected_message', [
(
{},
None,
'To: 07700900001',
'Test Service: A, Template <em>content</em> with & entity',
),
(
{'row_index': 2},
None,
'To: 07700900001',
'Test Service: A, Template <em>content</em> with & entity',
),
(
{'row_index': 4},
True,
'To: 07700900003',
'Test Service: C, Template <em>content</em> with & entity',
),
])
def test_upload_valid_csv_shows_preview_and_table(
client_request,
mocker,
mock_get_live_service,
mock_get_service_template_with_placeholders,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_s3_set_metadata,
fake_uuid,
extra_args,
expected_link_in_first_row,
expected_recipient,
expected_message,
):
with client_request.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {'template_id': fake_uuid}
}
mocker.patch('app.main.views.send.s3download', return_value="""
phone number,name,thing,thing,thing
07700900001, A, foo, foo, foo
07700900002, B, foo, foo, foo
07700900003, C, foo, foo,
""")
page = client_request.get(
'main.check_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
original_file_name='example.csv',
**extra_args
)
mock_s3_set_metadata.assert_called_once_with(
SERVICE_ONE_ID,
fake_uuid,
notification_count=3,
template_id=fake_uuid,
valid=True,
original_file_name='example.csv',
)
assert page.h1.text.strip() == 'Preview of Two week reminder'
assert page.select_one('.sms-message-recipient').text.strip() == expected_recipient
assert page.select_one('.sms-message-wrapper').text.strip() == expected_message
assert page.select_one('.table-field-index').text.strip() == '2'
if expected_link_in_first_row:
assert page.select_one('.table-field-index a')['href'] == url_for(
'main.check_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
row_index=2,
original_file_name='example.csv',
)
else:
assert not page.select_one('.table-field-index').select_one('a')
for row_index, row in enumerate([
(
'<td class="table-field-center-aligned "> <div class=""> 07700900001 </div> </td>',
'<td class="table-field-center-aligned "> <div class=""> A </div> </td>',
(
'<td class="table-field-center-aligned "> '
'<div class="table-field-status-default"> '
'<ul class="list list-bullet"> '
'<li>foo</li> <li>foo</li> <li>foo</li> '
'</ul> '
'</div> '
'</td>'
)
),
(
'<td class="table-field-center-aligned "> <div class=""> 07700900002 </div> </td>',
'<td class="table-field-center-aligned "> <div class=""> B </div> </td>',
(
'<td class="table-field-center-aligned "> '
'<div class="table-field-status-default"> '
'<ul class="list list-bullet"> '
'<li>foo</li> <li>foo</li> <li>foo</li> '
'</ul> '
'</div> '
'</td>'
)
),
(
'<td class="table-field-center-aligned "> <div class=""> 07700900003 </div> </td>',
'<td class="table-field-center-aligned "> <div class=""> C </div> </td>',
(
'<td class="table-field-center-aligned "> '
'<div class="table-field-status-default"> '
'<ul class="list list-bullet"> '
'<li>foo</li> <li>foo</li> '
'</ul> '
'</div> '
'</td>'
)
),
]):
for index, cell in enumerate(row):
row = page.select('table tbody tr')[row_index]
assert normalize_spaces(str(row.select('td')[index + 1])) == cell
def test_upload_valid_csv_only_sets_meta_if_filename_known(
client_request,
mocker,
mock_get_live_service,
mock_get_service_letter_template,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_s3_set_metadata,
fake_uuid,
):
mocker.patch('app.main.views.send.s3download', return_value="""
addressline1, addressline2, postcode
House , 1 Street , SW1A 1AA
""")
mocker.patch(
'app.main.views.send.TemplatePreview.from_utils_template',
return_value='foo'
)
client_request.get(
'main.check_messages_preview',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
filetype='pdf',
_test_page_title=False,
)
assert len(mock_s3_set_metadata.call_args_list) == 0
def test_file_name_truncated_to_fit_in_s3_metadata(
client_request,
mocker,
mock_get_live_service,
mock_get_service_template_with_placeholders,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_s3_set_metadata,
fake_uuid,
):
with client_request.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {'template_id': fake_uuid}
}
mocker.patch('app.main.views.send.s3download', return_value="""
phone number,name,thing,thing,thing
07700900001, A, foo, foo, foo
""")
file_name = 'ü😁' * 2000
client_request.get(
'main.check_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
original_file_name=file_name,
)
assert sys.getsizeof(
file_name.encode('utf-8')
) > 2000
assert sys.getsizeof(''.join((
'{}{}'.format(key, value) for key, value in
mock_s3_set_metadata.call_args_list[0][1].items()
)).encode('utf-8')) == 1724
def test_show_all_columns_if_there_are_duplicate_recipient_columns(
client_request,
mocker,
mock_get_live_service,
mock_get_service_template_with_placeholders,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
fake_uuid,
):
with client_request.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {'template_id': fake_uuid}
}
mocker.patch('app.main.views.send.s3download', return_value="""
phone number, phone_number, PHONENUMBER
07700900001, 07700900002, 07700900003
""")
page = client_request.get(
'main.check_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
_test_page_title=False,
)
assert normalize_spaces(page.select_one('thead').text) == (
'Row in file1 phone number phone_number PHONENUMBER'
)
assert normalize_spaces(page.select_one('tbody').text) == (
'2 07700900003 07700900003 07700900003'
)
@pytest.mark.parametrize('row_index, expected_status', [
(0, 404),
(1, 404),
(2, 200),
(3, 200),
(4, 200),
(5, 404),
])
def test_404_for_previewing_a_row_out_of_range(
client_request,
mocker,
mock_get_live_service,
mock_get_service_template_with_placeholders,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_s3_set_metadata,
fake_uuid,
row_index,
expected_status,
):
with client_request.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {'template_id': fake_uuid}
}
mocker.patch('app.main.views.send.s3download', return_value="""
phone number,name,thing,thing,thing
07700900001, A, foo, foo, foo
07700900002, B, foo, foo, foo
07700900003, C, foo, foo, foo
""")
client_request.get(
'main.check_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
row_index=row_index,
_expected_status=expected_status,
)
@pytest.mark.parametrize('user', (
active_user_with_permissions,
active_caseworking_user,
))
def test_send_test_doesnt_show_file_contents(
logged_in_client,
mocker,
mock_get_service_template,
mock_s3_upload,
mock_get_users_by_service,
mock_get_service_statistics,
service_one,
fake_uuid,
user,
):
mocker.patch('app.user_api_client.get_user', return_value=user(fake_uuid))
mocker.patch('app.main.views.send.s3download', return_value="""
phone number
07700 900 986
""")
response = logged_in_client.get(
url_for('main.send_test', service_id=service_one['id'], template_id=fake_uuid),
follow_redirects=True,
)
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.select('h1')[0].text.strip() == 'Preview of Two week reminder'
assert len(page.select('table')) == 0
assert len(page.select('.banner-dangerous')) == 0
assert page.select_one('button[type=submit]').text.strip() == 'Send 1 text message'
@pytest.mark.parametrize('user, endpoint, template_mock, expected_recipient', [
(
active_user_with_permissions,
'main.send_test_step',
mock_get_service_template_with_placeholders,
'07700 900762'
),
(
active_user_with_permissions,
'main.send_test_step',
mock_get_service_email_template,
'test@user.gov.uk'
),
(
active_caseworking_user,
'main.send_test_step',
mock_get_service_email_template,
'caseworker@example.gov.uk'
),
(
active_user_with_permissions,
'main.send_test_step',
mock_get_service_letter_template,
None
),
(
active_user_with_permissions,
'main.send_one_off_step',
mock_get_service_template,
None
),
(
active_user_with_permissions,
'main.send_one_off_step',
mock_get_service_email_template,
None
),
(
active_user_with_permissions,
'main.send_one_off_step',
mock_get_service_letter_template,
None
),
])
def test_send_test_step_redirects_if_session_not_setup(
mocker,
logged_in_client,
mock_get_service_statistics,
mock_get_users_by_service,
fake_uuid,
endpoint,
template_mock,
expected_recipient,
user,
):
mocker.patch('app.user_api_client.get_user', return_value=user(fake_uuid))
template_mock(mocker)
mocker.patch('app.main.views.send.get_page_count_for_letter', return_value=99)
with logged_in_client.session_transaction() as session:
assert 'recipient' not in session
assert 'placeholders' not in session
response = logged_in_client.get(
url_for(endpoint, service_id=SERVICE_ONE_ID, template_id=fake_uuid, step_index=0),
follow_redirects=True
)
assert response.status_code == 200
with logged_in_client.session_transaction() as session:
assert session['recipient'] == expected_recipient
def test_send_one_off_does_not_send_without_the_correct_permissions(
logged_in_client,
mock_get_service_template,
service_one,
fake_uuid,
):
template_id = fake_uuid
service_one['permissions'] = []
response = logged_in_client.get(url_for(
'.send_one_off',
service_id=service_one['id'],
template_id=template_id),
follow_redirects=True)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert response.status_code == 200
assert page.select('main p')[0].text.strip() == "Sending text messages has been disabled for your service."
assert page.select(".page-footer-back-link")[0].text == "Back to the template"
assert page.select(".page-footer-back-link")[0]['href'] == url_for(
'.view_template',
service_id=service_one['id'],
template_id=template_id,
)
@pytest.mark.parametrize('user', (
active_user_with_permissions,
active_caseworking_user,
))
@pytest.mark.parametrize('template_mock, partial_url, expected_h1, tour_shown', [
(
mock_get_service_template_with_placeholders,
partial(url_for, 'main.send_test'),
'Personalise this message',
False,
),
(
mock_get_service_template_with_placeholders,
partial(url_for, 'main.send_one_off'),
'Who should this message be sent to?',
False,
),
(
mock_get_service_template_with_placeholders,
partial(url_for, 'main.send_test', help=1),
'Example text message',
True,
),
(
mock_get_service_email_template,
partial(url_for, 'main.send_test', help=1),
'Example text message',
True,
),
(
mock_get_service_email_template,
partial(url_for, 'main.send_test'),
'Personalise this message',
False,
),
(
mock_get_service_email_template,
partial(url_for, 'main.send_one_off'),
'Who should this message be sent to?',
False,
),
(
mock_get_service_letter_template,
partial(url_for, 'main.send_test'),
'Print a test letter',
False,
),
(
mock_get_service_letter_template,
partial(url_for, 'main.send_one_off'),
'Print a test letter',
False,
),
])
def test_send_one_off_or_test_has_correct_page_titles(
logged_in_client,
service_one,
fake_uuid,
mocker,
template_mock,
partial_url,
expected_h1,
tour_shown,
user,
):
mocker.patch('app.user_api_client.get_user', return_value=user(fake_uuid))
template_mock(mocker)
mocker.patch('app.main.views.send.get_page_count_for_letter', return_value=99)
response = logged_in_client.get(
partial_url(service_id=service_one['id'], template_id=fake_uuid, step_index=0),
follow_redirects=True,
)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert response.status_code == 200
assert page.h1.text.strip() == expected_h1
assert (len(page.select('.banner-tour')) == 1) == tour_shown
@pytest.mark.parametrize('user, template_mock, expected_link_text, expected_link_url', [
(
active_user_with_permissions,
mock_get_service_template,
'Use my phone number',
partial(url_for, 'main.send_test')
),
(
active_user_with_permissions,
mock_get_service_email_template,
'Use my email address',
partial(url_for, 'main.send_test')
),
(
active_user_with_permissions,
mock_get_service_letter_template,
None, None
),
(
active_caseworking_user,
mock_get_service_template,
None, None
),
])
def test_send_one_off_has_skip_link(
logged_in_client,
service_one,
fake_uuid,
mock_get_service_email_template,
mocker,
template_mock,
expected_link_text,
expected_link_url,
user,
):
mocker.patch('app.user_api_client.get_user', return_value=user(fake_uuid))
template_mock(mocker)
mocker.patch('app.main.views.send.get_page_count_for_letter', return_value=99)
response = logged_in_client.get(
url_for('main.send_one_off_step', service_id=service_one['id'], template_id=fake_uuid, step_index=0),
follow_redirects=True
)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
skip_links = page.select('a.top-gutter-4-3')
assert response.status_code == 200
if expected_link_text and expected_link_url:
assert skip_links[0].text.strip() == expected_link_text
assert skip_links[0]['href'] == expected_link_url(
service_id=service_one['id'],
template_id=fake_uuid,
)
else:
assert not skip_links
@pytest.mark.parametrize('user', (
active_user_with_permissions,
active_caseworking_user,
))
def test_skip_link_will_not_show_on_sms_one_off_if_service_has_no_mobile_number(
logged_in_client,
service_one,
fake_uuid,
mock_get_service_template,
mocker,
user,
):
user = user(fake_uuid)
user.mobile_number = None
mocker.patch('app.user_api_client.get_user', return_value=user)
response = logged_in_client.get(
url_for('main.send_one_off_step', service_id=service_one['id'], template_id=fake_uuid, step_index=0),
follow_redirects=True
)
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
skip_links = page.select('a.top-gutter-4-3')
assert not skip_links
@pytest.mark.parametrize('user', (
active_user_with_permissions,
active_caseworking_user,
))
@pytest.mark.parametrize('endpoint, expected_redirect, placeholders', [
(
'main.send_test_step',
'main.send_test',
{'name': 'foo'},
),
(
'main.send_one_off_step',
'main.send_one_off',
{'name': 'foo', 'phone number': '07900900123'},
),
])
def test_send_test_redirects_to_end_if_step_out_of_bounds(
logged_in_client,
service_one,
fake_uuid,
endpoint,
placeholders,
expected_redirect,
mocker,
user,
):
mocker.patch('app.user_api_client.get_user', return_value=user(fake_uuid))
with logged_in_client.session_transaction() as session:
session['placeholders'] = placeholders
response = logged_in_client.get(url_for(
endpoint,
service_id=service_one['id'],
template_id=fake_uuid,
step_index=999,
))
assert response.status_code == 302
expected_url = url_for(
expected_redirect,
service_id=service_one['id'],
template_id=fake_uuid,
_external=True,
)
assert response.location == expected_url
@pytest.mark.parametrize('user', (
active_user_with_permissions,
active_caseworking_user,
))
@pytest.mark.parametrize('endpoint, expected_redirect', [
('main.send_test_step', 'main.send_test'),
('main.send_one_off_step', 'main.send_one_off'),
])
def test_send_test_redirects_to_start_if_you_skip_steps(
logged_in_platform_admin_client,
service_one,
fake_uuid,
mock_get_service_letter_template,
mock_s3_upload,
mock_get_users_by_service,
mock_get_service_statistics,
mocker,
endpoint,
expected_redirect,
user,
):
mocker.patch('app.user_api_client.get_user', return_value=user(fake_uuid))
with logged_in_platform_admin_client.session_transaction() as session:
session['send_test_letter_page_count'] = 1
session['placeholders'] = {'address_line_1': 'foo'}
response = logged_in_platform_admin_client.get(url_for(
endpoint,
service_id=service_one['id'],
template_id=fake_uuid,
step_index=7, # letter template has 7 placeholders – we’re at the end
))
assert response.status_code == 302
assert response.location == url_for(
expected_redirect,
service_id=service_one['id'],
template_id=fake_uuid,
_external=True,
)
@pytest.mark.parametrize('user', (
active_user_with_permissions,
active_caseworking_user,
))
@pytest.mark.parametrize('endpoint, expected_redirect', [
('main.send_test_step', 'main.send_test'),
('main.send_one_off_step', 'main.send_one_off'),
])
def test_send_test_redirects_to_start_if_index_out_of_bounds_and_some_placeholders_empty(
logged_in_client,
service_one,
fake_uuid,
mock_get_service_email_template,
mock_s3_download,
mock_get_users_by_service,
mock_get_service_statistics,
endpoint,
expected_redirect,
mocker,
user,
):
mocker.patch('app.user_api_client.get_user', return_value=user(fake_uuid))
with logged_in_client.session_transaction() as session:
session['placeholders'] = {'name': 'foo'}
response = logged_in_client.get(url_for(
endpoint,
service_id=service_one['id'],
template_id=fake_uuid,
step_index=999,
))
assert response.status_code == 302
assert response.location == url_for(
expected_redirect,
service_id=service_one['id'],
template_id=fake_uuid,
_external=True,
)
@pytest.mark.parametrize('user', (
active_user_with_permissions,
active_caseworking_user,
))
@pytest.mark.parametrize('endpoint, expected_redirect', [
('main.send_test', 'main.send_test_step'),
('main.send_one_off', 'main.send_one_off_step'),
])
def _redirects_with_help_argument(
logged_in_client,
mocker,
service_one,
fake_uuid,
endpoint,
expected_redirect,
user,
):
mocker.patch('app.user_api_client.get_user', return_value=user(fake_uuid))
template = {'data': {'template_type': 'sms'}}
mocker.patch('app.service_api_client.get_service_template', return_value=template)
response = logged_in_client.get(
url_for(endpoint, service_id=service_one['id'], template_id=fake_uuid, help=1)
)
assert response.status_code == 302
assert response.location == url_for(
expected_redirect,
service_id=service_one['id'],
template_id=fake_uuid,
step_index=0,
help=1,
_external=True,
)
@pytest.mark.parametrize('user', (
active_user_with_permissions,
active_caseworking_user,
))
def test_send_test_email_message_without_placeholders_redirects_to_check_page(
logged_in_client,
mocker,
service_one,
mock_get_service_email_template_without_placeholders,
mock_s3_upload,
mock_get_users_by_service,
mock_get_service_statistics,
fake_uuid,
user,
):
mocker.patch('app.user_api_client.get_user', return_value=user(fake_uuid))
with logged_in_client.session_transaction() as session:
session['recipient'] = 'foo@bar.com'
response = logged_in_client.get(
url_for('main.send_test', step_index=0, service_id=service_one['id'], template_id=fake_uuid),
follow_redirects=True
)
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.select('h1')[0].text.strip() == 'Preview of Two week reminder'
@pytest.mark.parametrize('user, expected_back_link_endpoint, extra_args', (
(active_user_with_permissions, 'main.view_template', {'template_id': unchanging_fake_uuid}),
(active_caseworking_user, 'main.choose_template', {}),
))
def test_send_test_sms_message_with_placeholders_shows_first_field(
logged_in_client,
mocker,
service_one,
mock_login,
mock_get_service,
mock_get_service_template_with_placeholders,
fake_uuid,
user,
expected_back_link_endpoint,
extra_args,
):
mocker.patch('app.user_api_client.get_user', return_value=user(fake_uuid))
with logged_in_client.session_transaction() as session:
assert 'placeholders' not in session
response = logged_in_client.get(
url_for(
'main.send_test',
service_id=service_one['id'],
template_id=unchanging_fake_uuid,
),
follow_redirects=True,
)
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.select('label')[0].text.strip() == 'name'
assert page.select('input')[0]['name'] == 'placeholder_value'
assert page.select('.page-footer-back-link')[0]['href'] == url_for(
expected_back_link_endpoint,
service_id=service_one['id'],
**extra_args
)
with logged_in_client.session_transaction() as session:
assert session['recipient'] == '07700 900762'
def test_send_test_letter_clears_previous_page_cache(
logged_in_platform_admin_client,
mocker,
service_one,
mock_login,
mock_get_service,
mock_get_service_letter_template,
fake_uuid,
):
with logged_in_platform_admin_client.session_transaction() as session:
session['send_test_letter_page_count'] = 'WRONG'
response = logged_in_platform_admin_client.get(url_for(
'main.send_test',
service_id=service_one['id'],
template_id=fake_uuid,
))
assert response.status_code == 302
with logged_in_platform_admin_client.session_transaction() as session:
assert session['send_test_letter_page_count'] is None
def test_send_test_letter_redirects_to_right_url(
logged_in_platform_admin_client,
fake_uuid,
mock_get_service_letter_template,
mock_s3_upload,
mock_get_users_by_service,
mock_get_service_statistics,
mocker,
):
with logged_in_platform_admin_client.session_transaction() as session:
session['send_test_letter_page_count'] = 1
session['recipient'] = ''
session['placeholders'] = {
'address line 1': 'foo',
'address line 2': 'bar',
'address line 3': '',
'address line 4': '',
'address line 5': '',
'address line 6': '',
'postcode': 'SW1 1AA',
}
response = logged_in_platform_admin_client.get(url_for(
'main.send_one_off_step',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
step_index=7, # letter template has 7 placeholders – we’re at the end
))
assert response.status_code == 302
assert response.location.startswith(url_for(
'main.check_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
_external=True,
))
def test_send_test_populates_field_from_session(
logged_in_client,
mocker,
service_one,
mock_login,
mock_get_service,
mock_get_service_template_with_placeholders,
fake_uuid,
):
with logged_in_client.session_transaction() as session:
session['recipient'] = None
session['placeholders'] = {}
session['placeholders']['name'] = 'Jo'
response = logged_in_client.get(url_for(
'main.send_test_step',
service_id=service_one['id'],
template_id=fake_uuid,
step_index=0,
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.select('input')[0]['value'] == 'Jo'
def test_send_test_caches_page_count(
logged_in_client,
mocker,
service_one,
mock_login,
mock_get_service,
mock_get_service_letter_template,
fake_uuid,
):
mocker.patch('app.main.views.send.get_page_count_for_letter', return_value=99)
logged_in_client.get(
url_for(
'main.send_test',
service_id=service_one['id'],
template_id=fake_uuid,
),
follow_redirects=True,
)
with logged_in_client.session_transaction() as session:
assert session['send_test_letter_page_count'] == 99
def test_send_test_indicates_optional_address_columns(
logged_in_client,
mocker,
service_one,
mock_login,
mock_get_service,
mock_get_service_letter_template,
fake_uuid,
):
mocker.patch('app.main.views.send.get_page_count_for_letter', return_value=1)
with logged_in_client.session_transaction() as session:
session['recipient'] = None
session['placeholders'] = {}
response = logged_in_client.get(url_for(
'main.send_test_step',
service_id=service_one['id'],
template_id=fake_uuid,
step_index=3,
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert normalize_spaces(page.select('label')[0].text) == (
'address line 4 '
'Optional'
)
assert page.select('.page-footer-back-link')[0]['href'] == url_for(
'main.send_one_off_step',
service_id=service_one['id'],
template_id=fake_uuid,
step_index=2,
)
def test_send_test_allows_empty_optional_address_columns(
logged_in_client,
mocker,
service_one,
mock_login,
mock_get_service,
mock_get_service_letter_template,
fake_uuid,
):
mocker.patch('app.main.views.send.get_page_count_for_letter', return_value=1)
with logged_in_client.session_transaction() as session:
session['recipient'] = None
session['placeholders'] = {}
response = logged_in_client.post(
url_for(
'main.send_test_step',
service_id=service_one['id'],
template_id=fake_uuid,
step_index=3,
),
# no data here
)
assert response.status_code == 302
assert response.location == url_for(
'main.send_test_step',
service_id=service_one['id'],
template_id=fake_uuid,
step_index=4,
_external=True,
)
def test_send_test_sms_message_puts_submitted_data_in_session(
logged_in_client,
service_one,
mock_get_service_template_with_placeholders,
mock_get_users_by_service,
mock_get_service_statistics,
fake_uuid,
):
with logged_in_client.session_transaction() as session:
session['recipient'] = '07700 900762'
session['placeholders'] = {}
response = logged_in_client.post(
url_for(
'main.send_test_step',
service_id=service_one['id'],
template_id=fake_uuid,
step_index=0,
),
data={'placeholder_value': 'Jo'}
)
assert response.status_code == 302
assert response.location == url_for(
'main.check_notification',
service_id=service_one['id'],
template_id=fake_uuid,
_external=True
)
with logged_in_client.session_transaction() as session:
assert session['recipient'] == '07700 900762'
assert session['placeholders']['name'] == 'Jo'
@pytest.mark.parametrize('filetype', ['pdf', 'png'])
def test_send_test_works_as_letter_preview(
filetype,
logged_in_platform_admin_client,
mock_get_service_letter_template,
mock_get_users_by_service,
mock_get_service_statistics,
service_one,
fake_uuid,
mocker,
):
service_one['permissions'] = ['letter']
mocker.patch('app.service_api_client.get_service', return_value={"data": service_one})
mocker.patch('app.main.views.send.get_page_count_for_letter', return_value=1)
mocked_preview = mocker.patch(
'app.main.views.send.TemplatePreview.from_utils_template',
return_value='foo'
)
service_id = service_one['id']
template_id = fake_uuid
with logged_in_platform_admin_client.session_transaction() as session:
session['placeholders'] = {'address_line_1': 'Jo Lastname'}
response = logged_in_platform_admin_client.get(
url_for(
'main.send_test_preview',
service_id=service_id,
template_id=template_id,
filetype=filetype
)
)
mock_get_service_letter_template.assert_called_with(service_id, template_id)
assert response.status_code == 200
assert response.get_data(as_text=True) == 'foo'
assert mocked_preview.call_args[0][0].id == template_id
assert type(mocked_preview.call_args[0][0]) == LetterImageTemplate
assert mocked_preview.call_args[0][0].values == {'address_line_1': 'Jo Lastname'}
assert mocked_preview.call_args[0][1] == filetype
def test_send_test_clears_session(
logged_in_client,
mocker,
service_one,
fake_uuid,
):
template = {'data': {'template_type': 'sms'}}
mocker.patch('app.service_api_client.get_service_template', return_value=template)
with logged_in_client.session_transaction() as session:
session['recipient'] = '07700900001'
session['placeholders'] = {'foo': 'bar'}
response = logged_in_client.get(
url_for(
'main.send_test',
service_id=service_one['id'],
template_id=fake_uuid,
),
)
assert response.status_code == 302
with logged_in_client.session_transaction() as session:
assert session['recipient'] is None
assert session['placeholders'] == {}
def test_download_example_csv(
logged_in_client,
mocker,
api_user_active,
mock_login,
mock_get_service,
mock_get_service_template_with_placeholders_same_as_recipient,
mock_has_permissions,
fake_uuid
):
response = logged_in_client.get(
url_for('main.get_example_csv', service_id=fake_uuid, template_id=fake_uuid),
follow_redirects=True
)
assert response.status_code == 200
assert response.get_data(as_text=True) == (
'phone number,name,date\r\n'
'07700 900321,example,example\r\n'
)
assert 'text/csv' in response.headers['Content-Type']
def test_upload_csvfile_with_valid_phone_shows_all_numbers(
logged_in_client,
mock_get_service_template,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_live_service,
mock_get_job_doesnt_exist,
mock_s3_set_metadata,
service_one,
fake_uuid,
mock_s3_upload,
mocker,
):
mocker.patch(
'app.main.views.send.s3download',
return_value='\n'.join(['phone number'] + [
'07700 9007{0:02d}'.format(final_two) for final_two in range(0, 53)
])
)
response = logged_in_client.post(
url_for('main.send_messages', service_id=service_one['id'], template_id=fake_uuid),
data={'file': (BytesIO(''.encode('utf-8')), 'valid.csv')},
content_type='multipart/form-data',
follow_redirects=True
)
with logged_in_client.session_transaction() as session:
assert 'file_uploads' not in session
mock_s3_set_metadata.assert_called_once_with(
SERVICE_ONE_ID,
fake_uuid,
notification_count=53,
template_id=fake_uuid,
valid=True,
original_file_name='valid.csv',
)
content = response.get_data(as_text=True)
assert response.status_code == 200
assert '07700 900701' in content
assert '07700 900749' in content
assert '07700 900750' not in content
assert 'Only showing the first 50 rows' in content
mock_get_service_statistics.assert_called_once_with(service_one['id'], today_only=True)
@pytest.mark.parametrize('service_mock, should_allow_international', [
(mock_get_service, False),
(mock_get_international_service, True),
])
def test_upload_csvfile_with_international_validates(
mocker,
api_user_active,
logged_in_client,
mock_get_service_template,
mock_s3_upload,
mock_has_permissions,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
fake_uuid,
service_mock,
should_allow_international,
):
service_mock(mocker, api_user_active)
mocker.patch('app.main.views.send.s3download', return_value='')
mock_recipients = mocker.patch(
'app.main.views.send.RecipientCSV',
return_value=RecipientCSV("", template_type="sms"),
)
response = logged_in_client.post(
url_for('main.send_messages', service_id=fake_uuid, template_id=fake_uuid),
data={'file': (BytesIO(''.encode('utf-8')), 'valid.csv')},
content_type='multipart/form-data',
follow_redirects=True,
)
assert response.status_code == 200
assert mock_recipients.call_args[1]['international_sms'] == should_allow_international
def test_test_message_can_only_be_sent_now(
client_request,
mocker,
service_one,
mock_get_service_template,
mock_s3_download,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_s3_set_metadata,
fake_uuid
):
content = client_request.get(
'main.check_messages',
service_id=service_one['id'],
upload_id=fake_uuid,
template_id=fake_uuid,
from_test=True
)
assert 'name="scheduled_for"' not in content
def test_letter_can_only_be_sent_now(
client_request,
mocker,
service_one,
mock_get_service_letter_template,
mock_get_users_by_service,
mock_get_service_statistics,
mock_s3_set_metadata,
mock_get_job_doesnt_exist,
fake_uuid,
):
mocker.patch('app.main.views.send.s3download', return_value="addressline1, addressline2, postcode\na,b,c")
mocker.patch('app.main.views.send.set_metadata_on_csv_upload')
mocker.patch('app.main.views.send.get_page_count_for_letter', return_value=1)
content = client_request.get(
'main.check_messages',
service_id=service_one['id'],
upload_id=fake_uuid,
template_id=fake_uuid,
from_test=True
)
assert 'name="scheduled_for"' not in content
@pytest.mark.parametrize('when', [
'', '2016-08-25T13:04:21.767198'
])
def test_create_job_should_call_api(
logged_in_client,
service_one,
mock_create_job,
mock_get_job,
mock_get_notifications,
mock_get_service_template,
mocker,
fake_uuid,
when
):
service_id = service_one['id']
data = mock_get_job(service_one['id'], fake_uuid)['data']
job_id = data['id']
original_file_name = data['original_file_name']
template_id = data['template']
notification_count = data['notification_count']
with logged_in_client.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {
'template_id': template_id,
'notification_count': notification_count,
'valid': True
}
}
response = logged_in_client.post(
url_for(
'main.start_job',
service_id=service_one['id'],
upload_id=job_id,
original_file_name=original_file_name
),
data={'scheduled_for': when},
follow_redirects=True,
)
assert response.status_code == 200
assert original_file_name in response.get_data(as_text=True)
mock_create_job.assert_called_with(
job_id,
service_id,
scheduled_for=when,
)
def test_can_start_letters_job(
logged_in_platform_admin_client,
mock_create_job,
service_one,
fake_uuid
):
with logged_in_platform_admin_client.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {
'template_id': fake_uuid,
'notification_count': 123,
'valid': True
}
}
response = logged_in_platform_admin_client.post(
url_for('main.start_job', service_id=service_one['id'], upload_id=fake_uuid),
data={}
)
assert response.status_code == 302
assert 'just_sent=yes' in response.location
@pytest.mark.parametrize('filetype', ['pdf', 'png'])
@pytest.mark.parametrize('extra_args, expected_values', [
(
{},
{'postcode': 'abc123', 'addressline1': '123 street'},
),
(
{'row_index': 2},
{'postcode': 'abc123', 'addressline1': '123 street'},
),
(
{'row_index': 3},
{'postcode': 'cba321', 'addressline1': '321 avenue'},
),
])
def test_should_show_preview_letter_message(
filetype,
logged_in_platform_admin_client,
mock_get_service_letter_template,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
service_one,
fake_uuid,
mocker,
extra_args,
expected_values,
):
service_one['permissions'] = ['letter']
mocker.patch('app.service_api_client.get_service', return_value={"data": service_one})
mocker.patch('app.main.views.send.get_page_count_for_letter', return_value=1)
mocker.patch(
'app.main.views.send.s3download',
return_value='\n'.join(
['address line 1, postcode'] +
['123 street, abc123'] +
['321 avenue, cba321']
)
)
mocked_preview = mocker.patch(
'app.main.views.send.TemplatePreview.from_utils_template',
return_value='foo'
)
service_id = service_one['id']
template_id = fake_uuid
with logged_in_platform_admin_client.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {
'template_id': fake_uuid,
'notification_count': 1,
'valid': True
}
}
response = logged_in_platform_admin_client.get(
url_for(
'main.check_messages_preview',
service_id=service_id,
template_id=fake_uuid,
upload_id=fake_uuid,
filetype=filetype,
**extra_args
)
)
mock_get_service_letter_template.assert_called_with(service_id, template_id)
assert response.status_code == 200
assert response.get_data(as_text=True) == 'foo'
assert mocked_preview.call_args[0][0].id == template_id
assert type(mocked_preview.call_args[0][0]) == LetterPreviewTemplate
assert mocked_preview.call_args[0][1] == filetype
assert mocked_preview.call_args[0][0].values == expected_values
def test_dont_show_preview_letter_templates_for_bad_filetype(
logged_in_client,
mock_get_service_template,
service_one,
fake_uuid
):
resp = logged_in_client.get(
url_for(
'main.check_messages_preview',
service_id=service_one['id'],
template_id=fake_uuid,
upload_id=fake_uuid,
filetype='blah'
)
)
assert resp.status_code == 404
assert mock_get_service_template.called is False
@pytest.mark.parametrize('route, response_code', [
('main.choose_template', 200),
('main.send_messages', 200),
('main.get_example_csv', 200),
('main.send_test', 302)
])
def test_route_permissions(
mocker,
app_,
client,
api_user_active,
service_one,
mock_get_service_template,
mock_get_service_templates,
mock_get_jobs,
mock_get_notifications,
mock_create_job,
mock_s3_upload,
fake_uuid,
route,
response_code,
):
validate_route_permission(
mocker,
app_,
"GET",
response_code,
url_for(
route,
service_id=service_one['id'],
template_id=fake_uuid
),
['view_activity', 'send_messages'],
api_user_active,
service_one)
@pytest.mark.parametrize('route, response_code, method', [
('main.check_notification', 200, 'GET'),
('main.send_notification', 302, 'POST')
])
def test_route_permissions_send_check_notifications(
mocker,
app_,
client,
api_user_active,
service_one,
mock_send_notification,
mock_get_service_template,
fake_uuid,
route,
response_code,
method
):
with client.session_transaction() as session:
session['recipient'] = '07700900001'
session['placeholders'] = {'name': 'a'}
validate_route_permission_with_client(
mocker,
client,
method,
response_code,
url_for(
route,
service_id=service_one['id'],
template_id=fake_uuid
),
['send_messages'],
api_user_active,
service_one
)
@pytest.mark.parametrize('route', [
'main.choose_template',
'main.send_messages',
'main.get_example_csv',
'main.send_test'
])
def test_route_invalid_permissions(
mocker,
app_,
client,
api_user_active,
service_one,
mock_get_service_template,
mock_get_service_templates,
mock_get_jobs,
mock_get_notifications,
mock_create_job,
fake_uuid,
route,
):
validate_route_permission(
mocker,
app_,
"GET",
403,
url_for(
route,
service_id=service_one['id'],
template_type='sms',
template_id=fake_uuid),
['blah'],
api_user_active,
service_one)
@pytest.mark.parametrize(
'template_mock, extra_args, expected_url',
[
(
mock_get_service_template,
dict(),
partial(url_for, '.send_messages')
),
(
mock_get_service_template_with_placeholders,
dict(),
partial(url_for, '.send_messages')
),
(
mock_get_service_letter_template, # No placeholders
dict(from_test=True),
partial(url_for, '.send_test')
),
(
mock_get_service_template_with_placeholders,
dict(from_test=True),
partial(url_for, '.send_test')
)
]
)
def test_check_messages_back_link(
logged_in_client,
api_user_active,
mock_login,
mock_get_user_by_email,
mock_get_users_by_service,
mock_get_service,
mock_has_permissions,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_s3_download,
mock_s3_set_metadata,
fake_uuid,
mocker,
template_mock,
extra_args,
expected_url
):
template_mock(mocker)
with logged_in_client.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {
'original_file_name': 'valid.csv',
'template_id': fake_uuid,
'notification_count': 1,
'valid': True
}
}
response = logged_in_client.get(url_for(
'main.check_messages',
service_id=fake_uuid,
upload_id=fake_uuid,
template_id=fake_uuid,
**extra_args
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert (
page.findAll('a', {'class': 'page-footer-back-link'})[0]['href']
) == expected_url(service_id=fake_uuid, template_id=fake_uuid)
def test_shows_link_to_end_tour(
client_request,
mock_get_notification,
fake_uuid,
):
page = client_request.get(
'main.view_notification',
service_id=SERVICE_ONE_ID,
notification_id=fake_uuid,
help=3,
)
assert page.select(".banner-tour a")[0]['href'] == url_for(
'main.go_to_dashboard_after_tour',
service_id=SERVICE_ONE_ID,
example_template_id='5407f4db-51c7-4150-8758-35412d42186a',
)
def test_go_to_dashboard_after_tour_link(
logged_in_client,
mocker,
api_user_active,
mock_login,
mock_get_service,
mock_has_permissions,
mock_delete_service_template,
fake_uuid
):
resp = logged_in_client.get(
url_for('main.go_to_dashboard_after_tour', service_id=fake_uuid, example_template_id=fake_uuid)
)
assert resp.status_code == 302
assert resp.location == url_for("main.service_dashboard", service_id=fake_uuid, _external=True)
mock_delete_service_template.assert_called_once_with(fake_uuid, fake_uuid)
@pytest.mark.parametrize('num_requested,expected_msg', [
(0, '‘valid.csv’ contains 100 phone numbers.'),
(1, 'You can still send 49 messages today, but ‘valid.csv’ contains 100 phone numbers.')
], ids=['none_sent', 'some_sent'])
def test_check_messages_shows_too_many_messages_errors(
mocker,
logged_in_client,
api_user_active,
mock_login,
mock_get_users_by_service,
mock_get_service,
mock_get_service_template,
mock_get_job_doesnt_exist,
mock_has_permissions,
fake_uuid,
num_requested,
expected_msg
):
# csv with 100 phone numbers
mocker.patch('app.main.views.send.s3download', return_value=',\n'.join(
['phone number'] + ([mock_get_users_by_service(None)[0].mobile_number] * 100)
))
mocker.patch('app.service_api_client.get_service_statistics', return_value={
'sms': {'requested': num_requested, 'delivered': 0, 'failed': 0},
'email': {'requested': 0, 'delivered': 0, 'failed': 0}
})
with logged_in_client.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {
'template_id': fake_uuid,
'notification_count': 1,
'valid': True
}
}
response = logged_in_client.get(url_for(
'main.check_messages',
service_id=fake_uuid,
template_id=fake_uuid,
upload_id=fake_uuid,
original_file_name='valid.csv',
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert page.find('h1').text.strip() == 'Too many recipients'
assert page.find('div', class_='banner-dangerous').find('a').text.strip() == 'trial mode'
# remove excess whitespace from element
details = page.find('div', class_='banner-dangerous').findAll('p')[1]
details = ' '.join([line.strip() for line in details.text.split('\n') if line.strip() != ''])
assert details == expected_msg
def test_check_messages_shows_trial_mode_error(
logged_in_client,
mock_get_users_by_service,
mock_get_service,
mock_get_service_template,
mock_has_permissions,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
fake_uuid,
mocker
):
mocker.patch('app.main.views.send.s3download', return_value=(
'phone number,\n07900900321' # Not in team
))
with logged_in_client.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {
'template_id': '',
}
}
response = logged_in_client.get(url_for(
'main.check_messages',
service_id=uuid.uuid4(),
template_id=fake_uuid,
upload_id=fake_uuid
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert ' '.join(
page.find('div', class_='banner-dangerous').text.split()
) == (
'You can’t send to this phone number '
'In trial mode you can only send to yourself and members of your team '
'Skip to file contents'
)
@pytest.mark.parametrize('service_mock, error_should_be_shown', [
(mock_get_service, True),
(mock_get_live_service, False),
])
@pytest.mark.parametrize('number_of_rows, expected_error_message', [
(1, 'You can’t send this letter'),
(11, 'You can’t send these letters'), # Less than trial mode limit
(111, 'You can’t send these letters'), # More than trial mode limit
])
def test_check_messages_shows_trial_mode_error_for_letters(
client_request,
api_user_active,
mock_get_service_letter_template,
mock_has_permissions,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_s3_set_metadata,
fake_uuid,
mocker,
service_mock,
error_should_be_shown,
number_of_rows,
expected_error_message,
):
service_mock(mocker, api_user_active)
mocker.patch('app.main.views.send.s3download', return_value='\n'.join(
['address_line_1,address_line_2,postcode,'] +
['First Last, 123 Street, SW1 1AA'] * number_of_rows
))
with client_request.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {
'template_id': '',
}
}
page = client_request.get(
'main.check_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
_test_page_title=False,
)
error = page.select('.banner-dangerous')
if error_should_be_shown:
assert normalize_spaces(error[0].text) == (
'{} '
'In trial mode you can only preview how your letters will look '
'Skip to file contents'
).format(expected_error_message)
else:
assert not error
if number_of_rows > 1:
assert page.select_one('.table-field-index a').text == '3'
def test_check_messages_shows_data_errors_before_trial_mode_errors_for_letters(
mocker,
client_request,
mock_get_service_letter_template,
mock_has_permissions,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
fake_uuid,
):
mocker.patch('app.main.views.send.s3download', return_value='\n'.join(
['address_line_1,address_line_2,postcode,'] +
[' , ,11SW1 1AA'] +
[' , ,11SW1 1AA']
))
with client_request.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {
'template_id': '',
'original_file_name': 'example.xlsx',
}
}
page = client_request.get(
'main.check_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
_test_page_title=False,
original_file_name='example.xlsx',
)
assert normalize_spaces(page.select_one('.banner-dangerous').text) == (
'There is a problem with example.xlsx '
'You need to enter missing data in 2 rows '
'Skip to file contents'
)
assert not page.select('.table-field-index a')
def test_check_messages_column_error_doesnt_show_optional_columns(
mocker,
client_request,
mock_get_service_letter_template,
mock_has_permissions,
fake_uuid,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
):
mocker.patch('app.main.views.send.s3download', return_value='\n'.join(
['address_line_1,address_line_2,foo'] +
['First Lastname,1 Example Road,SW1 1AA']
))
with client_request.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {
'template_id': '',
'original_file_name': '',
}
}
page = client_request.get(
'main.check_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
_test_page_title=False,
)
assert normalize_spaces(page.select_one('.banner-dangerous').text) == (
'Your file needs a column called ‘postcode’ '
'Right now it has columns called ‘address_line_1’, ‘address_line_2’ and ‘foo’. '
'Skip to file contents'
)
def test_generate_test_letter_doesnt_block_in_trial_mode(
client_request,
mocker,
mock_get_service,
mock_get_service_letter_template,
mock_has_permissions,
fake_uuid,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_s3_set_metadata,
):
mocker.patch('app.main.views.send.s3download', return_value="""
address_line_1,address_line_2,postcode,
First Last, 123 Street, SW1 1AA
""")
with client_request.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {
'template_id': '',
}
}
page = client_request.get(
'main.check_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
from_test=True,
_test_page_title=False,
)
assert not page.select('.banner-dangerous')
assert page.select_one('a.button').text == 'Download as a printable PDF'
def test_check_messages_shows_over_max_row_error(
logged_in_client,
api_user_active,
mock_login,
mock_get_users_by_service,
mock_get_service,
mock_get_service_template_with_placeholders,
mock_has_permissions,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
mock_s3_download,
fake_uuid,
mocker
):
mock_recipients = mocker.patch('app.main.views.send.RecipientCSV').return_value
mock_recipients.max_rows = 11111
mock_recipients.__len__.return_value = 99999
mock_recipients.too_many_rows.return_value = True
with logged_in_client.session_transaction() as session:
session['file_uploads'] = {
fake_uuid: {
'template_id': fake_uuid,
}
}
response = logged_in_client.get(url_for(
'main.check_messages',
service_id=fake_uuid,
template_id=fake_uuid,
upload_id=fake_uuid
))
assert response.status_code == 200
page = BeautifulSoup(response.data.decode('utf-8'), 'html.parser')
assert ' '.join(
page.find('div', class_='banner-dangerous').text.split()
) == (
'Your file has too many rows '
'Notify can process up to 11,111 rows at once. '
'Your file has 99,999 rows. '
'Skip to file contents'
)
@pytest.mark.parametrize('existing_session_items', [
{},
{'recipient': '07700900001'},
{'name': 'Jo'}
])
def test_check_notification_redirects_if_session_not_populated(
logged_in_client,
service_one,
fake_uuid,
existing_session_items,
mock_get_service_template_with_placeholders
):
with logged_in_client.session_transaction() as session:
session.update(existing_session_items)
resp = logged_in_client.get(url_for(
'main.check_notification',
service_id=service_one['id'],
template_id=fake_uuid
))
assert resp.location == url_for(
'main.send_one_off_step',
service_id=service_one['id'],
template_id=fake_uuid,
step_index=1,
_external=True
)
@pytest.mark.parametrize('existing_session_items', [
{},
{'recipient': '07700900001'},
{'name': 'Jo'}
])
def test_check_notification_redirects_with_help_if_session_not_populated(
logged_in_client,
service_one,
fake_uuid,
existing_session_items,
mock_get_service_template_with_placeholders
):
with logged_in_client.session_transaction() as session:
session.update(existing_session_items)
resp = logged_in_client.get(url_for(
'main.check_notification',
service_id=service_one['id'],
template_id=fake_uuid,
help='2'
))
assert resp.location == url_for(
'main.send_test',
service_id=service_one['id'],
template_id=fake_uuid,
help='2',
_external=True
)
def test_check_notification_shows_preview(
client_request,
service_one,
fake_uuid,
mock_get_service_template
):
with client_request.session_transaction() as session:
session['recipient'] = '07700900001'
session['placeholders'] = {}
page = client_request.get(
'main.check_notification',
service_id=service_one['id'],
template_id=fake_uuid
)
assert page.h1.text.strip() == 'Preview of Two week reminder'
assert (
page.findAll('a', {'class': 'page-footer-back-link'})[0]['href']
) == url_for(
'main.send_one_off_step',
service_id=service_one['id'],
template_id=fake_uuid,
step_index=0,
)
# assert tour not visible
assert not page.select('.banner-tour')
assert page.form.attrs['action'] == url_for(
'main.send_notification',
service_id=service_one['id'],
template_id=fake_uuid,
help='0'
)
def test_check_notification_shows_help(
client_request,
service_one,
fake_uuid,
mock_get_service_template
):
with client_request.session_transaction() as session:
session['recipient'] = '07700900001'
session['placeholders'] = {}
page = client_request.get(
'main.check_notification',
service_id=service_one['id'],
template_id=fake_uuid,
help='2'
)
assert page.select_one('.banner-tour')
assert page.form.attrs['action'] == url_for(
'main.send_notification',
service_id=service_one['id'],
template_id=fake_uuid,
help='3'
)
assert page.select_one('.page-footer-back-link')['href'] == url_for(
'main.send_test',
service_id=service_one['id'],
template_id=fake_uuid,
help='2'
)
def test_send_notification_submits_data(
client_request,
service_one,
fake_uuid,
mock_send_notification,
):
with client_request.session_transaction() as session:
session['recipient'] = '07700900001'
session['placeholders'] = {'a': 'b'}
client_request.post(
'main.send_notification',
service_id=service_one['id'],
template_id=fake_uuid
)
mock_send_notification.assert_called_once_with(
service_one['id'],
template_id=fake_uuid,
recipient='07700900001',
personalisation={'a': 'b'},
sender_id=None
)
def test_send_notification_clears_session(
client_request,
service_one,
fake_uuid,
mock_send_notification,
):
with client_request.session_transaction() as session:
session['recipient'] = '07700900001'
session['placeholders'] = {'a': 'b'}
client_request.post(
'main.send_notification',
service_id=service_one['id'],
template_id=fake_uuid
)
with client_request.session_transaction() as session:
assert 'recipient' not in session
assert 'placeholders' not in session
def test_send_notification_redirects_if_missing_data(
logged_in_client,
service_one,
fake_uuid,
):
with logged_in_client.session_transaction() as session:
session['placeholders'] = {'a': 'b'}
resp = logged_in_client.post(
url_for('main.send_notification', service_id=service_one['id'], template_id=fake_uuid)
)
assert resp.status_code == 302
assert resp.location == url_for(
'.send_one_off',
service_id=service_one['id'],
template_id=fake_uuid,
_external=True
)
@pytest.mark.parametrize('extra_args, extra_redirect_args', [
({}, {}),
({'help': '3'}, {'help': '3'})
])
def test_send_notification_redirects_to_view_page(
logged_in_client,
service_one,
fake_uuid,
mock_send_notification,
extra_args,
extra_redirect_args
):
with logged_in_client.session_transaction() as session:
session['recipient'] = '07700900001'
session['placeholders'] = {'a': 'b'}
resp = logged_in_client.post(
url_for('main.send_notification', service_id=service_one['id'], template_id=fake_uuid, **extra_args)
)
assert resp.status_code == 302
assert resp.location == url_for(
'.view_notification',
service_id=service_one['id'],
notification_id=fake_uuid,
_external=True,
**extra_redirect_args
)
TRIAL_MODE_MSG = (
'Can’t send to this recipient when service is in trial mode – '
'see https://www.notifications.service.gov.uk/trial-mode'
)
TOO_LONG_MSG = 'Content for template has a character count greater than the limit of 495'
SERVICE_DAILY_LIMIT_MSG = 'Exceeded send limits (1000) for today'
@pytest.mark.parametrize('exception_msg, expected_h1, expected_err_details', [
(
TRIAL_MODE_MSG,
'You can’t send to this phone number',
'In trial mode you can only send to yourself and members of your team'
),
(
TOO_LONG_MSG,
'Message too long',
'Text messages can’t be longer than 459 characters. Your message is 554 characters.'
),
(
SERVICE_DAILY_LIMIT_MSG,
'Daily limit reached',
'You can only send 1000 messages per day in trial mode.'
),
])
def test_send_notification_shows_error_if_400(
client_request,
service_one,
fake_uuid,
mocker,
mock_get_service_template_with_placeholders,
exception_msg,
expected_h1,
expected_err_details
):
class MockHTTPError(HTTPError):
message = exception_msg
mocker.patch(
'app.notification_api_client.send_notification',
side_effect=MockHTTPError(),
)
with client_request.session_transaction() as session:
session['recipient'] = '07700900001'
session['placeholders'] = {'name': 'a' * 500}
page = client_request.post(
'main.send_notification',
service_id=service_one['id'],
template_id=fake_uuid,
_expected_status=200
)
assert normalize_spaces(page.select('.banner-dangerous h1')[0].text) == expected_h1
assert normalize_spaces(page.select('.banner-dangerous p')[0].text) == expected_err_details
assert not page.find('input[type=submit]')
def test_send_notification_shows_email_error_in_trial_mode(
client_request,
fake_uuid,
mocker,
mock_get_service_email_template,
):
class MockHTTPError(HTTPError):
message = TRIAL_MODE_MSG
status_code = 400
mocker.patch(
'app.notification_api_client.send_notification',
side_effect=MockHTTPError(),
)
with client_request.session_transaction() as session:
session['recipient'] = 'test@example.com'
session['placeholders'] = {'date': 'foo', 'thing': 'bar'}
page = client_request.post(
'main.send_notification',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_expected_status=200,
)
assert normalize_spaces(page.select('.banner-dangerous h1')[0].text) == (
'You can’t send to this email address'
)
assert normalize_spaces(page.select('.banner-dangerous p')[0].text) == (
'In trial mode you can only send to yourself and members of your team'
)
@pytest.mark.parametrize('endpoint, extra_args', [
('main.check_messages', {
'template_id': fake_uuid(), 'upload_id': fake_uuid(), 'original_file_name': 'example.csv'
}),
('main.send_one_off_step', {
'template_id': fake_uuid(), 'step_index': 0
}),
])
@pytest.mark.parametrize('reply_to_address', [
None,
fake_uuid(),
])
def test_reply_to_is_previewed_if_chosen(
client_request,
mocker,
mock_get_service_email_template,
mock_s3_download,
mock_s3_set_metadata,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
get_default_reply_to_email_address,
fake_uuid,
endpoint,
extra_args,
reply_to_address,
):
mocker.patch('app.main.views.send.s3download', return_value="""
email_address,date,thing
notify@digital.cabinet-office.gov.uk,foo,bar
""")
with client_request.session_transaction() as session:
session['recipient'] = 'notify@digital.cabinet-office.gov.uk'
session['placeholders'] = {}
session['file_uploads'] = {
fake_uuid: {'template_id': fake_uuid}
}
session['sender_id'] = reply_to_address
page = client_request.get(
endpoint,
service_id=SERVICE_ONE_ID,
**extra_args
)
email_meta = page.select_one('.email-message-meta').text
if reply_to_address:
assert 'test@example.com' in email_meta
else:
assert 'test@example.com' not in email_meta
@pytest.mark.parametrize('endpoint, extra_args', [
('main.check_messages', {'template_id': fake_uuid(), 'upload_id': fake_uuid()}),
('main.send_one_off_step', {'template_id': fake_uuid(), 'step_index': 0}),
])
@pytest.mark.parametrize('sms_sender', [
None,
fake_uuid(),
])
def test_sms_sender_is_previewed(
client_request,
mocker,
mock_get_service_template,
mock_s3_download,
mock_s3_set_metadata,
mock_get_users_by_service,
mock_get_service_statistics,
mock_get_job_doesnt_exist,
get_default_sms_sender,
fake_uuid,
endpoint,
extra_args,
sms_sender,
):
mocker.patch('app.main.views.send.s3download', return_value="""
phone number,date,thing
7700900986,foo,bar
""")
with client_request.session_transaction() as session:
session['recipient'] = '7700900986'
session['placeholders'] = {}
session['file_uploads'] = {
fake_uuid: {
'template_id': fake_uuid,
'notification_count': 1,
'valid': True
}
}
session['sender_id'] = sms_sender
page = client_request.get(
endpoint,
service_id=SERVICE_ONE_ID,
**extra_args
)
sms_sender_on_page = page.select_one('.sms-message-sender')
if sms_sender:
assert sms_sender_on_page.text.strip() == 'From: GOVUK'
else:
assert not sms_sender_on_page
def test_redirects_to_template_if_job_exists_already(
client_request,
mock_get_service_email_template,
mock_get_job,
fake_uuid,
):
client_request.get(
'main.check_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
upload_id=fake_uuid,
original_file_name='example.csv',
_expected_status=301,
_expected_redirect=url_for(
'main.send_messages',
service_id=SERVICE_ONE_ID,
template_id=fake_uuid,
_external=True,
)
)
| 28.621776 | 111 | 0.655122 |
52ed507f9978beceddbfc335bf5dda152c0e923c | 1,077 | py | Python | azure-mgmt-resource/azure/mgmt/resource/resources/v2018_05_01/models/alias_type.py | JonathanGailliez/azure-sdk-for-python | f0f051bfd27f8ea512aea6fc0c3212ee9ee0029b | [
"MIT"
] | 1 | 2021-09-07T18:36:04.000Z | 2021-09-07T18:36:04.000Z | azure-mgmt-resource/azure/mgmt/resource/resources/v2018_05_01/models/alias_type.py | JonathanGailliez/azure-sdk-for-python | f0f051bfd27f8ea512aea6fc0c3212ee9ee0029b | [
"MIT"
] | 2 | 2019-10-02T23:37:38.000Z | 2020-10-02T01:17:31.000Z | azure-mgmt-resource/azure/mgmt/resource/resources/v2018_05_01/models/alias_type.py | JonathanGailliez/azure-sdk-for-python | f0f051bfd27f8ea512aea6fc0c3212ee9ee0029b | [
"MIT"
] | 1 | 2018-08-28T14:36:47.000Z | 2018-08-28T14:36:47.000Z | # coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
# --------------------------------------------------------------------------
from msrest.serialization import Model
class AliasType(Model):
"""The alias type. .
:param name: The alias name.
:type name: str
:param paths: The paths for an alias.
:type paths:
list[~azure.mgmt.resource.resources.v2018_05_01.models.AliasPathType]
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'paths': {'key': 'paths', 'type': '[AliasPathType]'},
}
def __init__(self, **kwargs):
super(AliasType, self).__init__(**kwargs)
self.name = kwargs.get('name', None)
self.paths = kwargs.get('paths', None)
| 31.676471 | 76 | 0.563603 |
9b02743cbdde3c0d3d4bac56ac38d5e9f1fa9742 | 14,533 | py | Python | ai_notes.py | AlanACruz/aipnd-project | e0d5dcb49865cced1a9e88f03adaf71f6d0bf1a6 | [
"MIT"
] | null | null | null | ai_notes.py | AlanACruz/aipnd-project | e0d5dcb49865cced1a9e88f03adaf71f6d0bf1a6 | [
"MIT"
] | null | null | null | ai_notes.py | AlanACruz/aipnd-project | e0d5dcb49865cced1a9e88f03adaf71f6d0bf1a6 | [
"MIT"
] | null | null | null | # --------------- AND Perceptron ---------------
import pandas as pd
# TODO: Set weight1, weight2, and bias
weight1 = 0.2
weight2 = 0.8
bias = -1.0
# DON'T CHANGE ANYTHING BELOW
# Inputs and outputs
test_inputs = [(0, 0), (0, 1), (1, 0), (1, 1)]
correct_outputs = [False, False, False, True]
outputs = []
# Generate and check output
for test_input, correct_output in zip(test_inputs, correct_outputs):
linear_combination = weight1 * test_input[0] + weight2 * test_input[1] + bias
output = int(linear_combination >= 0)
is_correct_string = 'Yes' if output == correct_output else 'No'
outputs.append([test_input[0], test_input[1], linear_combination, output, is_correct_string])
# Print output
num_wrong = len([output[4] for output in outputs if output[4] == 'No'])
output_frame = pd.DataFrame(outputs, columns=['Input 1', ' Input 2', ' Linear Combination', ' Activation Output', ' Is Correct'])
if not num_wrong:
print('Nice! You got it all correct.\n')
else:
print('You got {} wrong. Keep trying!\n'.format(num_wrong))
print(output_frame.to_string(index=False))
# --------------- NOT Perceptron --------------------
import pandas as pd
# TODO: Set weight1, weight2, and bias
weight1 = 0.0
weight2 = -1.0
bias = -0.0
# DON'T CHANGE ANYTHING BELOW
# Inputs and outputs
test_inputs = [(0, 0), (0, 1), (1, 0), (1, 1)]
correct_outputs = [True, False, True, False]
outputs = []
# Generate and check output
for test_input, correct_output in zip(test_inputs, correct_outputs):
linear_combination = weight1 * test_input[0] + weight2 * test_input[1] + bias
output = int(linear_combination >= 0)
is_correct_string = 'Yes' if output == correct_output else 'No'
outputs.append([test_input[0], test_input[1], linear_combination, output, is_correct_string])
# Print output
num_wrong = len([output[4] for output in outputs if output[4] == 'No'])
output_frame = pd.DataFrame(outputs, columns=['Input 1', ' Input 2', ' Linear Combination', ' Activation Output', ' Is Correct'])
if not num_wrong:
print('Nice! You got it all correct.\n')
else:
print('You got {} wrong. Keep trying!\n'.format(num_wrong))
print(output_frame.to_string(index=False))
# --------------- Perceptron Step --------------------
import numpy as np
# Setting the random seed, feel free to change it and see different solutions.
np.random.seed(42)
def stepFunction(t):
if t >= 0:
return 1
return 0
def prediction(X, W, b):
return stepFunction((np.matmul(X,W)+b)[0])
# TODO: Fill in the code below to implement the perceptron trick.
# The function should receive as inputs the data X, the labels y,
# the weights W (as an array), and the bias b,
# update the weights and bias W, b, according to the perceptron algorithm,
# and return W and b.
def perceptronStep(X, y, W, b, learn_rate = 0.01):
for i in range(len(X)):
y_hat = prediction(X[i],W,b)
if y[i]-y_hat == 1:
W[0] += X[i][0]*learn_rate
W[1] += X[i][1]*learn_rate
b += learn_rate
elif y[i]-y_hat == -1:
W[0] -= X[i][0]*learn_rate
W[1] -= X[i][1]*learn_rate
b -= learn_rate
return W, b
# This function runs the perceptron algorithm repeatedly on the dataset,
# and returns a few of the boundary lines obtained in the iterations,
# for plotting purposes.
# Feel free to play with the learning rate and the num_epochs,
# and see your results plotted below.
def trainPerceptronAlgorithm(X, y, learn_rate = 0.01, num_epochs = 25):
x_min, x_max = min(X.T[0]), max(X.T[0])
y_min, y_max = min(X.T[1]), max(X.T[1])
W = np.array(np.random.rand(2,1))
b = np.random.rand(1)[0] + x_max
# These are the solution lines that get plotted below.
boundary_lines = []
for i in range(num_epochs):
# In each epoch, we apply the perceptron step.
W, b = perceptronStep(X, y, W, b, learn_rate)
boundary_lines.append((-W[0]/W[1], -b/W[1]))
return boundary_lines
# --------------- Softmax --------------------
import numpy as np
def softmax(L):
expL = np.exp(L)
sumExpL = sum(expL)
result = []
for i in expL:
result.append(i*1.0/sumExpL)
return result
# Note: The function np.divide can also be used here, as follows:
# def softmax(L):
# expL = np.exp(L)
# return np.divide (expL, expL.sum())
# --------------- Cross Entropy --------------------
import numpy as np
def cross_entropy(Y, P):
Y = np.float_(Y)
P = np.float_(P)
return -np.sum(Y * np.log(P) + (1 - Y) * np.log(1 - P))
# -------------------- Gradient Descent --------------------
# Sigmoid Activation Function ( Integral of log(e^x + 1) + C )
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# Output (prediction) formula
def output_formula(features, weights, bias):
linear_combination=np.dot(features, weights)
return sigmoid(linear_combination + bias)
# Error Formula (Binary Cross-Entropy / Log Loss)
# y = probability
def error_formula(y, output):
porbability_of_1 = - y * np.log(output)
probability_of_0 = - (1 - y) * np.log(1-output)
binary_cross_entropy = porbability_of_1 + probability_of_0
return binary_cross_entropy
# Gradient descent step
def update_weights(x, y, weights, bias, learnrate):
output = output_formula(x, weights, bias)
d_error = -(y - output)
weights -= learnrate * d_error * x
bias -= learnrate * d_error
return weights, bias
# -------------------- Gradient Descent 2 --------------------
import numpy as np
def sigmoid(x):
"""
Calculate sigmoid
"""
return 1/(1+np.exp(-x))
def sigmoid_prime(x):
"""
# Derivative of the sigmoid function
"""
return sigmoid(x) * (1 - sigmoid(x))
learnrate = 0.5
x = np.array([1, 2, 3, 4])
y = np.array(0.5)
# Initial weights
w = np.array([0.5, -0.5, 0.3, 0.1])
### Calculate one gradient descent step for each weight
### Note: Some steps have been consolidated, so there are
### fewer variable names than in the above sample code
# TODO: Calculate the node's linear combination of inputs and weights
h = np.dot(x, w)
# TODO: Calculate output of neural network
nn_output = sigmoid(h)
# TODO: Calculate error of neural network
error = y - nn_output
# TODO: Calculate the error term
# Remember, this requires the output gradient, which we haven't
# specifically added a variable for.
error_term = error * sigmoid_prime(h)
# Note: The sigmoid_prime function calculates sigmoid(h) twice,
# but you've already calculated it once. You can make this
# code more efficient by calculating the derivative directly
# rather than calling sigmoid_prime, like this:
# error_term = error * nn_output * (1 - nn_output)
# TODO: Calculate change in weights
del_w = learnrate * error_term * x
print('Neural Network output:')
print(nn_output)
print('Amount of Error:')
print(error)
print('Change in Weights:')
print(del_w)
# --------------- Gradient Descent 3 --------------------
import numpy as np
from data_prep import features, targets, features_test, targets_test
def sigmoid(x):
"""
Calculate sigmoid
"""
return 1 / (1 + np.exp(-x))
# TODO: We haven't provided the sigmoid_prime function like we did in
# the previous lesson to encourage you to come up with a more
# efficient solution. If you need a hint, check out the comments
# in solution.py from the previous lecture.
# Use to same seed to make debugging easier
np.random.seed(42)
n_records, n_features = features.shape
last_loss = None
# Initialize weights
weights = np.random.normal(scale=1 / n_features**.5, size=n_features)
# Neural Network hyperparameters
epochs = 1000
learnrate = 0.5
for e in range(epochs):
del_w = np.zeros(weights.shape)
for x, y in zip(features.values, targets):
# Loop through all records, x is the input, y is the target
# Activation of the output unit
# Notice we multiply the inputs and the weights here
# rather than storing h as a separate variable
output = sigmoid(np.dot(x, weights))
# The error, the target minus the network output
error = y - output
# The error term
# Notice we calulate f'(h) here instead of defining a separate
# sigmoid_prime function. This just makes it faster because we
# can re-use the result of the sigmoid function stored in
# the output variable
error_term = error * output * (1 - output)
# The gradient descent step, the error times the gradient times the inputs
del_w += error_term * x
# Update the weights here. The learning rate times the
# change in weights, divided by the number of records to average
weights += learnrate * del_w / n_records
# Printing out the mean square error on the training set
if e % (epochs / 10) == 0:
out = sigmoid(np.dot(features, weights))
loss = np.mean((out - targets) ** 2)
if last_loss and last_loss < loss:
print("Train loss: ", loss, " WARNING - Loss Increasing")
else:
print("Train loss: ", loss)
last_loss = loss
# Calculate accuracy on test data
tes_out = sigmoid(np.dot(features_test, weights))
predictions = tes_out > 0.5
accuracy = np.mean(predictions == targets_test)
print("Prediction accuracy: {:.3f}".format(accuracy))
# --------------- Multiplayer Perceptrons (Hidden Layers) --------------------
import numpy as np
def sigmoid(x):
"""
Calculate sigmoid
"""
return 1/(1+np.exp(-x))
# Network size
N_input = 4
N_hidden = 3
N_output = 2
np.random.seed(42)
# Make some fake data
X = np.random.randn(4)
weights_input_to_hidden = np.random.normal(0, scale=0.1, size=(N_input, N_hidden))
weights_hidden_to_output = np.random.normal(0, scale=0.1, size=(N_hidden, N_output))
# TODO: Make a forward pass through the network
hidden_layer_in = np.dot(X, weights_input_to_hidden)
hidden_layer_out = sigmoid(hidden_layer_in)
print('Hidden-layer Output:')
print(hidden_layer_out)
output_layer_in = np.dot(hidden_layer_out, weights_hidden_to_output)
output_layer_out = sigmoid(output_layer_in)
print('Output-layer Output:')
print(output_layer_out)
# -------------------- Backpropagation --------------------
import numpy as np
def sigmoid(x):
"""
Calculate sigmoid
"""
return 1 / (1 + np.exp(-x))
x = np.array([0.5, 0.1, -0.2])
target = 0.6
learnrate = 0.5
weights_input_hidden = np.array([[0.5, -0.6],
[0.1, -0.2],
[0.1, 0.7]])
weights_hidden_output = np.array([0.1, -0.3])
## Forward pass
hidden_layer_input = np.dot(x, weights_input_hidden)
hidden_layer_output = sigmoid(hidden_layer_input)
output_layer_in = np.dot(hidden_layer_output, weights_hidden_output)
output = sigmoid(output_layer_in)
## Backwards pass
## TODO: Calculate output error
error = target - output
# TODO: Calculate error term for output layer
output_error_term = error * output * (1 - output)
# TODO: Calculate error term for hidden layer
hidden_error_term = np.dot(output_error_term, weights_hidden_output) * \
hidden_layer_output * (1 - hidden_layer_output)
# TODO: Calculate change in weights for hidden layer to output layer
delta_w_h_o = learnrate * output_error_term * hidden_layer_output
# TODO: Calculate change in weights for input layer to hidden layer
delta_w_i_h = learnrate * hidden_error_term * x[:, None]
print('Change in weights for hidden layer to output layer:')
print(delta_w_h_o)
print('Change in weights for input layer to hidden layer:')
print(delta_w_i_h)
# -------------------- Backpropagation 2 --------------------
import numpy as np
from data_prep import features, targets, features_test, targets_test
np.random.seed(21)
def sigmoid(x):
"""
Calculate sigmoid
"""
return 1 / (1 + np.exp(-x))
# Hyperparameters
n_hidden = 2 # number of hidden units
epochs = 900
learnrate = 0.005
n_records, n_features = features.shape
last_loss = None
# Initialize weights
weights_input_hidden = np.random.normal(scale=1 / n_features ** .5,
size=(n_features, n_hidden))
weights_hidden_output = np.random.normal(scale=1 / n_features ** .5,
size=n_hidden)
for e in range(epochs):
del_w_input_hidden = np.zeros(weights_input_hidden.shape)
del_w_hidden_output = np.zeros(weights_hidden_output.shape)
for x, y in zip(features.values, targets):
## Forward pass ##
# TODO: Calculate the output
hidden_input = np.dot(x, weights_input_hidden)
hidden_output = sigmoid(hidden_input)
output = sigmoid(np.dot(hidden_output,
weights_hidden_output))
## Backward pass ##
# TODO: Calculate the network's prediction error
error = y - output
# TODO: Calculate error term for the output unit
output_error_term = error * output * (1 - output)
## propagate errors to hidden layer
# TODO: Calculate the hidden layer's contribution to the error
hidden_error = np.dot(output_error_term, weights_hidden_output)
# TODO: Calculate the error term for the hidden layer
hidden_error_term = hidden_error * hidden_output * (1 - hidden_output)
# TODO: Update the change in weights
del_w_hidden_output += output_error_term * hidden_output
del_w_input_hidden += hidden_error_term * x[:, None]
# TODO: Update weights
weights_input_hidden += learnrate * del_w_input_hidden / n_records
weights_hidden_output += learnrate * del_w_hidden_output / n_records
# Printing out the mean square error on the training set
if e % (epochs / 10) == 0:
hidden_output = sigmoid(np.dot(x, weights_input_hidden))
out = sigmoid(np.dot(hidden_output,
weights_hidden_output))
loss = np.mean((out - targets) ** 2)
if last_loss and last_loss < loss:
print("Train loss: ", loss, " WARNING - Loss Increasing")
else:
print("Train loss: ", loss)
last_loss = loss
# Calculate accuracy on test data
hidden = sigmoid(np.dot(features_test, weights_input_hidden))
out = sigmoid(np.dot(hidden, weights_hidden_output))
predictions = out > 0.5
accuracy = np.mean(predictions == targets_test)
print("Prediction accuracy: {:.3f}".format(accuracy))
| 31.053419 | 133 | 0.650107 |
5cef6b4ed1ddeb97ad5df13e0938c583633ae77f | 999 | py | Python | Software/PokemonDataObtainer/models/pokemonspecies.py | goodguyplayer/UniProject-AlolaPokedex | 44a20fa08feb8ba57fdd4ca9319a07d35b3f459a | [
"MIT"
] | null | null | null | Software/PokemonDataObtainer/models/pokemonspecies.py | goodguyplayer/UniProject-AlolaPokedex | 44a20fa08feb8ba57fdd4ca9319a07d35b3f459a | [
"MIT"
] | null | null | null | Software/PokemonDataObtainer/models/pokemonspecies.py | goodguyplayer/UniProject-AlolaPokedex | 44a20fa08feb8ba57fdd4ca9319a07d35b3f459a | [
"MIT"
] | null | null | null | import pokebase as pb
class PokemonSpecies:
def __init__(self, id:str):
self.pokemonspecies = pb.pokemon_species(id)
self.name = self.pokemonspecies.name
self.flavortext = self.setFlavorText(self.pokemonspecies.flavor_text_entries)
self.genera = self.setGenus(self.pokemonspecies.genera)
self.varieties = self.setVariety(self.pokemonspecies.varieties)
def setGenus(self, genera: list):
for i in genera:
if i.language.name == "en":
return i.genus
def setFlavorText(self, flavor:list):
for i in flavor:
if i.language.name == "en":
return i.flavor_text
def setVariety(self, variety:list):
for i in variety:
if "alola" in i.pokemon.name:
return self.getIDInUrl(i.pokemon.url)
return self.getIDInUrl(variety[0].pokemon.url)
def getIDInUrl(self, url: str):
output = url.split("/")
return (output[-2]).strip() | 34.448276 | 85 | 0.621622 |
f133e8364e64eda8188af5d6f98717399e668fdb | 261 | py | Python | automata/pda/pda.py | dengl11/automata | 95d89e5eec118b01101efb021a78fea325794e4a | [
"MIT"
] | null | null | null | automata/pda/pda.py | dengl11/automata | 95d89e5eec118b01101efb021a78fea325794e4a | [
"MIT"
] | null | null | null | automata/pda/pda.py | dengl11/automata | 95d89e5eec118b01101efb021a78fea325794e4a | [
"MIT"
] | 1 | 2018-11-15T08:52:19.000Z | 2018-11-15T08:52:19.000Z | #!/usr/bin/env python3
"""Classes and methods for working with all pushdown automata."""
import abc
from automata.base.automaton import Automaton
class PDA(Automaton, metaclass=abc.ABCMeta):
"""An abstract base class for pushdown automata."""
pass
| 20.076923 | 65 | 0.739464 |
77618b0e4012f4d2d84d021bf29824b48abb265e | 328 | py | Python | Emmanuel ANENE/Phase 1/Python Basic 1/Day11/task7.py | CodedLadiesInnovateTech/-python-challenge-solutions | 430cd3eb84a2905a286819eef384ee484d8eb9e7 | [
"MIT"
] | 6 | 2020-05-23T19:53:25.000Z | 2021-05-08T20:21:30.000Z | Emmanuel ANENE/Phase 1/Python Basic 1/Day11/task7.py | CodedLadiesInnovateTech/-python-challenge-solutions | 430cd3eb84a2905a286819eef384ee484d8eb9e7 | [
"MIT"
] | 8 | 2020-05-14T18:53:12.000Z | 2020-07-03T00:06:20.000Z | Emmanuel ANENE/Phase 1/Python Basic 1/Day11/task7.py | CodedLadiesInnovateTech/-python-challenge-solutions | 430cd3eb84a2905a286819eef384ee484d8eb9e7 | [
"MIT"
] | 39 | 2020-05-10T20:55:02.000Z | 2020-09-12T17:40:59.000Z | '''
Write a Python program to list the special variables used within the language.
'''
speVar = sorted((set(globals().keys()) | set(__builtins__.keys())) - set("_names i".split()))
spr = "\n".join(' '.join(speVar[i:i+8]) for i in range(0, len(speVar), 8))
stv = set(__builtins__.keys())
# print(speVar)
print(spr)
# print(stv) | 29.818182 | 93 | 0.661585 |
6a059737451985af9cae5f90ffd6fb61501e4aed | 131 | py | Python | app/auth/__init__.py | TopKeingt/MHS-code | 3173f16ef2cc625f9979eb382aee84633131bc29 | [
"MIT"
] | null | null | null | app/auth/__init__.py | TopKeingt/MHS-code | 3173f16ef2cc625f9979eb382aee84633131bc29 | [
"MIT"
] | null | null | null | app/auth/__init__.py | TopKeingt/MHS-code | 3173f16ef2cc625f9979eb382aee84633131bc29 | [
"MIT"
] | null | null | null | from flask import Blueprint
bp = Blueprint('auth', __name__, static_folder="../static/admin_static")
from app.auth import routes
| 21.833333 | 72 | 0.770992 |
9c527db8f193a0ee4742bda4cf4e7287adb3dfa4 | 607 | py | Python | gssClients/gssPythonClients/deleteFolder_gss.py | SemWES/client_libs | 48c3af519ceaf80b3f33cf509c72376b9b3d9582 | [
"Zlib"
] | null | null | null | gssClients/gssPythonClients/deleteFolder_gss.py | SemWES/client_libs | 48c3af519ceaf80b3f33cf509c72376b9b3d9582 | [
"Zlib"
] | null | null | null | gssClients/gssPythonClients/deleteFolder_gss.py | SemWES/client_libs | 48c3af519ceaf80b3f33cf509c72376b9b3d9582 | [
"Zlib"
] | null | null | null | #!/bin/env python
# Copyright STIFTELSEN SINTEF 2016
import suds
import urllib2
import sys
if len(sys.argv) < 3:
print ("Usage:")
print ("\t %s gss-url token" % sys.argv[0])
print ("\t (got ", len(sys.argv), " arguments" )
exit()
# get url:
url = sys.argv[1]
sessionToken = sys.argv[2]
wsdlLocation = "https://api.caxman.eu/sintef/infrastructure/gss-0.1/FileUtilities?wsdl"
client = suds.client.Client(wsdlLocation)
deleteFolder = client.service.deleteFolder(url, sessionToken)
if deleteFolder:
print "Folder was deleted"
else:
print "Something went wrong"
print deleteFolder
| 21.678571 | 87 | 0.701812 |
e71d158600cf00c66354329d82b15a9beac5ff9d | 5,132 | py | Python | tests/test_resize.py | ftnext/python-image-processor | 4625522318f6ca67951c2c2e2e376fe9c4bd628b | [
"MIT"
] | null | null | null | tests/test_resize.py | ftnext/python-image-processor | 4625522318f6ca67951c2c2e2e376fe9c4bd628b | [
"MIT"
] | null | null | null | tests/test_resize.py | ftnext/python-image-processor | 4625522318f6ca67951c2c2e2e376fe9c4bd628b | [
"MIT"
] | null | null | null | from unittest import TestCase
from unittest.mock import call, MagicMock, patch
import myimageprocessor.path_handler as ph
import myimageprocessor.resize as r
class ShrinkSizeCalculatorTestCase(TestCase):
def setUp(self):
self.limit = 300
def test_init(self):
size = (400, 600)
actual = r.ShrinkSizeCalculator(size, self.limit)
self.assertEqual(actual._now, (400, 600))
self.assertEqual(actual._limit, 300)
def test_needs_shrink(self):
"""Case of width > limit and height > limit"""
size = (600, 400)
shrink_size_calculator = r.ShrinkSizeCalculator(size, self.limit)
actual = shrink_size_calculator.needs_shrink()
self.assertTrue(actual)
def test_needs_shrink_width_smaller(self):
"""Case of width < limit (< height)"""
size = (299, 500)
shrink_size_calculator = r.ShrinkSizeCalculator(size, self.limit)
actual = shrink_size_calculator.needs_shrink()
self.assertFalse(actual)
def test_needs_shrink_height_smaller(self):
"""Case of height < limit (< width)"""
size = (400, 250)
shrink_size_calculator = r.ShrinkSizeCalculator(size, self.limit)
actual = shrink_size_calculator.needs_shrink()
self.assertFalse(actual)
def test_needs_shrink_boundary(self):
"""Case of height == limit < width"""
size = (301, 300)
shrink_size_calculator = r.ShrinkSizeCalculator(size, self.limit)
actual = shrink_size_calculator.needs_shrink()
self.assertFalse(actual)
def test_shrink_size(self):
size = (600, 400)
limit = 300
shrink_size_calculator = r.ShrinkSizeCalculator(size, limit)
actual = shrink_size_calculator.shrink_size()
self.assertEqual(actual, (300, 200))
def test_shrink_size_check_int(self):
"""intで返っていることを確認する
(400 / 700) * 500 = 285.71
四捨五入でなく、intによる切り捨てで285となる
"""
size = (500, 700)
limit = 400
shrink_size_calculator = r.ShrinkSizeCalculator(size, limit)
actual = shrink_size_calculator.shrink_size()
self.assertEqual(actual, (285, 400))
class CreateShrinkSizeCalculatorTestCase(TestCase):
@patch(
"myimageprocessor.resize.ShrinkSizeCalculator.__init__",
return_value=None,
)
def test(self, init_mock):
size, limit = MagicMock(spec=tuple), MagicMock(spec=int)
actual = r.create_shrink_size_calculator(size, limit)
self.assertIsInstance(actual, r.ShrinkSizeCalculator)
self.assertEqual(init_mock.call_args_list, [call(size, limit)])
class ShrinkProcessorTestCase(TestCase):
def setUp(self):
self.shrink_size = MagicMock(spec=int)
def test_init(self):
source_destination_file_pair = MagicMock(spec=ph.PathPair)
actual = r.ShrinkProcessor(
source_destination_file_pair, self.shrink_size
)
self.assertEqual(
actual._source_destination_pair, source_destination_file_pair
)
self.assertEqual(actual._shrink_size, self.shrink_size)
@patch("myimageprocessor.resize.create_shrink_size_calculator")
@patch("myimageprocessor.resize.Image.open")
def test_process(self, image_open, create_shrink_size_calculator):
source_destination_file_pair = MagicMock(spec=ph.SourceDestinationPair)
image = image_open.return_value
shrink_size_calculator = create_shrink_size_calculator.return_value
shrink_size_calculator.needs_shrink.return_value = True
shrinked_size = shrink_size_calculator.shrink_size.return_value
resized_image = image.resize.return_value
shrink_processor = r.ShrinkProcessor(
source_destination_file_pair, self.shrink_size
)
shrink_processor.process()
self.assertEqual(
image_open.call_args_list,
[call(source_destination_file_pair.source)],
)
self.assertEqual(
create_shrink_size_calculator.call_args_list,
[call(image.size, self.shrink_size)],
)
self.assertEqual(
shrink_size_calculator.needs_shrink.call_args_list, [call()]
)
self.assertEqual(
shrink_size_calculator.shrink_size.call_args_list, [call()]
)
self.assertEqual(image.resize.call_args_list, [call(shrinked_size)])
self.assertEqual(
resized_image.save.call_args_list,
[call(source_destination_file_pair.destination)],
)
class CreateShrinkProcessor(TestCase):
@patch(
"myimageprocessor.resize.ShrinkProcessor.__init__", return_value=None
)
def test_init(self, init_mock):
source_destination_pair = MagicMock(spec=tuple)
shrink_size = MagicMock(spec=int)
actual = r.create_shrink_processor(
source_destination_pair, shrink_size
)
self.assertIsInstance(actual, r.ShrinkProcessor)
self.assertEqual(
init_mock.call_args_list,
[call(source_destination_pair, shrink_size)],
)
| 35.888112 | 79 | 0.675175 |
5d191a7f0eecda0849676d09e3803a309fbfa931 | 23,909 | py | Python | respy/shared.py | MaxBlesch/respy | ddde5dec1dc650684d4d601e74d6a4f96d0f80ed | [
"MIT"
] | null | null | null | respy/shared.py | MaxBlesch/respy | ddde5dec1dc650684d4d601e74d6a4f96d0f80ed | [
"MIT"
] | null | null | null | respy/shared.py | MaxBlesch/respy | ddde5dec1dc650684d4d601e74d6a4f96d0f80ed | [
"MIT"
] | null | null | null | """Contains functions which are shared across other modules.
This module should only import from other packages or modules of respy which also do not
import from respy itself. This is to prevent circular imports.
"""
import shutil
import chaospy as cp
import numba as nb
import numpy as np
import pandas as pd
from respy._numba import array_to_tuple
from respy.config import MAX_LOG_FLOAT
from respy.config import MIN_LOG_FLOAT
from respy.parallelization import parallelize_across_dense_dimensions
@nb.njit
def aggregate_keane_wolpin_utility(wage, nonpec, continuation_value, draw, delta):
"""Calculate the utility of Keane and Wolpin models.
Note that the function works for working and non-working alternatives as wages are
set to one for non-working alternatives such that the draws enter the utility
function additively.
Parameters
----------
wage : float
Value of the wage component. Note that for non-working alternatives this value
is actually zero, but to simplify computations it is set to one.
nonpec : float
Value of the non-pecuniary component.
continuation_value : float
Value of the continuation value which is the expected present-value of the
following state.
draw : float
The shock which enters the enters the reward of working alternatives
multiplicatively and of non-working alternatives additively.
delta : float
The discount factor to calculate the present value of continuation values.
Returns
-------
alternative_specific_value_function : float
The expected present value of an alternative.
flow_utility : float
The immediate reward of an alternative.
"""
flow_utility = wage * draw + nonpec
alternative_specific_value_function = flow_utility + delta * continuation_value
return alternative_specific_value_function, flow_utility
def create_base_draws(shape, seed, monte_carlo_sequence):
"""Create a set of draws from the standard normal distribution.
The draws are either drawn randomly or from quasi-random low-discrepancy sequences,
i.e., Sobol or Halton.
`"random"` is used to draw random standard normal shocks for the Monte Carlo
integrations or because individuals face random shocks in the simulation.
`"halton"` or `"sobol"` can be used to change the sequence for two Monte Carlo
integrations. First, the calculation of the expected value function (EMAX) in the
solution and the choice probabilities in the maximum likelihood estimation.
For the solution and estimation it is necessary to have the same randomness in every
iteration. Otherwise, there is chatter in the simulation, i.e. a difference in
simulated values not only due to different parameters but also due to draws (see
10.5 in [1]_). At the same time, the variance-covariance matrix of the shocks is
estimated along all other parameters and changes every iteration. Thus, instead of
sampling draws from a varying multivariate normal distribution, standard normal
draws are sampled here and transformed to the distribution specified by the
parameters in :func:`transform_base_draws_with_cholesky_factor`.
Parameters
----------
shape : tuple(int)
Tuple representing the shape of the resulting array.
seed : int
Seed to control randomness.
monte_carlo_sequence : {"random", "halton", "sobol"}
Name of the sequence.
Returns
-------
draws : numpy.ndarray
Array with shape (n_choices, n_draws, n_choices).
See also
--------
transform_base_draws_with_cholesky_factor
References
----------
.. [1] Train, K. (2009). `Discrete Choice Methods with Simulation
<https://eml.berkeley.edu/books/choice2.html>`_. *Cambridge: Cambridge
University Press.*
.. [2] Lemieux, C. (2009). `Monte Carlo and Quasi-Monte Carlo Sampling
<https://www.springer.com/de/book/9780387781648>`_. *New York: Springer
Verlag New York.*
"""
n_choices = shape[-1]
n_points = np.prod(shape[:-1])
np.random.seed(seed)
if monte_carlo_sequence == "random":
draws = np.random.standard_normal(shape)
elif monte_carlo_sequence == "halton":
distribution = cp.MvNormal(loc=np.zeros(n_choices), scale=np.eye(n_choices))
draws = distribution.sample(n_points, rule="H").T.reshape(shape)
elif monte_carlo_sequence == "sobol":
distribution = cp.MvNormal(loc=np.zeros(n_choices), scale=np.eye(n_choices))
draws = distribution.sample(n_points, rule="S").T.reshape(shape)
else:
raise NotImplementedError
return draws
@parallelize_across_dense_dimensions
def transform_base_draws_with_cholesky_factor(
draws, choice_set, shocks_cholesky, optim_paras
):
r"""Transform standard normal draws with the Cholesky factor.
The standard normal draws are transformed to normal draws with variance-covariance
matrix :math:`\Sigma` by multiplication with the Cholesky factor :math:`L` where
:math:`L^TL = \Sigma`. See chapter 7.4 in [1]_ for more information.
This function relates to :func:`create_base_draws` in the sense that it transforms
the unchanging standard normal draws to the distribution with the
variance-covariance matrix specified by the parameters.
References
----------
.. [1] Gentle, J. E. (2009). Computational statistics (Vol. 308). New York:
Springer.
See also
--------
create_base_draws
"""
shocks_cholesky = subset_cholesky_factor_to_choice_set(shocks_cholesky, choice_set)
draws_transformed = draws.dot(shocks_cholesky.T)
# Check how many wages we have
n_wages_raw = len(optim_paras["choices_w_wage"])
n_wages = sum(choice_set[:n_wages_raw])
draws_transformed[:, :n_wages] = np.exp(
np.clip(draws_transformed[:, :n_wages], MIN_LOG_FLOAT, MAX_LOG_FLOAT)
)
return draws_transformed
def generate_column_dtype_dict_for_estimation(optim_paras):
"""Generate column labels for data necessary for the estimation."""
labels = (
["Identifier", "Period", "Choice", "Wage"]
+ [f"Experience_{choice.title()}" for choice in optim_paras["choices_w_exp"]]
+ [f"Lagged_Choice_{i}" for i in range(1, optim_paras["n_lagged_choices"] + 1)]
+ [observable.title() for observable in optim_paras["observables"]]
)
column_dtype_dict = {}
for label in labels:
if label == "Wage":
column_dtype_dict[label] = float
elif "Choice" in label:
column_dtype_dict[label] = "category"
else:
column_dtype_dict[label] = int
return column_dtype_dict
def downcast_to_smallest_dtype(series, downcast_options=None):
"""Downcast the dtype of a :class:`pandas.Series` to the lowest possible dtype.
By default, variables are converted to signed or unsigned integers. Use ``"float"``
to cast variables from ``float64`` to ``float32``.
Be aware that NumPy integers silently overflow which is why conversion to low dtypes
should be done after calculations. For example, using :class:`numpy.uint8` for an
array and squaring the elements leads to silent overflows for numbers higher than
255.
For more information on the dtype boundaries see the NumPy documentation under
https://docs.scipy.org/doc/numpy-1.17.0/user/basics.types.html.
"""
# We can skip integer as "unsigned" and "signed" will find the same dtypes.
if downcast_options is None:
downcast_options = ["unsigned", "signed"]
if series.dtype.name == "category":
out = series
else:
min_dtype = series.dtype
for dc_opt in downcast_options:
try:
dtype = pd.to_numeric(series, downcast=dc_opt).dtype
# A ValueError happens if strings are found in the series.
except ValueError:
min_dtype = "category"
break
# If we can convert the series to an unsigned integer, we can stop.
if dtype.name.startswith("u"):
min_dtype = dtype
break
elif dtype.itemsize < min_dtype.itemsize:
min_dtype = dtype
else:
pass
out = series.astype(min_dtype)
return out
def compute_covariates(df, definitions, check_nans=False, raise_errors=True):
"""Compute covariates.
The function iterates over the definitions of covariates and tries to compute them.
It keeps track on how many covariates still need to be computed and stops if the
number does not change anymore. This might be due to missing information.
Parameters
----------
df : pandas.DataFrame
DataFrame with some, maybe not all state space dimensions like period,
experiences.
definitions : dict
Keys represent covariates and values are strings passed to ``df.eval``.
check_nans : bool, default False
Perform a check whether the variables used to compute the selected covariate do
not contain any `np.nan`. This is necessary in
:func:`respy.simulate._sample_characteristic` where some characteristics may
contain missings.
raise_errors : bool, default True
Whether to raise errors if variables cannot be computed. This option is
necessary for, e.g., :func:`~respy.simulate._sample_characteristic` where not
all necessary variables exist and it is not easy to exclude covariates which
depend on them.
Returns
-------
covariates : pandas.DataFrame
DataFrame with shape (n_states, n_covariates).
Raises
------
Exception
If variables cannot be computed and ``raise_errors`` is true.
"""
has_covariates_left_changed = True
covariates_left = list(definitions)
while has_covariates_left_changed:
n_covariates_left = len(covariates_left)
# Create a copy of `covariates_left` to remove elements without side-effects.
for covariate in covariates_left.copy():
# Check if the covariate does not exist and needs to be computed.
is_covariate_missing = covariate not in df.columns
if not is_covariate_missing:
covariates_left.remove(covariate)
continue
# Check that the dependencies are present.
index_or_columns = df.columns.union(df.index.names)
are_dependencies_present = all(
dep in index_or_columns for dep in definitions[covariate]["depends_on"]
)
if are_dependencies_present:
# If true, perform checks for NaNs.
if check_nans:
have_dependencies_no_missings = all(
df.eval(f"{dep}.notna().all()")
for dep in definitions[covariate]["depends_on"]
)
else:
have_dependencies_no_missings = True
else:
have_dependencies_no_missings = False
if have_dependencies_no_missings:
df[covariate] = df.eval(definitions[covariate]["formula"])
covariates_left.remove(covariate)
has_covariates_left_changed = n_covariates_left != len(covariates_left)
if covariates_left and raise_errors:
raise Exception(f"Cannot compute all covariates: {covariates_left}.")
return df
def convert_labeled_variables_to_codes(df, optim_paras):
"""Convert labeled variables to codes.
We need to check choice variables and observables for potential labels. The
mapping from labels to code can be inferred from the order in ``optim_paras``.
"""
choices_to_codes = {choice: i for i, choice in enumerate(optim_paras["choices"])}
if "choice" in df.columns:
df.choice = df.choice.replace(choices_to_codes).astype(np.uint8)
for i in range(1, optim_paras["n_lagged_choices"] + 1):
label = f"lagged_choice_{i}"
if label in df.columns:
df[label] = df[label].replace(choices_to_codes).astype(np.uint8)
observables = optim_paras["observables"]
for observable in observables:
if observable in df.columns:
levels_to_codes = {lev: i for i, lev in enumerate(observables[observable])}
df[observable] = df[observable].replace(levels_to_codes).astype(np.uint8)
return df
def rename_labels_to_internal(x):
"""Shorten labels and convert them to lower-case."""
return x.replace("Experience", "exp").lower()
def rename_labels_from_internal(x):
"""Shorten labels and convert them to lower-case."""
return x.replace("exp", "Experience").title()
def normalize_probabilities(probabilities):
"""Normalize probabilities such that their sum equals one.
Examples
--------
The following `probs` do not sum to one after dividing by the sum.
>>> probs = np.array([0.3775843411510946, 0.5384246942799851, 0.6522988820635421])
>>> normalize_probabilities(probs)
array([0.24075906, 0.34331568, 0.41592526])
"""
probabilities = probabilities / np.sum(probabilities)
probabilities[-1] = 1 - probabilities[:-1].sum()
return probabilities
@nb.guvectorize(
["f8, f8, f8, f8, f8, f8[:], f8[:]"],
"(), (), (), (), () -> (), ()",
nopython=True,
target="parallel",
)
def calculate_value_functions_and_flow_utilities(
wage, nonpec, continuation_value, draw, delta, value_function, flow_utility
):
"""Calculate the choice-specific value functions and flow utilities.
To apply :func:`aggregate_keane_wolpin_utility` to arrays with arbitrary dimensions,
this function uses :func:`numba.guvectorize`. One cannot use :func:`numba.vectorize`
because it does not support multiple return values.
See also
--------
aggregate_keane_wolpin_utility
"""
value_function[0], flow_utility[0] = aggregate_keane_wolpin_utility(
wage, nonpec, continuation_value, draw, delta
)
def create_core_state_space_columns(optim_paras):
"""Create internal column names for the core state space."""
return [f"exp_{choice}" for choice in optim_paras["choices_w_exp"]] + [
f"lagged_choice_{i}" for i in range(1, optim_paras["n_lagged_choices"] + 1)
]
def create_dense_state_space_columns(optim_paras):
"""Create internal column names for the dense state space."""
columns = list(optim_paras["observables"])
if optim_paras["n_types"] >= 2:
columns += ["type"]
return columns
def create_dense_choice_state_space_columns(optim_paras):
"""Create internal column names for the dense state space."""
columns = list(optim_paras["observables"]) + [
f"_{x}" for x in optim_paras["choices"]
]
if optim_paras["n_types"] >= 2:
columns += ["type"]
return columns
def create_state_space_columns(optim_paras):
"""Create names of state space dimensions excluding the period and identifier."""
return create_core_state_space_columns(
optim_paras
) + create_dense_state_space_columns(optim_paras)
@nb.guvectorize(
["f8[:], f8[:], f8[:], f8[:, :], f8, f8[:]"],
"(n_choices), (n_choices), (n_choices), (n_draws, n_choices), () -> ()",
nopython=True,
target="parallel",
)
def calculate_expected_value_functions(
wages, nonpecs, continuation_values, draws, delta, expected_value_functions
):
r"""Calculate the expected maximum of value functions for a set of unobservables.
The function takes an agent and calculates the utility for each of the choices, the
ex-post rewards, with multiple draws from the distribution of unobservables and adds
the discounted expected maximum utility of subsequent periods resulting from
choices. Averaging over all maximum utilities yields the expected maximum utility of
this state.
The underlying process in this function is called `Monte Carlo integration
<https://en.wikipedia.org/wiki/Monte_Carlo_integration>`_. The goal is to
approximate an integral by evaluating the integrand at randomly chosen points. In
this setting, one wants to approximate the expected maximum utility of the current
state.
Note that ``wages`` have the same length as ``nonpecs`` despite that wages are only
available in some choices. Missing choices are filled with ones. In the case of a
choice with wage and without wage, flow utilities are
.. math::
\text{Flow Utility} = \text{Wage} * \epsilon + \text{Non-pecuniary}
\text{Flow Utility} = 1 * \epsilon + \text{Non-pecuniary}
Parameters
----------
wages : numpy.ndarray
Array with shape (n_choices,) containing wages.
nonpecs : numpy.ndarray
Array with shape (n_choices,) containing non-pecuniary rewards.
continuation_values : numpy.ndarray
Array with shape (n_choices,) containing expected maximum utility for each
choice in the subsequent period.
draws : numpy.ndarray
Array with shape (n_draws, n_choices).
delta : float
The discount factor.
Returns
-------
expected_value_functions : float
Expected maximum utility of an agent.
"""
n_draws, n_choices = draws.shape
expected_value_functions[0] = 0
for i in range(n_draws):
max_value_functions = 0
for j in range(n_choices):
value_function, _ = aggregate_keane_wolpin_utility(
wages[j], nonpecs[j], continuation_values[j], draws[i, j], delta
)
if value_function > max_value_functions:
max_value_functions = value_function
expected_value_functions[0] += max_value_functions
expected_value_functions[0] /= n_draws
def convert_dictionary_keys_to_dense_indices(dictionary):
"""Convert the keys to tuples containing integers.
Examples
--------
>>> dictionary = {(0.0, 1): 0, 2: 1}
>>> convert_dictionary_keys_to_dense_indices(dictionary)
{(0, 1): 0, (2,): 1}
"""
new_dictionary = {}
for key, val in dictionary.items():
new_key = (int(key),) if np.isscalar(key) else tuple(int(i) for i in key)
new_dictionary[new_key] = val
return new_dictionary
def subset_cholesky_factor_to_choice_set(cholesky_factor, choice_set):
"""Subset the Cholesky factor to dimensions required by the admissible choice set.
Examples
--------
>>> m = np.arange(9).reshape(3, 3)
>>> subset_cholesky_factor_to_choice_set(m, (False, True, False))
array([[4]])
"""
rows_cols_to_keep = np.where(choice_set)[0]
out = cholesky_factor[rows_cols_to_keep][:, rows_cols_to_keep]
return out
def return_core_dense_key(core_idx, dense=False):
"""Return core dense keys in the right format."""
if dense is False:
return (core_idx, 0)
else:
return (core_idx, dense)
def pandas_dot(x, beta, out=None):
"""Compute the dot product for a DataFrame and a Series.
The function computes each product in the dot product separately to limit the impact
of converting a Series to an array.
To access the NumPy array, `.values` is used instead of `.to_numpy()` because it is
faster and the latter avoids problems for extension arrays which are not used here.
Parameters
----------
x : pandas.DataFrame
A DataFrame containing the covariates of the dot product.
beta : pandas.Series
A Series containing the parameters or coefficients of the dot product.
out : numpy.ndarray or optional
An output array can be passed to the function which is filled instead of
allocating a new array.
Returns
-------
out : numpy.ndarray
Array with shape `len(x)` which contains the solution of the dot product.
Examples
--------
>>> x = pd.DataFrame(np.arange(10).reshape(5, 2), columns=list("ab"))
>>> beta = pd.Series([1, 2], index=list("ab"))
>>> x.dot(beta).to_numpy()
array([ 2, 8, 14, 20, 26]...
>>> pandas_dot(x, beta)
array([ 2., 8., 14., 20., 26.])
"""
received_out = False if out is None else True
if not received_out:
out = np.zeros(x.shape[0])
for covariate, beta in beta.items():
out += beta * x[covariate].values
if not received_out:
return out
def map_observations_to_states(states, state_space, optim_paras):
"""Map observations in data to states."""
core_columns = ["period"] + create_core_state_space_columns(optim_paras)
core = states.reset_index(level="period")[core_columns].to_numpy(dtype="int64")
core_key, core_index = _map_observations_to_core_states_numba(
core, state_space.indexer
)
if state_space.dense_covariates_to_dense_index:
dense_columns = create_dense_state_space_columns(optim_paras)
dense = states[dense_columns].to_numpy(dtype="int64")
dense_key = _map_observations_to_dense_index(
dense,
core_key,
state_space.dense_covariates_to_dense_index,
state_space.core_key_and_dense_index_to_dense_key,
)
else:
dense_key = core_key.copy()
return dense_key, core_index
@nb.njit
def _map_observations_to_core_states_numba(core, indexer):
"""Map observations to states in Numba."""
n_observations = core.shape[0]
core_key = np.zeros(n_observations, dtype=np.int64)
core_index = np.zeros(n_observations, dtype=np.int64)
for i in range(n_observations):
core_key_, core_index_ = indexer[array_to_tuple(indexer, core[i])]
core_key[i] = core_key_
core_index[i] = core_index_
return core_key, core_index
@nb.njit
def _map_observations_to_dense_index(
dense,
core_index,
dense_covariates_to_dense_index,
core_key_and_dense_index_to_dense_key,
):
n_observations = dense.shape[0]
dense_key = np.zeros(n_observations, dtype=np.int64)
for i in range(n_observations):
dense_index = dense_covariates_to_dense_index[
array_to_tuple(dense_covariates_to_dense_index, dense[i])
]
dense_key_ = core_key_and_dense_index_to_dense_key[(core_index[i], dense_index)]
dense_key[i] = dense_key_
return dense_key
def dump_states(states, complex_, options):
"""Dump states."""
file_name = _create_file_name_from_complex_index(complex_)
states.to_parquet(
options["cache_path"] / file_name, compression=options["cache_compression"],
)
def load_states(complex_, options):
"""Load states."""
file_name = _create_file_name_from_complex_index(complex_)
directory = options["cache_path"]
return pd.read_parquet(directory / file_name)
def _create_file_name_from_complex_index(complex_):
"""Create a file name from a complex index."""
choice = "".join([str(int(x)) for x in complex_[1]])
if len(complex_) == 3:
file_name = f"{complex_[0]}_{choice}_{complex_[2]}.parquet"
elif len(complex_) == 2:
file_name = f"{complex_[0]}_{choice}.parquet"
else:
raise NotImplementedError
return file_name
def prepare_cache_directory(options):
"""Prepare cache directory.
The directory contains the parts of the state space.
"""
directory = options["cache_path"]
if directory.exists():
shutil.rmtree(directory)
directory.mkdir(parents=True, exist_ok=True)
return directory
def select_valid_choices(choices, choice_set):
"""Select valid choices.
Examples
--------
>>> select_valid_choices(list("abcde"), (1, 0, 1, 0, 1))
['a', 'c', 'e']
>>> select_valid_choices(list("abc"), (0, 1, 0, 1, 0))
['b']
"""
return [x for i, x in enumerate(choices) if choice_set[i]]
| 34.009957 | 88 | 0.678698 |
108618ef3118fdf97bad71c503cda8ff418b5049 | 1,803 | py | Python | nesta/packages/crunchbase/predict/data.py | anniyanvr/nesta | 4b3ae79922cebde0ad33e08ac4c40b9a10e8e7c3 | [
"MIT"
] | 13 | 2019-06-18T16:53:53.000Z | 2021-03-04T10:58:52.000Z | nesta/packages/crunchbase/predict/data.py | nestauk/old_nesta_daps | 4b3ae79922cebde0ad33e08ac4c40b9a10e8e7c3 | [
"MIT"
] | 208 | 2018-08-10T13:15:40.000Z | 2021-07-21T10:16:07.000Z | nesta/packages/crunchbase/predict/data.py | nestauk/old_nesta_daps | 4b3ae79922cebde0ad33e08ac4c40b9a10e8e7c3 | [
"MIT"
] | 8 | 2018-09-20T15:19:23.000Z | 2020-12-15T17:41:34.000Z | """
Creates a training dataset by applying a boolean field based on the presence of keywords
within the data. This is primarily designed for use with the crunchbase organisation
data but should be applicable to other similar processes.
"""
import numpy as np
def label_data(data, keywords, column, label_name, size, random_seed=42):
"""Adds a boolean column to a dataframe based on the value of a columns and a list
of keywords. A sample of the original data is returned.
Args:
data (:obj: `pandas.DataFrame`): dataframe containing the column to label
keywords (list): keywords to check for
column (str): target column in the dataframe
label_name (str): column name to use for the boolean
size (int): sample number of records from data
random_seed (int): seed for the numpy random generator
Returns:
(:obj: `pandas.DataFrame): original data with label added as an additonal column
"""
np.random.seed(random_seed)
data[label_name] = data[column].apply(lambda x: int(any(k in str(x)
for k in keywords)))
data_idx = np.random.choice(data.index, size, replace=False)
data = data.loc[data_idx]
return data
if __name__ == '__main__':
import json
import pandas as pd
import pickle
import sys
org_file = sys.argv[1]
orgs = pd.read_csv(org_file)
orgs = orgs[~orgs.category_list.isnull()]
with open('health_keywords.json') as f:
health_keywords = json.load(f)
labeled = label_data(orgs, health_keywords, 'category_list', 'is_health', 200000)
labeled = labeled[['category_list', 'is_health']]
with open('../data/training_data/training_data.pickle', 'wb') as h:
pickle.dump(labeled, h)
| 34.018868 | 88 | 0.66944 |
0c77164135eb4c03a09691d09708c3f97774719a | 8,151 | py | Python | sympy/utilities/_compilation/util.py | Michal-Gagala/sympy | 3cc756c2af73b5506102abaeefd1b654e286e2c8 | [
"MIT"
] | null | null | null | sympy/utilities/_compilation/util.py | Michal-Gagala/sympy | 3cc756c2af73b5506102abaeefd1b654e286e2c8 | [
"MIT"
] | null | null | null | sympy/utilities/_compilation/util.py | Michal-Gagala/sympy | 3cc756c2af73b5506102abaeefd1b654e286e2c8 | [
"MIT"
] | null | null | null | from collections import namedtuple
from hashlib import sha256
import os
import shutil
import sys
import fnmatch
from sympy.testing.pytest import XFAIL
def may_xfail(func):
if sys.platform.lower() == 'darwin' or os.name == 'nt':
# sympy.utilities._compilation needs more testing on Windows and macOS
# once those two platforms are reliably supported this xfail decorator
# may be removed.
return XFAIL(func)
else:
return func
class CompilerNotFoundError(FileNotFoundError):
pass
class CompileError (Exception):
"""Failure to compile one or more C/C++ source files."""
def get_abspath(path, cwd='.'):
""" Returns the aboslute path.
Parameters
==========
path : str
(relative) path.
cwd : str
Path to root of relative path.
"""
if os.path.isabs(path):
return path
else:
if not os.path.isabs(cwd):
cwd = os.path.abspath(cwd)
return os.path.abspath(
os.path.join(cwd, path)
)
def make_dirs(path):
""" Create directories (equivalent of ``mkdir -p``). """
if path[-1] == '/':
parent = os.path.dirname(path[:-1])
else:
parent = os.path.dirname(path)
if len(parent) > 0:
if not os.path.exists(parent):
make_dirs(parent)
if not os.path.exists(path):
os.mkdir(path, 0o777)
else:
assert os.path.isdir(path)
def copy(src, dst, only_update=False, copystat=True, cwd=None,
dest_is_dir=False, create_dest_dirs=False):
""" Variation of ``shutil.copy`` with extra options.
Parameters
==========
src : str
Path to source file.
dst : str
Path to destination.
only_update : bool
Only copy if source is newer than destination
(returns None if it was newer), default: ``False``.
copystat : bool
See ``shutil.copystat``. default: ``True``.
cwd : str
Path to working directory (root of relative paths).
dest_is_dir : bool
Ensures that dst is treated as a directory. default: ``False``
create_dest_dirs : bool
Creates directories if needed.
Returns
=======
Path to the copied file.
"""
if cwd: # Handle working directory
if not os.path.isabs(src):
src = os.path.join(cwd, src)
if not os.path.isabs(dst):
dst = os.path.join(cwd, dst)
if not os.path.exists(src): # Make sure source file extists
raise FileNotFoundError("Source: `{}` does not exist".format(src))
# We accept both (re)naming destination file _or_
# passing a (possible non-existent) destination directory
if dest_is_dir:
if not dst[-1] == '/':
dst = dst+'/'
else:
if os.path.exists(dst) and os.path.isdir(dst):
dest_is_dir = True
if dest_is_dir:
dest_dir = dst
dest_fname = os.path.basename(src)
dst = os.path.join(dest_dir, dest_fname)
else:
dest_dir = os.path.dirname(dst)
if not os.path.exists(dest_dir):
if create_dest_dirs:
make_dirs(dest_dir)
else:
raise FileNotFoundError("You must create directory first.")
if only_update:
# This function is not defined:
# XXX: This branch is clearly not tested!
if not missing_or_other_newer(dst, src): # noqa
return
if os.path.islink(dst):
dst = os.path.abspath(os.path.realpath(dst), cwd=cwd)
shutil.copy(src, dst)
if copystat:
shutil.copystat(src, dst)
return dst
Glob = namedtuple('Glob', 'pathname')
ArbitraryDepthGlob = namedtuple('ArbitraryDepthGlob', 'filename')
def glob_at_depth(filename_glob, cwd=None):
if cwd is not None:
cwd = '.'
globbed = []
for root, dirs, filenames in os.walk(cwd):
for fn in filenames:
# This is not tested:
if fnmatch.fnmatch(fn, filename_glob):
globbed.append(os.path.join(root, fn))
return globbed
def sha256_of_file(path, nblocks=128):
""" Computes the SHA256 hash of a file.
Parameters
==========
path : string
Path to file to compute hash of.
nblocks : int
Number of blocks to read per iteration.
Returns
=======
hashlib sha256 hash object. Use ``.digest()`` or ``.hexdigest()``
on returned object to get binary or hex encoded string.
"""
sh = sha256()
with open(path, 'rb') as f:
for chunk in iter(lambda: f.read(nblocks*sh.block_size), b''):
sh.update(chunk)
return sh
def sha256_of_string(string):
""" Computes the SHA256 hash of a string. """
sh = sha256()
sh.update(string)
return sh
def pyx_is_cplus(path):
"""
Inspect a Cython source file (.pyx) and look for comment line like:
# distutils: language = c++
Returns True if such a file is present in the file, else False.
"""
for line in open(path):
if line.startswith('#') and '=' in line:
splitted = line.split('=')
if len(splitted) != 2:
continue
lhs, rhs = splitted
if lhs.strip().split()[-1].lower() == 'language' and \
rhs.strip().split()[0].lower() == 'c++':
return True
return False
def import_module_from_file(filename, only_if_newer_than=None):
""" Imports Python extension (from shared object file)
Provide a list of paths in `only_if_newer_than` to check
timestamps of dependencies. import_ raises an ImportError
if any is newer.
Word of warning: The OS may cache shared objects which makes
reimporting same path of an shared object file very problematic.
It will not detect the new time stamp, nor new checksum, but will
instead silently use old module. Use unique names for this reason.
Parameters
==========
filename : str
Path to shared object.
only_if_newer_than : iterable of strings
Paths to dependencies of the shared object.
Raises
======
``ImportError`` if any of the files specified in ``only_if_newer_than`` are newer
than the file given by filename.
"""
path, name = os.path.split(filename)
name, ext = os.path.splitext(name)
name = name.split('.')[0]
if sys.version_info[0] == 2:
from imp import find_module, load_module
fobj, filename, data = find_module(name, [path])
if only_if_newer_than:
for dep in only_if_newer_than:
if os.path.getmtime(filename) < os.path.getmtime(dep):
raise ImportError("{} is newer than {}".format(dep, filename))
mod = load_module(name, fobj, filename, data)
else:
import importlib.util
spec = importlib.util.spec_from_file_location(name, filename)
if spec is None:
raise ImportError("Failed to import: '%s'" % filename)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
return mod
def find_binary_of_command(candidates):
""" Finds binary first matching name among candidates.
Calls ``which`` from shutils for provided candidates and returns
first hit.
Parameters
==========
candidates : iterable of str
Names of candidate commands
Raises
======
CompilerNotFoundError if no candidates match.
"""
from shutil import which
for c in candidates:
binary_path = which(c)
if c and binary_path:
return c, binary_path
raise CompilerNotFoundError('No binary located for candidates: {}'.format(candidates))
def unique_list(l):
""" Uniquify a list (skip duplicate items). """
result = []
for x in l:
if x not in result:
result.append(x)
return result
| 28.400697 | 91 | 0.58913 |
468b860277d3cc6d207a99f3e790bd594ff4203d | 5,592 | py | Python | backend/Hinkskalle/tests/models/test_Entity.py | h3kker/hinkskalle | 609ab67468b7be0e84cf6044ffb5938afcaa0813 | [
"MIT"
] | 4 | 2021-08-07T02:45:40.000Z | 2022-02-16T09:43:11.000Z | backend/Hinkskalle/tests/models/test_Entity.py | h3kker/hinkskalle | 609ab67468b7be0e84cf6044ffb5938afcaa0813 | [
"MIT"
] | 11 | 2021-12-17T15:34:18.000Z | 2022-03-31T08:58:12.000Z | backend/Hinkskalle/tests/models/test_Entity.py | h3kker/hinkskalle | 609ab67468b7be0e84cf6044ffb5938afcaa0813 | [
"MIT"
] | 1 | 2021-08-07T02:45:49.000Z | 2021-08-07T02:45:49.000Z | from datetime import datetime, timedelta
from Hinkskalle.models.Entity import Entity, EntitySchema
from Hinkskalle.models.Collection import Collection
from Hinkskalle import db
from ..model_base import ModelBase
from .._util import _create_user, _create_image
class TestEntity(ModelBase):
def test_entity(self):
entity = Entity(name='test-hase')
db.session.add(entity)
db.session.commit()
read_entity = Entity.query.filter_by(name='test-hase').first()
self.assertEqual(read_entity.id, entity.id)
self.assertTrue(abs(read_entity.createdAt - datetime.now()) < timedelta(seconds=1))
def test_entity_case(self):
entity = Entity(name='TestHase')
db.session.add(entity)
db.session.commit()
read_entity = Entity.query.get(entity.id)
self.assertEqual(read_entity.name, 'testhase')
def test_count(self):
ent = Entity(name='test-hase')
self.assertEqual(ent.size(), 0)
db.session.add(ent)
db.session.commit()
self.assertEqual(ent.size(), 0)
coll1 = Collection(name='coll_i', entity_ref=ent)
db.session.add(coll1)
db.session.commit()
self.assertEqual(ent.size(), 1)
other_ent = Entity(name='other-hase')
db.session.add(other_ent)
db.session.commit()
other_coll = Collection(name="coll_other", entity_ref=other_ent)
db.session.add(other_coll)
db.session.commit()
self.assertEqual(ent.size(), 1)
def test_used_quota_null(self):
ent = Entity(name='test-quota')
self.assertEqual(ent.calculate_used(), 0)
self.assertEqual(ent.used_quota, 0)
image1 = _create_image(postfix='1')[0]
image1.container_ref.collection_ref.entity_ref=ent
image1.size = None
image1.uploaded = True
self.assertEqual(ent.calculate_used(), 0)
def test_used_quota(self):
ent = Entity(name='test-quota')
self.assertEqual(ent.calculate_used(), 0)
self.assertEqual(ent.used_quota, 0)
image1 = _create_image(postfix='1')[0]
image1.container_ref.collection_ref.entity_ref=ent
image1.size=200
image1.location='/da/ham1'
image1.uploaded=True
self.assertEqual(ent.calculate_used(), 200)
self.assertEqual(ent.used_quota, 200)
self.assertEqual(image1.container_ref.used_quota, 200)
self.assertEqual(image1.container_ref.collection_ref.used_quota, 200)
image2 = _create_image(postfix='2')[0]
image2.container_ref.collection_ref.entity_ref=ent
image2.size=300
image2.location='/da/ham2'
image2.uploaded=True
self.assertEqual(ent.calculate_used(), 500)
self.assertEqual(image2.container_ref.used_quota, 300)
self.assertEqual(image2.container_ref.collection_ref.used_quota, 300)
image2_same = _create_image(postfix='2_same')[0]
image2_same.container_ref.collection_ref.entity_ref=ent
image2_same.size=400
image2_same.location='/da/ham2'
image2_same.uploaded=True
self.assertEqual(ent.calculate_used(), 500)
self.assertEqual(image2_same.container_ref.used_quota, 400)
self.assertEqual(image2_same.container_ref.collection_ref.used_quota, 400)
image3 = _create_image(postfix='3')[0]
image3.container_ref.collection_ref=image2_same.container_ref.collection_ref
image3.size=600
image3.location='/da/ham2'
image3.uploaded=True
self.assertEqual(ent.calculate_used(), 500)
self.assertEqual(image3.container_ref.used_quota, 600)
self.assertEqual(image3.container_ref.collection_ref.used_quota, 400)
image4_upl = _create_image(postfix='4')[0]
image4_upl.container_ref.collection_ref.entity_ref=ent
image4_upl.size=300
image4_upl.location='/da/ham3'
image4_upl.uploaded=False
self.assertEqual(ent.calculate_used(), 500)
self.assertEqual(image4_upl.container_ref.used_quota, 0)
self.assertEqual(image4_upl.container_ref.collection_ref.used_quota, 0)
def test_access(self):
admin = _create_user(name='admin.oink', is_admin=True)
user = _create_user(name='user.oink', is_admin=False)
entity = Entity(name='test-hase')
self.assertTrue(entity.check_access(admin))
self.assertFalse(entity.check_access(user))
entity.owner=user
self.assertTrue(entity.check_access(user))
default = Entity(name='default')
self.assertTrue(default.check_access(user))
def test_update_access(self):
admin = _create_user(name='admin.oink', is_admin=True)
user = _create_user(name='user.oink', is_admin=False)
entity = Entity(name='test-hase')
self.assertTrue(entity.check_update_access(admin))
self.assertFalse(entity.check_update_access(user))
entity.owner=user
self.assertTrue(entity.check_update_access(user))
default = Entity(name='default')
self.assertFalse(default.check_update_access(user))
def test_schema(self):
entity = Entity(name='Test Hase')
schema = EntitySchema()
serialized = schema.dump(entity)
self.assertEqual(serialized.data['id'], entity.id)
self.assertEqual(serialized.data['name'], entity.name)
self.assertIsNone(serialized.data['deletedAt'])
self.assertFalse(serialized.data['deleted'])
entity.used_quota = 999
serialized = schema.dump(entity)
self.assertEqual(serialized.data['usedQuota'], 999)
def test_quota_default(self):
entity = Entity(name='test1hase')
db.session.add(entity)
db.session.commit()
self.assertEqual(entity.quota, 0)
self.app.config['DEFAULT_USER_QUOTA']=100
entity = Entity(name='test2hase')
db.session.add(entity)
db.session.commit()
self.assertEqual(entity.quota, 100)
self.app.config.pop('DEFAULT_USER_QUOTA') | 32.701754 | 87 | 0.728541 |
fd7550bcdb35c973cf1fe74b9319a3dca969e1d1 | 5,416 | py | Python | admin/shop/views.py | wfpinedar/shopping_app | bbb24a5d2ef139bc1ea2be35a1a5c06af71c1feb | [
"WTFPL"
] | null | null | null | admin/shop/views.py | wfpinedar/shopping_app | bbb24a5d2ef139bc1ea2be35a1a5c06af71c1feb | [
"WTFPL"
] | null | null | null | admin/shop/views.py | wfpinedar/shopping_app | bbb24a5d2ef139bc1ea2be35a1a5c06af71c1feb | [
"WTFPL"
] | null | null | null | from rest_framework import viewsets, status
from rest_framework.response import Response
from rest_framework.views import APIView
from .models import Shipment, Payment, Product, Order
from .serializers import ShipmentSerializer, PaymentSerializer, ProductSerializer, OrderSerializer
from rest_framework.authentication import SessionAuthentication, BasicAuthentication
from rest_framework.permissions import IsAuthenticated
def _get_object(model, object_id):
try:
return model.objects.get(id=object_id)
except:
raise Http404
class ShipmentViewSet(viewsets.ViewSet):
authentication_classes = [SessionAuthentication, BasicAuthentication]
permission_classes = [IsAuthenticated]
def list(self, request):
shipments = Shipment.objects.all()
serializer = ShipmentSerializer(shipments, many=True)
return Response(serializer.data)
def create(self, request):
serializer = ShipmentSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def retrieve(self, request, pk=None):
shipment = _get_object(model=Shipment, object_id=pk)
serializer = ShipmentSerializer(shipment)
return Response(serializer.data)
def update(self, request, pk=None):
shipment = Shipment.objects.get(id=pk)
serializer = ShipmentSerializer(instance=shipment, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
def destroy(self, request, pk=None):
shipment = Shipment.objects.get(id=pk)
shipment.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
class PaymentViewSet(viewsets.ViewSet):
def list(self, request):
payments = Payment.objects.all()
serializer = PaymentSerializer(payments, many=True)
return Response(serializer.data)
def create(self, request):
serializer = PaymentSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def retrieve(self, request, pk=None):
payment = _get_object(model=Payment, object_id=pk)
serializer = PaymentSerializer(payment)
return Response(serializer.data)
def update(self, request, pk=None):
payment = Payment.objects.get(id=pk)
serializer = PaymentSerializer(instance=payment, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
def destroy(self, request, pk=None):
payment = Payment.objects.get(id=pk)
payment.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
class ProductViewSet(viewsets.ViewSet):
def list(self, request):
products = Product.objects.all()
serializer = ProductSerializer(products, many=True)
return Response(serializer.data)
def create(self, request):
serializer = ProductSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def retrieve(self, request, pk=None):
product = _get_object(model=Product, object_id=pk)
serializer = ProductSerializer(product)
return Response(serializer.data)
def update(self, request, pk=None):
product = Product.objects.get(id=pk)
serializer = ProductSerializer(instance=product, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
def destroy(self, request, pk=None):
product = Product.objects.get(id=pk)
product.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
class OrderViewSet(viewsets.ViewSet):
authentication_classes = [SessionAuthentication, BasicAuthentication]
permission_classes = [IsAuthenticated]
def list(self, request):
orders = Order.objects.all()
serializer = OrderSerializer(orders, many=True)
return Response(serializer.data)
def create(self, request):
serializer = OrderSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def retrieve(self, request, pk=None):
order = _get_object(model=Order, object_id=pk)
serializer = OrderSerializer(order)
return Response(serializer.data)
def update(self, request, pk=None):
order = Order.objects.get(id=pk)
serializer = OrderSerializer(instance=order, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
def destroy(self, request, pk=None):
order = Order.objects.get(id=pk)
order.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
class UserAPIView(APIView):
def create(self, serializer):
pass | 37.611111 | 98 | 0.701071 |
354e55fa586f557d5949420bab437773d533548e | 7,810 | py | Python | lib/AssemblyUtil/AssemblyUtilClient.py | gunturus/MyContigFilterRDP | 7a33f1c765c5fe3e20d92ee91f9d764f71625f9b | [
"MIT"
] | 1 | 2020-01-13T19:39:02.000Z | 2020-01-13T19:39:02.000Z | lib/AssemblyUtil/AssemblyUtilClient.py | gunturus/MyContigFilterRDP | 7a33f1c765c5fe3e20d92ee91f9d764f71625f9b | [
"MIT"
] | 15 | 2016-10-26T03:32:34.000Z | 2019-01-30T22:15:08.000Z | lib/AssemblyUtil/AssemblyUtilClient.py | gunturus/MyContigFilterRDP | 7a33f1c765c5fe3e20d92ee91f9d764f71625f9b | [
"MIT"
] | 14 | 2016-09-08T19:40:28.000Z | 2019-05-17T17:01:45.000Z | # -*- coding: utf-8 -*-
############################################################
#
# Autogenerated by the KBase type compiler -
# any changes made here will be overwritten
#
############################################################
from __future__ import print_function
# the following is a hack to get the baseclient to import whether we're in a
# package or not. This makes pep8 unhappy hence the annotations.
try:
# baseclient and this client are in a package
from .baseclient import BaseClient as _BaseClient # @UnusedImport
except:
# no they aren't
from baseclient import BaseClient as _BaseClient # @Reimport
import time
class AssemblyUtil(object):
def __init__(
self, url=None, timeout=30 * 60, user_id=None,
password=None, token=None, ignore_authrc=False,
trust_all_ssl_certificates=False,
auth_svc='https://kbase.us/services/authorization/Sessions/Login',
service_ver='release',
async_job_check_time_ms=100, async_job_check_time_scale_percent=150,
async_job_check_max_time_ms=300000):
if url is None:
raise ValueError('A url is required')
self._service_ver = service_ver
self._client = _BaseClient(
url, timeout=timeout, user_id=user_id, password=password,
token=token, ignore_authrc=ignore_authrc,
trust_all_ssl_certificates=trust_all_ssl_certificates,
auth_svc=auth_svc,
async_job_check_time_ms=async_job_check_time_ms,
async_job_check_time_scale_percent=async_job_check_time_scale_percent,
async_job_check_max_time_ms=async_job_check_max_time_ms)
def _check_job(self, job_id):
return self._client._check_job('AssemblyUtil', job_id)
def _get_assembly_as_fasta_submit(self, params, context=None):
return self._client._submit_job(
'AssemblyUtil.get_assembly_as_fasta', [params],
self._service_ver, context)
def get_assembly_as_fasta(self, params, context=None):
"""
Given a reference to an Assembly (or legacy ContigSet data object), along with a set of options,
construct a local Fasta file with the sequence data. If filename is set, attempt to save to the
specified filename. Otherwise, a random name will be generated.
:param params: instance of type "GetAssemblyParams" (@optional
filename) -> structure: parameter "ref" of String, parameter
"filename" of String
:returns: instance of type "FastaAssemblyFile" -> structure:
parameter "path" of String, parameter "assembly_name" of String
"""
job_id = self._get_assembly_as_fasta_submit(params, context)
async_job_check_time = self._client.async_job_check_time
while True:
time.sleep(async_job_check_time)
async_job_check_time = (async_job_check_time *
self._client.async_job_check_time_scale_percent / 100.0)
if async_job_check_time > self._client.async_job_check_max_time:
async_job_check_time = self._client.async_job_check_max_time
job_state = self._check_job(job_id)
if job_state['finished']:
return job_state['result'][0]
def _export_assembly_as_fasta_submit(self, params, context=None):
return self._client._submit_job(
'AssemblyUtil.export_assembly_as_fasta', [params],
self._service_ver, context)
def export_assembly_as_fasta(self, params, context=None):
"""
A method designed especially for download, this calls 'get_assembly_as_fasta' to do
the work, but then packages the output with WS provenance and object info into
a zip file and saves to shock.
:param params: instance of type "ExportParams" -> structure:
parameter "input_ref" of String
:returns: instance of type "ExportOutput" -> structure: parameter
"shock_id" of String
"""
job_id = self._export_assembly_as_fasta_submit(params, context)
async_job_check_time = self._client.async_job_check_time
while True:
time.sleep(async_job_check_time)
async_job_check_time = (async_job_check_time *
self._client.async_job_check_time_scale_percent / 100.0)
if async_job_check_time > self._client.async_job_check_max_time:
async_job_check_time = self._client.async_job_check_max_time
job_state = self._check_job(job_id)
if job_state['finished']:
return job_state['result'][0]
def _save_assembly_from_fasta_submit(self, params, context=None):
return self._client._submit_job(
'AssemblyUtil.save_assembly_from_fasta', [params],
self._service_ver, context)
def save_assembly_from_fasta(self, params, context=None):
"""
WARNING: has the side effect of moving the file to a temporary staging directory, because the upload
script for assemblies currently requires a working directory, not a specific file. It will attempt
to upload everything in that directory. This will move the file back to the original location, but
if you are trying to keep an open file handle or are trying to do things concurrently to that file,
this will break. So this method is certainly NOT thread safe on the input file.
:param params: instance of type "SaveAssemblyParams" (Options
supported: file / shock_id / ftp_url - mutualy exclusive
parameters pointing to file content workspace_name - target
workspace assembly_name - target object name Uploader options not
yet supported taxon_reference: The ws reference the assembly
points to. (Optional) source: The source of the data (Ex: Refseq)
date_string: Date (or date range) associated with data. (Optional)
contig_information_dict: A mapping that has is_circular and
description information (Optional)) -> structure: parameter "file"
of type "FastaAssemblyFile" -> structure: parameter "path" of
String, parameter "assembly_name" of String, parameter "shock_id"
of type "ShockNodeId", parameter "ftp_url" of String, parameter
"workspace_name" of String, parameter "assembly_name" of String
:returns: instance of String
"""
job_id = self._save_assembly_from_fasta_submit(params, context)
async_job_check_time = self._client.async_job_check_time
while True:
time.sleep(async_job_check_time)
async_job_check_time = (async_job_check_time *
self._client.async_job_check_time_scale_percent / 100.0)
if async_job_check_time > self._client.async_job_check_max_time:
async_job_check_time = self._client.async_job_check_max_time
job_state = self._check_job(job_id)
if job_state['finished']:
return job_state['result'][0]
def status(self, context=None):
job_id = self._client._submit_job('AssemblyUtil.status',
[], self._service_ver, context)
async_job_check_time = self._client.async_job_check_time
while True:
time.sleep(async_job_check_time)
async_job_check_time = (async_job_check_time *
self._client.async_job_check_time_scale_percent / 100.0)
if async_job_check_time > self._client.async_job_check_max_time:
async_job_check_time = self._client.async_job_check_max_time
job_state = self._check_job(job_id)
if job_state['finished']:
return job_state['result'][0]
| 51.045752 | 108 | 0.66991 |
5f52366f77002718d95da512b81b0a0dbcd77052 | 454,156 | py | Python | spacy/lang/el/lemmatizer/_nouns.py | cedar101/spaCy | 66e22098a8bb77cbe527b1a4a3c69ec1cfb56f95 | [
"MIT"
] | 12 | 2019-03-20T20:43:47.000Z | 2020-04-13T11:10:52.000Z | spacy/lang/el/lemmatizer/_nouns.py | cedar101/spaCy | 66e22098a8bb77cbe527b1a4a3c69ec1cfb56f95 | [
"MIT"
] | 13 | 2018-06-05T11:54:40.000Z | 2019-07-02T11:33:14.000Z | spacy/lang/el/lemmatizer/_nouns.py | cedar101/spaCy | 66e22098a8bb77cbe527b1a4a3c69ec1cfb56f95 | [
"MIT"
] | 1 | 2022-02-12T06:50:34.000Z | 2022-02-12T06:50:34.000Z | # coding: utf8
from __future__ import unicode_literals
NOUNS = set(
"""
-αλγία -βατώ -βατῶ -ούλα -πληξία -ώνυμο sofa table άβακας άβατο άβατον άβυσσος
άγανο άγαρ άγγελμα άγγελος άγγιγμα άγγισμα άγγλος άγημα άγιασμα άγιο φως
άγκλισμα άγκυρα άγμα άγνοια άγνωστος άγονο άγος άγουρος άγουσα άγρα άγρευμα
άγρευσις άγρωστη άγχος άγχωση άδεια άδειασμα άδικο άδραγμα άδυτο άζωτο άζωτον
άθεος άθλημα άθληση άθλησις άθλο άθλον άθλος άθος άθροιση άθροισμα άθυρμα
άκανθα άκανθος άκαρι άκατος άκμονας άκμων άκουσμα άκρα άκρη άκρια άκρο άκρον
άλβατρο άλβεδο άλγεβρα άλγη άλγος άλειμμα άλειψη άλεση άλεσις άλεσμα άλευρο
άλικο άλκα άλκαλι άλκη άλλαγμα άλλαντα άλλεν άλλιο άλλοθι άλμα άλμη άλμπατρος
άλμπουρο άλογο άλσος άλτης άλτο άλτο κόρνο άλτρια άλυσις άλυσος άλφα άλφιτο
άλωση άλωσις άμαξα άμαχος άμβικας άμβλυνση άμβλωση άμβλωσις άμβυκας άμβωνας
άμιλλα άμμος άμνιο άμπακας άμπακος άμπελος άμπικας άμπωτη άμπωτις άμυλο άμυλον
άμφιο άναμμα άναξ άνασσα άνδηρο άνδηρον άνδρας άνεμος άνεση άνεσις άνηθο
άνθημα άνθηση άνθησις άνθι άνθιση άνθισις άνθισμα άνθος άνθρακας άνθραξ
άνθρωπος άνοδος άνοια άνοιγμα άνοιξη άνοιξις άντερα άντερο άντζα άντληση
άντλιον άντρακλας άντραρος άντρας άντρο άντρον άντωση άνυσμα άνω σορβικά
άνωση άνωσις άξονας άξων άουτ άουτο ντα φε άπαις άπαν άπαντα άπαρση άπαρσις
άπηξ άπιον άπλα άπλοια άπλυτα άπλωμα άπνοια άποικος άποψη άποψις άππαρος άπωση
άρα κατάρα άρα μάρα άραβας άραγμα άραψ άρβυκας άρβυλο άργασμα άργητα άργιλος
άρδευση άρδευσις άρθρο άρθρον άρθρωμα άρθρωση άρθρωσις άρια άρκαλος άρκευθος
άρκος άρκτος άρμα μάχης άρμεγμα άρμενα άρμενο άρμενον άρμη άρμοση άρμοσις
άρνηση άρνησις άροση άροτρο άρουλα άρουρα άρπα άρπαγας άρπαγμα άρπασμα άρρενας
άρσις άρτος άρτυμα άρχοντας άρχος άρχων άρωμα άσβεστος άσθμα άσιος ο φλογώδης
άσκαυλος άσκηση άσκησις άσμα άσος άσπρη άσπρισμα άσπρο άσπρουγας άσσος άστατο
άστραμμα άστριος άστρο άστυ άσυλο άσφαλτος άτα άτι άτλαντας άτλας άτμιση
άτομο άτομον άτοπο άτρακτος άφεση άφημα άφθα άφιξη άφνιο άφρη άφρισμα
άφτρα άχερο άχης άχθος άχνα άχνη άχνισμα άχρεια άχτι άχυρο άψα άψη άψινθος
έβγα έβδομο έβενος έγγαλο έγγραμμα έγγραφο έγερση έγκατα έγκαυμα έγκλεισμα
έγκληση έγκλιση έγκοιλο έγκριση έγκυος έγνοια έγχελυς έγχορδο έγχυμα έγχυση
έδεσμα έδικτο έδικτον έδρα έδρανο έδρανον έδραση έθιμο έθνος έθος έιτζ έκβαση
έκδοση έκδοσις έκδοχο έκδοχον έκδυση έκδυσις έκζεμα έκθεμα έκθεση έκθεσις
έκθλιψις έκκαμψη έκκαυμα έκκεντρο έκκληση έκκλησις έκκριμα έκκριση έκκρισις
έκλειψη έκλειψις έκλυση έκλυσις έκπληξη έκπληξις έκπλους έκπλυμα έκπτωση
έκρηξη έκρηξις έκσταση έκστασις έκταξη έκταση έκτη έκτιση έκτισις έκτο έκτροπα
έκτρωση έκτρωσις έκφανση έκφανσις έκφραση έκφρασις έκφυση έκχυση έκχυσις έλαιο
έλασις έλασμα έλατο έλατος έλαφος έλεγχος έλεος έλευση έλευσις έλικα έλικας
έλκος έλκυση έλκωση έλλειμμα έλλειψη έλλην έλληνας έλμινθα έλξη έλξις έλος
έλπισις έλυτρο έμβασμα έμβλημα έμβολο έμβρυο έμενταλ έμεση έμεσμα έμετος
έμπα έμπλαστρο έμπνευση έμπνευσις έμπολα έμπορας έμπορος έμπυο έμφαση έμφασις
έμφραξη έμφραξις έναρξη έναυσμα ένδεια ένδειξη ένδεκα ένδυμα ένδυση ένδυσις
ένζυμο ένθεμα ένθεση ένθεσις ένθετο ένθημα ένοικος ένοπλος ένορκος ένσημο
ένσταση ένστασις ένστικτο ένστικτον ένστιχτο ένστολος ένστρωση ένταλμα ένταξη
έντερο έντομο έντρανς πολ έντυπο ένωση ένωσις έξαλα έξαρμα έξαρση έξαρσις
έξαψη έξη έξι έξις έξιτ πολ έξοδο έξοδος έξοδος έξτρα έξω έξωση έουε έπαθλο
έπαινος έπακρο έπακρον έπαλξη έπαρμα έπαρση έπαρσις έπαρχος έπαυλη έπαυλις
έποικος έποπας έπος έποψ έποψη έποψις έρανος έρβιο έργο έρεβος έρεισμα έρευνα
έριδα έριθος έριο έρις έρκος έρμα έρμαιο έρπης έρπητας έρυξ έρως έρωτας έσοδο
έσσω έτος έτσι έτυμον έφαψη έφεση έφηβη έφηβος έφοδος έφορος έχθρα έχθρητα
έχνος έχτρα έχτρητα έψηση έψιλον έψιμα ήβη ήδικτο ήθος ήλεκτρο ήλεκτρον
ήλιο ήλιος ήλος ήνυστρο ήπαρ ήπειρος ήρα ήρωας ήρως ήσκιος ήτα ήττα ήχος ίαμα
ίανθος ίαση ίασμος ίασπις ίβηρας ίβις ίγγλα ίγκλα ίγκμπο ίδιον ίδρος ίδρυμα
ίδρωμα ίδρωση ίδρωτας ίζημα ίζμπα ίκαρος ίκτερος ίλαρχος ίλη ίλιγγος ίμβριος
ίνα ίνδαλμα ίνδικτος ίνδιο ίντεξ ίντερνετ ίντο ίντριγκα ίντσα ίνωμα ίο ίον
ίππαθλο ίππαθλος ίππαρχος ίππευση ίππος ίριδα ίρις ίσαλα ίσιωμα ίσκα ίσκιος
ίσμπα ίσο ίσον ίσχαση ίσχνανση ίσωμα ίταμος ίχνος ίωση αέρας αέριο αέριον
αέτωμα αήρ αίγα αίγαγρος αίγειρος αίγλη αίθουσα αίθριο αίλουρος αίμα αίνιγμα
αίρεση αίρεσις αίρμπας αίσθημα αίσθηση αίσθησις αίσχος αίτημα αίτηση αίτησις
αίτιος ααχενόσαυρος αβάζι αβάθεια αβάκιο αβάκιον αβάνης αβάνς αβάντα αβάντζα
αβάντσα αβάντσο αβάρσαμο αβάς αβάσκαμα αβάσκαντο αβαγιανός αβαείο αβανγκάρντ
αβανγκαρντιστής αβανιά αβαντάζ αβανταδόρισσα αβανταδόρος αβαρία αβαρεσιά
αβασκαντήρα αβασταγή αβασταγό αβατσνιά αββάς αβγάτισμα αβγίλα αβγοδάρτης
αβγοθήκη αβγοκάσα αβγοκόψιμο αβγολέμονο αβγοτάραχο αβγοτέμπερα αβγουλάκι
αβγουλίλα αβγουλιέρα αβγουλομάτης αβγουλού αβγοφαγία αβγούλι αβγό αβγότσουφλο
αβδελλάς αβδηρίτης αβδηρίτισσα αβδηριτισμός αβεβαιότητα αβελτερία αβελτηρία
αβικέννια αβιογένεση αβιταμίνωση αβλάβεια αβλέμονας αβλέπτημα αβλεψία αβοκάντο
αβοκαντόσουπα αβορίγινες αβουλία αβουλησία αβροφροσύνη αβροχιά αβρότητα αβτζής
αγάθοσμα αγάντα αγάπανθος αγάπη αγάς αγέλη αγένεια αγέρανος αγίασμα αγαθά
αγαθάγγελος αγαθαγγελισμός αγαθαγγελιστής αγαθαρχία αγαθεμός αγαθοβουλία
αγαθοδωρία αγαθοεργία αγαθοθυμία αγαθολόγος αγαθολόι αγαθομάνι αγαθομάρα
αγαθοπιστία αγαθοποιία αγαθοσύνη αγαθουκλιά αγαθουργία αγαθωνυμία αγαθό
αγαθότης αγαθότητα αγαθόφυλλο αγαθόχορτο αγαλακτία αγαλλίαση αγαλλίασις
αγαλμάτιον αγαλματάκι αγαλματίδιο αγαλματίδιον αγαλματίτης αγαλματοποιία
αγαμία αγαμογένεση αγαμοείδος αγαμοσπερμία αγανάκτηση αγανάχτηση αγανακτισμός
αγαπημένα αγαπημένος αγαπημός αγαπητικιά αγαπητικός αγαπητικότητα αγαποβότανο
αγαρηνός αγαρικό αγαρμπιά αγαρμποσύνη αγαύη αγγάρεμα αγγέλιασμα αγγαρεία
αγγαροδουλειά αγγείο αγγείον αγγείωμα αγγειίτιδα αγγειεκτασία αγγειοβλάστη
αγγειογένεση αγγειογράφος αγγειογραφία αγγειοδερματίτιδα αγγειοδιασταλτικά
αγγειοδιαστολή αγγειοδυσπλασία αγγειοκαρδιογράφημα αγγειοκαρδιογραφία
αγγειολίπωμα αγγειολαβίδα αγγειολογία αγγειολόγος αγγειομυολίπωμα αγγειοοίδημα
αγγειοπιεσίνη αγγειοπλάστης αγγειοπλαστική αγγειορραγία αγγειοσάρκωμα
αγγειοσυστολή αγγειοτενσίνη αγγειοτενσινογόνο αγγειοχειρουργική
αγγειωμάτωση αγγειόσπασμος αγγειόσπερμα αγγελάκι αγγελία αγγελιαφόρος αγγελική
αγγελιοφόρος αγγελιόσημο αγγελοβάρεμα αγγελοβλεπούσα αγγελοθεσία αγγελολογία
αγγελοπρέπεια αγγελουδάκι αγγελούδι αγγελτήριο αγγελόκρουσμα αγγιό αγγλίδα
αγγλικά αγγλικανή αγγλικανισμός αγγλικανός αγγλισμός αγγλομανία
αγγλοσαξονικά αγγλοσαξωνικά αγγουράκι αγγουρέλαιο αγγουριά αγγουροντομάτα
αγγουρόνερο αγγουρόσουπα αγγούρι αγγρίφι αγγόνα αγελάδα αγελαδάρης
αγελαδοτροφία αγελαδοτρόφος αγερασιά αγερικό αγερσανιώτης αγερσανιώτισσα
αγηματάρχης αγιάζι αγιάρι αγιασμός αγιαστήρα αγιαστούρα αγιατολάχ αγιογδύτης
αγιογράφηση αγιογράφος αγιογραφία αγιοδημητριάτης αγιοδημητριάτικο αγιοκέρι
αγιολόγιο αγιολόγος αγιονορείτης αγιοποίηση αγιοποίησις αγιορείτης αγιοστέφανο
αγιούπας αγιωνυμία αγιωνύμιο αγιωτικά αγιωτικό αγιόκλημα αγιότητα αγιόφιδο
αγκάθι αγκάλη αγκάλιασμα αγκίδα αγκίθα αγκίστρι αγκίστρωμα αγκίστρωση
αγκαθιά αγκαθοκόπος αγκαθούλα αγκαθότοπος αγκαλιά αγκινάρα αγκιναριά
αγκιναροφαγία αγκιναρόκηπος αγκιναρόσουπα αγκιναρότοπος αγκιναρόφυλλο
αγκιστράς αγκιστριά αγκιτάτορας αγκιτάτσια αγκιό αγκλέορας αγκλέουρας αγκλίτσα
αγκολέζος αγκομάχημα αγκομαχητό αγκορτσιά αγκουρέτο αγκούσα αγκράφα
αγκυλοστομίαση αγκυροβολία αγκυροβόλημα αγκυροβόληση αγκυροβόλι αγκυροβόλιο
αγκωνάρι αγκωνή αγκωνιά αγκύλη αγκύλι αγκύλωμα αγκύλωση αγκύρωση αγκώνας
αγλάκι αγλέορας αγλέουρας αγλακιχτής αγλαόκαρπος αγλωσσία αγνά αγνάντεμα
αγνεία αγνισμός αγνοούμενος αγνωμοσύνη αγνωσία αγνωσιακός αγνωσιαρχία
αγνωσιοκρατία αγνωστικίστρια αγνωστικισμός αγνωστικιστής αγνωστισμός
αγνότης αγνότητα αγνύθα αγνώμονας αγονία αγορά αγοράκι αγοράστρια αγορήτρια
αγοραίο αγοραίον αγοραλογία αγορανομία αγορανόμος αγοραπωλησία αγορασιμότητα
αγοραφοβία αγορητής αγοροκόριτσο αγορολογία αγοροπωλησία αγουράδα αγουρέλαιο
αγουρίλα αγουροξύπνημα αγουρόλαδο αγουστιά αγράμπελη αγρέλι αγρέλλιν αγρίεμα
αγρίμι αγρίωμα αγραμματοσύνη αγρανάπαυση αγρανάπαυσις αγραφιώτης αγριάδα
αγριαγκινάρα αγριαπιδιά αγριαχλαδιά αγριαψιθιά αγριελιά αγριεμός αγριλίδα
αγριμοκυνηγός αγριμολόγος αγρινιώτης αγρινό αγριοβόρι αγριογαρίφαλο
αγριογούρουνο αγριοκάτσικο αγριοκοίταγμα αγριοκουμαριά αγριοκούναβο
αγριολίναρο αγριολεβάντα αγριολινάρι αγριολούλουδο αγριομηλιά αγριοπαπαρούνα
αγριοπερίστερο αγριορίγανη αγριοσινάπι αγριοσυκιά αγριοτριανταφυλλέλαιο
αγριοφωνάρα αγριοχορτοσαλάτα αγριόγαλος αγριόγατα αγριόγατος αγριόγιδο
αγριόκρινος αγριόπαπια αγριόπευκο αγριότης αγριότητα αγριότοπος αγριόχοιρος
αγροβιολογία αγροβιομηχανία αγροδιατροφή αγροζημία αγροικία αγροκήπιο
αγρολήπτης αγρολήπτρια αγροληψία αγρομίσθωση αγρονομία αγρονόμος αγροπόντικας
αγροτεμάχιο αγροτεμάχιον αγροτεχνική αγροτιά αγροτικό αγροτικός αγροτικότητα
αγροτοπατέρας αγροτοπατερισμός αγροτόσπιτο αγροφιλία αγροφυλακή αγροφύλακας
αγρυπνία αγρωνύμιο αγρωστίδες αγρωστοειδή αγρωστώδη αγρόκτημα αγρός αγρότης
αγρύπνια αγυιόπαιδο αγυιόπαις αγυμνασία αγυρτεία αγχίνοια αγχιστεία αγχολυτικά
αγωγή αγωγιάτης αγωγιάτικα αγωγιάτισσα αγωγιαστήριο αγωγιαστής αγωγιμομετρία
αγωγιμότητα αγωγός αγωγόσημο αγωνία αγωνίστρια αγωνιστής αγωνιστικότητα
αγωνοθέτης αγωνοθεσία αγόρασμα αγόρευση αγόρι αγύριστος αγύρτης αγύρτισσα
αγώι αγών αγώνας αγώνισμα αδάμαντας αδάμας αδέλφι αδέλφωμα αδένας αδένωμα
αδέρφωμα αδήν αδίκημα αδαημοσύνη αδαμαντίνη αδαμαντοπωλείο αδαμαντοπώλης
αδαμαντουργός αδαμαντωρυχείο αδαμαντωρυχείον αδαμαντωρύχος αδαπανησία
αδεκαρία αδελφάρα αδελφάτο αδελφάτον αδελφή αδελφικότης αδελφικότητα
αδελφοποίηση αδελφοποίησις αδελφοποιία αδελφοσύνη αδελφούλα αδελφούλης αδελφός
αδελφότητα αδενίνη αδενίτιδα αδενεκτομή αδενοκαρκίνωμα αδενολογία αδενοπάθεια
αδενοϊός αδενοϋπόφυση αδεξιοσύνη αδεξιότης αδεξιότητα αδερφάρα αδερφή
αδερφοδιώχτης αδερφομεράδι αδερφομοιράδι αδερφοποιτός αδερφοσκοτωμός
αδερφούλης αδερφός αδημονία αδηφαγία αδιάβροχο αδιάφθορος αδιέξοδο αδιαίρετο
αδιαθεσία αδιακρισία αδιαλλαξία αδιαντροπιά αδιαντροπότητα αδιαφάνεια
αδιαύγεια αδικήτρα αδικήτρια αδικία αδικαίωτο αδικητής αδικοπραγία αδικοπραξία
αδολέσχημα αδολέσχης αδολεσχία αδουλαίος αδράνεια αδράχτι αδρανοποίηση
αδρασκελιά αδραχτιά αδρεναλίνη αδρομέρεια αδρομισθία αδρόνιο αδρότης αδρότητα
αδυναμία αδυνατότητα αδωνιστής αεθνισμός αειπάρθενος αειφαγία αειφορία
αεράθλημα αεράκατος αεράκι αεράμυνα αερέγχυμα αερέλκυθρο αεραγηματάρχης
αεραθλητής αεραθλητισμός αερανάρτηση αεραντλία αεραποθήκη αεραπόβαση
αεριαγωγός αερικό αεριοκίνηση αεριοποίηση αεριοποιητής αεριοσκόπιο
αεριοστρόβιλος αεριοταμιευτήρας αεριοφόρο αερισμός αεριστήρας αεριστής
αεριωθούμενο αεριωθούμενον αεριόμετρο αεριόφως αεροαπασχολούμενος αεροβάτης
αεροβασία αεροβόλο αεροβόλον αερογάμης αερογάμι αερογέφυρα αερογκάμι
αεροδίκης αεροδίνη αεροδεξαμενοσκάφος αεροδιάδρομος αεροδιακομιδή αεροδικείο
αεροδρόμιο αεροδρόμιον αεροδυναμική αεροελεγκτής αεροεπιβάτης αεροζόλ
αεροθεραπεία αεροκήτος αεροκαθαριστήρας αεροκουρτίνα αερολέσχη αερολεωφορείο
αερολιμήν αερολιμενάρχης αερολιμενικός αερολογία αεροματσάκονο αερομαχία
αερομεταφορέας αερομετεωρολογία αερομετεωρολόγος αερομοντέλο αερομοντελισμός
αερομπαλόνι αεροναυαγοσωστικό αεροναυμαχία αεροναυπηγία αεροναυπηγική
αεροναυτία αεροναυτίλος αεροναυτική αεροναυτιλία αεροναύτης αεροπειρατής
αεροπειρατίνα αεροπειρατεία αεροπλάνο αεροπλαγκτόν αεροπλανάκι αεροπλανοφόρο
αεροπλοΐα αεροπλοηγός αεροπλοϊμότητα αεροπονία αεροπονική αεροπορία αεροπορίνα
αεροπόνος αεροπόρος αεροσήραγγα αεροσκάφος αεροσκόπιο αεροσοφία αεροσούστα
αεροσταθμός αεροστατική αεροστρόβιλος αεροσυγκοινωνία αεροσυμπιεστής
αεροτεχνική αεροτροχοδρόμηση αεροτροχόδρομος αεροφάρος αεροφαγία αεροφοβία
αεροφωτογραφία αεροχείμαρρος αεροψεκασμός αεροψύκτης αεροϊατρική αεροϊσημερία
αερόθερμο αερόθερμον αερόλιθος αερόλουτρο αερόλουτρον αερόλυμα αερόμπικ
αερόπλοιο αερόσακος αερόσουστα αερόστατο αερόστατον αερόστρωμα αερόστρωμνο
αερόφρενο αερόφωνο αερόχημα αερόψυξη αετίνα αετιδεύς αετονύχης αετονύχισσα
αετοφωλιά αετόπουλο αετός αζάν προβοκατέρ αζέρος αζήτητα αζίνα αζαλέα αζεριανά
αζερμπαϊτζανός αζιμούθιο αζουλέχο αζουρίτης αζούρ αζυμοφαγία αζωοσπερμία αηδία
αηδονολαλιά αηδονοφωλιά αηδόνα αηδόνι αηδόνισμα αηδών αηστρατίτης αθάλη
αθάνατοι αθάνατος αθάσι αθέρα αθέρας αθέτηση αθέτησις αθήρ αθήρωμα αθίγγανος
αθασιά αθεΐα αθεΐστρια αθεοδημοκράτης αθεοδημοκράτισσα αθεολογία αθεολόγος
αθεϊσμός αθεϊστής αθημωνιά αθηνά η νυκτία αθηναία αθηναίος αθηναιοδίφης
αθηροσκλήρωση αθηρωμάτωση αθιβολή αθιβόλι αθιγγανίς αθκιασερός αθλήτρια
αθλητής αθλητίατρος αθλητιατρική αθλητικά αθλητικογράφος αθλητισμός αθλιότητα
αθλοθέτηση αθλοθεσία αθλοπαιδιά αθρακιά αθρεψία αθρησκία αθρησκευτικότητα
αθυρμάτιο αθυρματάκι αθυρματοποιία αθυρματοποιός αθυρογλωσσία αθυροστομία
αθωνίτιδα αθωνίτις αθωότητα αθόγαλα αθόγαλο αθόμελη αθότυρο αθώωση αθώωσις
αιγαγροπίλημα αιγαιοπελαγίτης αιγαιοπελαγίτισσα αιγαλιώτης αιγιαλίτις αιγιαλός
αιγιωλιός ο πένθιμος αιγιώτης αιγκρέτα αιγοβοσκός αιγοκάμηλος αιγοπρόβατα
αιγυπτιακά αραβικά αιγυπτιολογία αιγυπτιολόγος αιγυπτιώτης αιγυπτιώτισσα
αιγόδερμα αιγόκερος αιγύπτια αιγύπτιος αιδεσιμολογιώτατος αιδεσιμότατος
αιδοίο αιδοίον αιδοιολείκτης αιδοιολειξία αιδοιολειχία αιδώς αιθάλη αιθάνιο
αιθέρας αιθήρ αιθίνιο αιθίοπας αιθαλομίχλη αιθαλοπαγίδα αιθανάλη αιθανοδιόλη
αιθανόλη αιθεράρχης αιθεροβάμονας αιθεροβάμων αιθεροβάτης αιθερολογία
αιθουσάρχης αιθρία αιθρίασμα αιθυλένιο αιθυλένιον αιθυλεστέρας αιθυλοβενζόλιο
αιθύλιον αιλουραετός αιλουροειδές αιλουροειδή αιμάτωμα αιμάτωση αιμαγγείωμα
αιμασιά αιματάλευρο αιματέμεση αιματέμεσις αιματίνη αιματίτης αιματοκρίτης
αιματολογία αιματολόγος αιματοποσία αιματοπότης αιματοσκοπία αιματοσκόπιο
αιματοχυσία αιματόμετρο αιματόρροια αιμοβορία αιμογλοβίνη αιμοδιάγραμμα
αιμοδιήθηση αιμοδιαδιήθηση αιμοδιψία αιμοδοσία αιμοδυναμική αιμοδότης
αιμοεπαγρύπνηση αιμοθώρακας αιμοκάθαρση αιμοκάθαρσις αιμοκαλλιέργεια αιμοληψία
αιμομίκτης αιμομίκτρια αιμομίχτης αιμομίχτρια αιμομειξία αιμομετάγγιση
αιμοπετάλιο αιμοπνευμοθώρακας αιμοποίηση αιμοποσία αιμοπότης αιμορραγία
αιμορροΐς αιμορροφιλία αιμορροϊδεκτομή αιμορροϊδοπάθεια αιμοσιδήρωση
αιμοστασία αιμοστατικά αιμοσφαίριο αιμοσφαίριον αιμοσφαιρίνη αιμοσφαιρινουρία
αιμωδία αιμωδίαση αιμόλυση αιμόπτυση αιμόπτυσις αιμόρροια αιμόσταση αιμόστασις
αινιγματικότης αινιγματικότητα αινιγματολογία αιξ αιπόλος αιρεσιάρχης
αιρετότητα αιρκοντίσιον αισθαντικότης αισθαντικότητα αισθηματίας
αισθηματικότητα αισθηματισμός αισθηματολογία αισθησιαρχία αισθησιασμός
αισθησιολογία αισθητήρας αισθητήριο αισθητήριον αισθητής αισθητική αισθητικός
αισθητικότητα αισθητισμός αισθητοποίηση αισθητοποίησις αισθητότης αισθητότητα
αισχροέπεια αισχρογράφημα αισχρογράφος αισχροκέρδεια αισχρολογία αισχρολόγημα
αισχρότης αισχρότητα αισχύνη αιτία αιτίαση αιτίασις αιτιαρχία αιτιατική
αιτιοκρατία αιτιολογία αιτιολόγηση αιτιολόγησις αιτιότης αιτιότητα αιτούσα
αιφνιδιασμός αιχμάλωτος αιχμή αιχμαλωσία αιχμαλώτιση αιχμαλώτισις αιχμηρότης
αιωνιότης αιωνιότητα αιωροπτερίστρια αιωροπτερισμός αιωροπτεριστής αιωρόπτερο
αιώνας αιώνιο αιώρα αιώρημα αιώρηση αιώρησις ακάτιος ακίδα ακίνητο ακαγιού
ακαδημαϊκός ακαδημαϊκότης ακαδημαϊκότητα ακαζιού ακαζού ακαθαρσία ακαθοριστία
ακακία ακακιόμελο ακαλαισθησία ακαμάτης ακαμάτισσα ακαμάτρα ακαματοσύνη
ακανές ακανθόχοιρος ακανθώνας ακαρίαση ακαρδία ακαρεοφοβία ακαρπία ακαρώνι
ακαταδεξιά ακαταλληλότης ακαταλληλότητα ακαταλόγιστο ακατανοησία ακαταρτισία
ακεραιότητα ακετυλένιο ακετυλοσαλικυλικός ακετυλχολίνη ακετυλχολινεστεράση
ακεφιά ακηδία ακιδοπέταλο ακινάκης ακινησία ακινητοποίηση ακινητοποίησις
ακκισμός ακληρία ακμή ακοή ακοινωνησία ακοκκιοκυτταραιμία ακολασία ακολουθία
ακολούθημα ακολούθηση ακομοδέσιο ακομπανιάρισμα ακομπανιαμέντο ακομπανιατέρ
ακονιστήρι ακονιστής ακοντίστρια ακοντισμός ακοντιστής ακονόπετρα ακοολογία
ακοομέτρηση ακοομετρία ακορντεονίστας ακορντεονίστρια ακορντεόν ακοσμία
ακουάριο ακουαμαρίνα ακουαρέλα ακουαρελίστας ακουαφόρτε ακουμπιστήρι
ακουομετρία ακουστική ακουστικό ακουστικότης ακουστικότητα ακουόγραμμα
ακοόμετρο ακοόμετρον ακράκι ακράτεια ακρίβεια ακρίδα ακρίς ακρίτας ακρίτης
ακρεοφαγία ακριβοθυγατέρα ακριβολογία ακριδοφαγία ακρισία ακριτοέπεια
ακροάτρια ακροαματικότης ακροαματικότητα ακροαστικά ακροατήριο ακροατής
ακροβάτις ακροβάτισσα ακροβασία ακροβατισμός ακροβολισμός ακροβολιστής
ακροβυστία ακρογιάλι ακρογιαλιά ακρογωνιαίος λίθος ακροδάχτυλο ακροδέκτης
ακροδεξιός ακροθάλασσα ακροθαλάσσι ακροθαλασσιά ακροκέραμο ακροκέραμος
ακροκιβώτιο ακρολίμανο ακρολαΐνη ακρολεΐνη ακρολιμνιά ακρομεγαλία ακροπάθεια
ακροποσθιοκόφτης ακροποταμιά ακροπτερύγιο ακροπόσθιο ακροπύργιο ακροπύργιον
ακροστιχίδα ακροστιχίς ακροστόλι ακροσωλήνιο ακροφύσιο ακροχορδών ακρούλα
ακρυλονιτρίλιο ακρωδυνία ακρωνύμιο ακρωτήρι ακρωτήριο ακρωτήριον ακρωτηρίαση
ακρωτηριασμός ακρόαμα ακρόαση ακρόβουνο ακρόλιθο ακρόλιθος ακρόλιμνο ακρόπλωρο
ακρόπρωρο ακρόπρωρον ακρόσωμα ακρότατο ακρότης ακρότητα ακρόχορδος ακρώμιο
ακρώνυμο ακρώρεια ακτή ακτίνα ακτίνα χ ακτίνα χ ακτίνα-χ ακτίνα-χ ακτίνη ακτίς
ακταρμάς ακτημοσύνη ακτιβίστρια ακτιβισμός ακτιβιστής ακτινίδες ακτινίδιο
ακτινιδίνη ακτινοβολία ακτινογράφημα ακτινογράφηση ακτινογράφησις ακτινογραφία
ακτινοδερματίτιδα ακτινοδιαγνωστική ακτινοθεραπεία ακτινοθεραπευτής
ακτινολογία ακτινολόγος ακτινομανομετρία ακτινομετρία ακτινομυκίνη
ακτινομυκωσία ακτινομύκητας ακτινομύκωση ακτινοπνευμονίτιδα ακτινοπροστασία
ακτινοσκοπία ακτινοσκόπηση ακτινοσκόπησις ακτινοσκόπιο ακτινοσκόπος
ακτινοχημεία ακτινόμετρο ακτογραμμή ακτομυοσίνη ακτοπλοΐα ακτοπλόος
ακτοφρουρός ακτοφυλακή ακτοφυλακίδα ακτοφύλακας ακτωνύμιο ακτόδρομος
ακυριολεξία ακυρολεξία ακυρωσία ακυρότης ακυρότητα ακωκή ακόλουθος ακόνη ακόνι
ακόντιο ακόντιον ακόντιση ακόντισις ακόρντο ακύρωση ακύρωσις αλάβαστρο
αλάθητο αλάνα αλάνης αλάνι αλάνισσα αλάργεμα αλάρμ αλάτι αλάτισμα αλάφι
αλέ-ρετούρ αλέα αλέγκρο αλέκτορας αλέκτωρ αλέτρι αλήθεια αλήτης αλήτις
αλίευμα αλίευση αλίνδιση αλίπαστα αλαζονεία αλαζονικότητα αλαζόνας
αλαλία αλαλαγή αλαλαγμός αλαλητό αλαλητός αλαλιά αλαλομάρα αλαλούμ
αλαμπουρνέζος αλανάκι αλανίνη αλαναρία αλανιάρα αλανιάρης αλανιάρισσα
αλατερή αλατερό αλατζάς αλατιέρα αλατοδιανομέας αλατοδοχείο αλατοθήκη
αλατοπίπερο αλατοποιία αλατοσυλλογή αλατοσωρός αλατωρυχείο αλατωρυχείον
αλατότητα αλατότοπος αλαφράδα αλαφρομυαλιά αλαφροχειμωνιά αλαφρόπετρα αλβανάκι
αλβανικά αλβανός αλγαισθητικό αλγερινή αλγερινός αλγηδόνα αλγηδών αλγκονκίν
αλγοϋποδοχέας αλγόριθμος αλδεΰδη αλδιμίνη αλεβιτισμός αλειμματοκέρι αλεκτικός
αλεξήλιον αλεξία αλεξίπτωτο αλεξίπτωτον αλεξίπυρον αλεξίφωτον αλεξανδρινισμός
αλεξιβάσκανο αλεξιβρόχιο αλεξικέραυνο αλεξικέραυνον αλεξιπτωτίστρια
αλεξιπτωτιστής αλεξισπέρμιο αλεξιφιλία αλεποπορδή αλεποτόμαρο αλεπουδάκι
αλερετούρ αλεσιά αλεστικά αλετροπόδα αλετροπόδι αλετροπόδιον αλετρόποδο
αλευράπιδο αλευράς αλευρέα αλευρέμπορας αλευρέμπορος αλευρίλα αλευρίτης
αλευραγορά αλευραποθήκη αλευρεμπόριο αλευριά αλευρικό αλευριτέλαιο
αλευροβιομηχανία αλευροβιοτέχνης αλευροβιοτεχνία αλευρογαλιά αλευρογύρισμα
αλευροζούμι αλευροζυγός αλευροκοσκίνισμα αλευροκόσκινο αλευροκόφινο
αλευρομάχη αλευρομάχος αλευρομαντεία αλευρομαχητής αλευρομείκτης αλευρομηχανή
αλευρονοθεία αλευροπάζαρο αλευροπαραγωγή αλευροπασάλειμμα αλευροποίηση
αλευροποιία αλευροποιείο αλευροποιός αλευροπολτός αλευροπρατήριο αλευροπωλείο
αλευροπόστα αλευροπώλης αλευροσακί αλευροσιλός αλευροσκάφη αλευροσκόπιο
αλευροσταύρωμα αλευροχαρμάνι αλευροχαρμανιέρα αλευρού αλευρόγαλη αλευρόγαλο
αλευρόζουμο αλευρόκολλα αλευρόκρεμα αλευρόμετρο αλευρόμυλος αλευρόπιτα
αλευρόσητα αλευρόφυτο αλεύρι αλεύρωμα αληγείς αληθινότητα αληθοφάνεια
αλησμονιά αλητάκι αλητάκος αλητάμπουρας αληταράς αληταρία αλητεία αλητοπαρέα
αλητοτουρίστρια αλητόπαιδο αλητόπαις αλθαία αλιάδα αλιάετος αλιαετός
αλιγάτορας αλιεία αλιεύς αλιζάρι αλιζαρίνη αλιπηγή αλισάχνη αλισίβα αλισβερίσι
αλιφασκιά αλιψίττακος αλιψιττακός αλκάλιο αλκάλωση αλκή αλκαλικότητα
αλκαλοειδές αλκοολίκι αλκοολική αλκοολικιά αλκοολικός αλκοολικότητα
αλκοολομέτρηση αλκοτέστ αλκοόλ αλκοόλη αλκυλαμίνες αλκυλεστέρας αλκυονίδα
αλκυόνα αλκυόνη αλκυών αλκύλιο αλλάγιο αλλάς αλλήλιο αλλίο αλλαγή αλλαισθησία
αλλαντίαση αλλαντίασις αλλαντικά αλλαντικό αλλαντοποιία αλλαντοποιείο
αλλαντοποιός αλλαντοπωλείο αλλαντοπώλης αλλαξιά αλλαξιέρα αλλαξοκαιριά
αλλαξοφαγία αλλαξοφαγίζω αλλεπαλληλία αλλεργία αλλεργικός αλλεργιογόνο
αλληγορία αλληγόρημα αλληθώρισμα αλληλέγγυο αλληλασφάλεια αλληλασφάλιση
αλληλενέργεια αλληλεξάρτηση αλληλεξάρτησις αλληλεπίδραση αλληλεπίδρασις
αλληλοβοήθεια αλληλογράφος αλληλογραφία αλληλοδιαδοχή αλληλοδιδασκαλία
αλληλοεισχώρηση αλληλοενημέρωση αλληλοεξόντωση αλληλοεπίδραση αλληλοεπικάλυψη
αλληλοκατηγορία αλληλοκατηγορίες αλληλομαχαίρωμα αλληλοπάθεια αλληλοπεριχώρηση
αλληλοσκοτωμός αλληλοσπαραγμός αλληλοσυσχέτιση αλληλοσύνδεση αλληλουχία
αλληλοϋποστήριξη αλλιγάτορας αλλοίωση αλλοίωσις αλλογαμία αλλοδαπή αλλοδαπός
αλλοκεντρισμός αλλοκοτιά αλλομεταγωγή αλλομετρία αλλοπαθητική αλλοπροσαρμογή
αλλοτρίωσις αλλοτριοφαγία αλλοτροπία αλλοτροπισμός αλλοφροσύνη αλλοχειρία
αλλότροπο αλλότροπος αλλόφρονας αλλόφωνο αλμαγωγός αλμανάκ αλμανάχ αλμπάνης
αλμπίνα αλμπίνος αλμπαρόριζα αλμπινισμός αλμπουράκι αλμυρά αλμυρίκι αλμυρό
αλμόλοιπο αλμύρα αλογάκι αλογάς αλογίνα αλογατάκι αλογοδότητος αλογοκλέφτης
αλογομούρα αλογομούρης αλογοουρά αλογοπάζαρο αλογοσούρτης αλογοσύρτης
αλογόμυγα αλογόνο αλοιφή αλοιφαδόρος αλοννησιώτης αλοπήγιο αλοπόχηνα αλοσάχνη
αλουμίνα αλουμίνιο αλουμινάς αλουμινοταινία αλουμινόχαρτο αλουποτόμαρο αλουπού
αλουργίς αλουσιά αλούμινα αλπάκα αλπακά αλπινίστρια αλπινισμός αλπινιστής
αλσύλλιο αλτάνα αλτήρας αλτερνατίβα αλτικόρνο αλτρουίστρια αλτρουισμός
αλυγαριά αλυγισία αλυκή αλυσέλικτρο αλυσίδα αλυσιτέλεια αλυσμός αλυσοπρίονο
αλυτάρχης αλυτρωτισμός αλυτρωτιστής αλφάβητο αλφάβητος αλφάδι αλφάδιασμα αλφάς
αλφαβήτιση αλφαβητάρι αλφαβητάριο αλφαβητάριον αλφαβητισμός αλφαδάκι αλφαδιά
αλχημίστρια αλχημεία αλχημιστής αλωνίστρια αλωνιάρης αλωνισμός αλωνιστής
αλωπεκή αλωπεκία αλωπεκίαση αλωπεκίασις αλόγα αλόη αλύταρχος αλύχτημα
αλώνι αλώνισμα αμάδα αμάθεια αμάκα αμάλγαμα αμάξι αμάξωμα αμάρα αμάραντο
αμάρτημα αμάχη αμέθυστος αμέλεια αμέλημα αμένσιοτο αμέταλλο αμίαντο αμίαντος
αμαζονομαχία αμαζόνα αμαζών αμαθιά αμακαδόρος αμακατζής αμακατζού
αμαλγάμωση αμαλγάμωσις αμαλγαμάτωση αμαλγαμάτωσις αμανάτι αμανές αμανίτης
αμαξάδικο αμαξάκι αμαξάς αμαξίδιο αμαξηλάτης αμαξοδηγός αμαξοστάσιο
αμαξόδρομος αμαρτία αμαρτωλός αμαρυλλίδα αμαρυλλίς αμασκάλη αμαστία αμασχάλη
αμαυρότητα αμαύρωση αμαύρωσις αμβλυωπία αμβλύνοια αμβλύτης αμβλύτητα αμβλύωπας
αμειψισπορά αμελέτητα αμερίκιο αμερικάνα αμερικάνος αμερικανάκι αμερικανίδα
αμερικανοκρατία αμερικανός αμερικανόφιλος αμεριμνησία αμεροληψία αμεσότης
αμετανοησία αμεταφυσική αμετροέπεια αμετροφάγος αμετροφαγία αμετρωπία
αμητός αμηχανία αμιαντοτσιμέντο αμιαντοτσιμεντοσωλήνας αμιαντωρυχείο
αμινάλη αμινογλυκοσίδες αμινομάδα αμινοξέα αμινοξύ αμλετισμός αμμάτι
αμμοβολή αμμοβολείο αμμοβολιστής αμμοδοχείο αμμοδόχη αμμοδόχος αμμοθεραπεία
αμμολεκάνη αμμοληψία αμμορυχείο αμμουδέρα αμμουδεριστής αμμουδιά αμμοχάλικο
αμμούδα αμμωνία αμμόκρινο αμμόλιθος αμμόλουτρο αμμόλουτρον αμμόλοφος αμμόμετρο
αμνάδα αμνήμονας αμνήστευση αμνήστευσις αμνημοσύνη αμνησία αμνησικακία
αμνοερίφιο αμνοσκοπία αμνοφαγία αμνός αμοιβάδα αμοιβάδωση αμοιβάδωσις αμοιβή
αμοιβαιότητα αμοιβολόγιο αμοραλίστρια αμοραλισμός αμοραλιστής αμοργιανή
αμορτί αμορτισέρ αμορτισεράς αμορφία αμορφωσιά αμορόζα αμουντάριστο αμουρούζα
αμπάγια αμπάρα αμπάρι αμπάριζα αμπάρωμα αμπάς αμπέλι αμπέρ αμπέχονο
αμπαζούρ αμπαλάζ αμπαλάρισμα αμπανόζι αμπαρόριζα αμπατζής αμπελάκι
αμπελοκαλλιεργητής αμπελοκομία αμπελοκουρμούλα αμπελοκόμος αμπελοοινική
αμπελοτόπι αμπελουδάκι αμπελουργία αμπελουργική αμπελουργός αμπελοφάσουλο
αμπελοχώραφο αμπελόκηπος αμπελότοπος αμπελόφυλλο αμπελώνας αμπερόμετρο
αμπιγιέ αμπιγιέζ αμπιγιέρ αμπλά αμπλαούμπλας αμπολή αμπούλα αμπρί αμπραγιάζ
αμπόδεμα αμυαλιά αμυγδαλέλαιο αμυγδαλέλαιον αμυγδαλή αμυγδαλή αμυγδαλίτιδα
αμυγδαλεώνας αμυγδαλιά αμυγδαλιώνας αμυγδαλομαρουλοσαλάτα αμυγδαλοσκελίδα
αμυγδαλωτό αμυγδαλόλαδο αμυγδαλόψιχα αμυδρότητα αμυλάλευρο αμυλάλευρον αμυλάση
αμυλοπηκτίνη αμυλοπλάστης αμυλοσάκχαρο αμυλοσάκχαρον αμυλόζη αμυλόκοκκος
αμυντικός αμυντικότης αμυντικότητα αμυχή αμφίβια αμφίβιο αμφίβραχυς αμφίεση
αμφίλυση αμφίσκορο αμφίψωμο αμφεταμίνη αμφιβικόπτερο αμφιβληστροειδής
αμφιβληστροειδοπάθεια αμφιβολία αμφιγαμοκωλάριος αμφιδεξιότητα αμφιδρόμηση
αμφιθέατρον αμφιθυμία αμφικτίονες αμφικτιονία αμφικόπτερο αμφιλογία αμφιλύκη
αμφισβήτησις αμφισβητίας αμφισημία αμφισημότητα αμφισκάφος αμφισσαίος
αμφιταλάντευσις αμφιτρύων αμφιτρύωνας αμφιφυλοφιλία αμφιφυλόφιλος αμφορέας
αμόκ αμόνι αμόρε αμόρσα αμύγδαλο αμύγδαλον ανάβαθα ανάβαση ανάβασις ανάβλεμμα
ανάβλεψις ανάβλυση ανάβλυσις ανάβρα ανάβρασμα ανάβρυση ανάβρυσμα ανάγκη
ανάγνωση ανάγνωσις ανάγνωσμα ανάγραμμα ανάδειξη ανάδειξις ανάδευση ανάδομα
ανάδοχος ανάδραση ανάδυση ανάδυσις ανάθεμα ανάθεση ανάθεσις ανάθημα ανάθρεμμα
ανάκαρα ανάκαρο ανάκλαση ανάκληση ανάκλιντρο ανάκλιση ανάκριση ανάκρουση
ανάκτηση ανάκτορο ανάκυψη ανάλεκτα ανάλημμα ανάληψη ανάλυμα ανάλυση ανάλωση
ανάμειξη ανάμιξη ανάμνηση ανάμπαιγμα ανάνηψη ανάντη ανάξεση ανάπαιστος ανάπαμα
ανάπαυση ανάπαψη ανάπεμψη ανάπηρος ανάπλα ανάπλαση ανάπλασις ανάπλευση
ανάποδη ανάπτυγμα ανάπτυξη ανάπτυξις ανάραχο ανάρρηση ανάρρησις ανάρρους
ανάρρωσις ανάρτηση ανάρτησις ανάρχας ανάσα ανάσαση ανάσπαση ανάσταση ανάστασις
ανάστροφη ανάσυρση ανάσχεση ανάσχεσις ανάταξη ανάταξις ανάταση ανάτασις
ανάφαση ανάφλεξη ανάχρειο ανάχωμα ανέβασμα ανέγερση ανέγερσις ανέκδοτο ανέλιξη
ανέλκυση ανέλκυσις ανέλο ανέμη ανέμισμα ανένταχτος ανέσα ανέσπερο ανέχεια
ανήρ ανήφορος ανία ανίδρυση ανίδρυσις ανίχνευση ανίψι αναίδεια αναίρεση
αναβάθμισις αναβάθρα αναβάπτιση αναβάπτισις αναβάπτισμα αναβάτης αναβάτρια
αναβίβασις αναβίωμα αναβίωση αναβίωσις αναβαθμίδα αναβαθμίδωση αναβαθμίς
αναβαθμολόγησις αναβαθμός αναβαλλόμενος αναβαπτισμός αναβαπτιστής αναβατήρας
αναβατόριο αναβιβασμός αναβλάστηση αναβλητικότης αναβλητικότητα αναβολέας
αναβολεύς αναβολικά αναβολισμός αναβοσβήσιμο αναβρασμός αναβροχιά αναβρυτήριο
αναγάλλια αναγέλασμα αναγέννηση αναγέννησις αναγγελία αναγκάμι αναγκαίο
αναγκαιότητα αναγκασμός αναγνωρισιμότητα αναγνωσιμότης αναγνωσιμότητα
αναγνωστήριο αναγνωστικό αναγνωστικότητα αναγνώριση αναγνώρισις αναγνώστης
αναγούλα αναγούλιασμα αναγραμματισμός αναγραφέας αναγραφή αναγωγή αναγόμωση
αναγόρευσις αναγύρισμα αναδάσωση αναδάσωσις αναδίπλωση αναδίπλωσις αναδίφηση
αναδαμαλισμός αναδασμός αναδεντράδα αναδεξιμιά αναδεξιμιός αναδευτήρας
αναδημιουργία αναδημοσίευση αναδημοσίευσις αναδιάρθρωση αναδιάρθρωσις
αναδιαμελισμός αναδιανομή αναδιαπραγμάτευση αναδιαρρύθμιση αναδιατύπωση
αναδιοργανωτής αναδιπλασιασμός αναδιφητής αναδουλειά αναδοχή αναδρομή
αναδρομικότητα αναδόμηση αναζήτηση αναζήτησις αναζωογόνηση αναζωογόνησις
αναζωπύρωσις αναθάρρηση αναθάρρησις αναθέρμανση αναθέρμανσις αναθέσμιση
αναθεματισμός αναθεωρητής αναθεωρητισμός αναθεώρηση αναθεώρησις αναθρεφτή
αναθυμίαση αναθυμίασις αναθύμημα αναθύμηση αναιμία αναιρέτης αναισθησία
αναισθητικό αναισθητοποίηση αναισθητοποίησις αναισχυντία ανακάλυψη ανακάτεμα
ανακάτωση ανακήρυξη ανακίνηση ανακαίνιση ανακαινίστρια ανακαινιστής ανακαράς
ανακατάληψη ανακατάταξη ανακατανομή ανακατασκευή ανακατεύθυνση ανακατοσούρας
ανακατωσούρα ανακατωσούρας ανακεράμωση ανακεφαλαίωση ανακεφαλαιοποίηση
ανακλάδωμα ανακλαστήρας ανακοίνωση ανακοινωθέν ανακολουθία ανακομιδή ανακοπή
ανακούφιση ανακρίβεια ανακρίτρια ανακριτής ανακριτική ανακρυστάλλωση
ανακυψιμότητα ανακωχή ανακόντα ανακύκληση ανακύκλωση αναλήθεια αναλαμπή
αναλγησία αναλγητικά αναλγητικό αναληπτικά αναλλαξιά αναλογία αναλογισμός
αναλυτής αναλυτικότητα αναλφαβητισμός αναλόγιο αναλύτρια αναλώσιμα αναμάρτητος
αναμέτρηση αναμεικτήρας αναμελιά αναμετάδοση αναμεταδότης αναμηρυκασμός
αναμονή αναμορφωτήριο αναμορφωτής αναμορφώτρια αναμπουμπούλα αναμόρφωση
ανανάς ανανέωση ανανδρία ανανοηματοδότηση αναντιστοιχία αναντρία αναξιοκρατία
αναξιοπιστία αναξιοπρέπεια αναξιοσύνη αναξιότητα αναξυρίς αναοριοθέτηση
αναπέταση αναπήδημα αναπήδηση αναπήδησις αναπήνιση αναπαημός αναπαλαίωση
αναπαμός αναπαράσταση αναπαραγωγή αναπαραδιά αναπαραδιάρης αναπαραδιάρισσα
αναπαυτήριον αναπεριέλιξη αναπεταρούδια αναπηρία αναπλήρωμα αναπλήρωση
αναπλειστηριασμός αναπληροφόρηση αναπληρωτής αναπληρώτρια αναπλώριση
αναπνιά αναπνοή αναποδιά αναποδογύρισμα αναποκάλυπτος αναπολιτισμός αναπομπή
αναποφασιστικότητα αναπροεξόφληση αναπροσαρμογή αναπρόσληψη αναπτέρωση
αναπτήρ αναπτήρας αναπτηράκι αναπόδιση αναπόληση αναπόλησις αναπότρεπτο
αναπύρωση αναρέσα αναρή αναρθρία αναριθμητισμός αναρμοδιότης αναρμοδιότητα
αναρρίπιση αναρρίπισις αναρρίχηση αναρρίχησις αναρριχήτρια αναρριχητής
αναρρούσα αναρρωτήριο αναρρωτήριον αναρρόφηση αναρρόφησις αναρρύθμιση αναρτήρ
αναρχία αναρχιδία αναρχικότητα αναρχισμός αναρχοκαπιταλισμός
αναρχοκομμούνι αναρχοκουμούνι αναρχοπάνκ αναρχοπίτουρας αναρχοσυνδικαλισμός
αναρχούμενο ανασάλεμα ανασήκωμα ανασαιμιά ανασασμός ανασκάλεμα ανασκέλωμα
ανασκίρτηση ανασκίρτησις ανασκαφέας ανασκαφή ανασκελάς ανασκευή ανασκολοπισμός
ανασκούμπωμα ανασκόπηση ανασκόπησις αναστάτωμα αναστάτωση αναστάτωσις
αναστήλωση αναστήλωσις αναστενάρης αναστενάρια αναστενάρισσα αναστεναγμός
αναστολή αναστοχασμός αναστοχαστικότητα αναστροφή αναστόμωση αναστόφυτο
αναστύλωσις ανασυγκρότηση ανασυγκρότησις ανασυνδυασμός ανασυσκευασία
ανασχεδιασμός ανασχηματισμός ανασόνι ανασύνδεση ανασύνδεσις ανασύνθεση
ανασύνταξη ανασύνταξις ανασύσταση ανασύστασις ανατάραγμα ανατάραξη ανατίμηση
ανατίναξη ανατίναξις αναταξινόμηση αναταραγμός αναταραχή ανατιμητής
ανατοκισμός ανατολή ανατολίστρια ανατολίτης ανατολίτις ανατολίτισσα
ανατολικασιάτης ανατολικοασιάτης ανατολιστής ανατομή ανατομία ανατομείο
ανατοποθέτηση ανατρίχιασμα ανατριχίλα ανατροπέας ανατροπή ανατροφέας ανατροφή
ανατόμος ανατύπωση αναφαγιά αναφιλητό αναφιώτης αναφιώτισσα αναφλεκτήρας
αναφορέας αναφροδισία αναφυλαξία αναφύτευση αναφώνηση αναχαίτιση αναχαιτισμός
αναχρονισμός αναχωμάτωση αναχωρητήριο αναχωρητής αναχωρητισμός αναχώνευση
αναψηλάφηση αναψηλάφησις αναψυκτήριο αναψυκτήριον αναψυκτικό αναψυκτικόν
ανδορρανός ανδράδελφος ανδράδερφος ανδράποδο ανδραγάθημα ανδραγαθία ανδραδέλφη
ανδρεία ανδρείκελο ανδρείκελον ανδρειοσύνη ανδρειότητα ανδριάντας ανδριάς
ανδριαντοποιός ανδρισμός ανδριώτης ανδριώτισσα ανδρογένεση ανδρογυνία
ανδρογόνα ανδρογόνο ανδροειδές ανδροκοίτης ανδροκρατία ανδρολογία ανδρολόγος
ανδρωνίτης ανδρόγυνο ανδρόπαυση ανδρώνας ανεβασιά ανεβατόρι ανεβοκατέβασμα
ανεγκεφαλία ανεδαφικότης ανεδαφικότητα ανεικονικότητα ανειλικρίνεια
ανεκδοτολόγος ανεκτικότης ανεκτικότητα ανελαστικότης ανελαστικότητα
ανελκυστήρ ανελκυστήρας ανεμελιά ανεμική ανεμικό ανεμιστήρ ανεμιστήρας
ανεμιστής ανεμοβλογιά ανεμοβρόχι ανεμοβόρι ανεμογεννήτρια ανεμογκάστρι
ανεμογρίβαδο ανεμογριβάδι ανεμοδείκτης ανεμοδείχτης ανεμοδούρα ανεμοδόχη
ανεμοθραύστης ανεμοθύελλα ανεμοθώρακας ανεμοκυπρίνοι ανεμοκυπρίνος ανεμολάβαρο
ανεμολόγιον ανεμομάζεμα ανεμομάζωμα ανεμομελωδός ανεμοξουριά ανεμοπλάνο
ανεμοπύρωμα ανεμορούφουλας ανεμορρόμβιο ανεμοσκόπιο ανεμοστάτης ανεμοστρόβιλος
ανεμοσυρμή ανεμούρι ανεμούριο ανεμυαλιά ανεμόβροχο ανεμόκαλτσα ανεμόμετρο
ανεμόπτερο ανεμόπτερον ανεμόσκαλα ανεμότρατα ανεμώνα ανεμώνη ανεντιμότητα
ανεξέταση ανεξίτηλο ανεξαρτησία ανεξαρτητοποίηση ανεξαρτητοποίησις ανεξιγνωμία
ανεξικακία ανεπάρκεια ανεπιείκεια ανεπιστημοσύνη ανεπιστρέφων ανεπιτηδειότης
ανεράιδα ανεργία ανεριά ανερούσα ανευθυνοϋπεύθυνος ανευθυνότητα ανευλάβεια
ανευφήμηση ανευφημία ανεφοδιασμός ανεψιά ανεψιός ανεύρεση ανεύρεσις ανεύρυσμα
ανηθικότης ανηθικότητα ανηλικιότητα ανηλικότης ανηλικότητα ανημποριά ανημπόρια
ανηφοριά ανηφόρα ανηφόρι ανηψιά ανηψιός ανθάκι ανθέλικα ανθέλληνας ανθέμιο
ανθήρ ανθήρας ανθί ανθαγορά ανθεθνικότητα ανθεκτικότης ανθεκτικότητα
ανθελμινθικά ανθελονοσιακά ανθεμίδα ανθεστήρια ανθηρότης ανθηρότητα ανθιβόλι
ανθοβαφία ανθοβολή ανθοβολία ανθοβολιά ανθοβοσκός ανθοβόλημα ανθοβόληση
ανθογυάλι ανθοδέσμη ανθοδέτης ανθοδέτρια ανθοδετική ανθοδοχείο ανθοδόχη
ανθοκήπιο ανθοκαλλιέργεια ανθοκεφαλή ανθοκηπευτική ανθοκλάδι ανθοκομία
ανθοκομική ανθοκούλουρο ανθοκράμβη ανθοκόμος ανθολογία ανθολόγημα ανθολόγηση
ανθολόγιο ανθολόγος ανθοπαραγωγή ανθοπαραγωγός ανθοπωλείο ανθοπώλης ανθοπώλιδα
ανθοπώλισσα ανθοστήλη ανθοστολισμός ανθοστόλισμα ανθοταξία ανθοτόπι ανθοφορία
ανθράκευσις ανθράκωση ανθρακίτης ανθρακαποθήκη ανθρακεύω ανθρακιά ανθρακικό
ανθρακοποίησις ανθρακωρυχείο ανθρακωρύχος ανθρακόνημα ανθρωπoειδές ανθρωπάκι
ανθρωπάριο ανθρωπάριον ανθρωπίστρια ανθρωπιά ανθρωπισμός ανθρωπιστής
ανθρωπογνωσία ανθρωποδύναμη ανθρωποθάλασσα ανθρωποθυσία ανθρωποκεντρικότητα
ανθρωποκοινωνιολογία ανθρωποκτονία ανθρωποκυνηγητό ανθρωπολατρία
ανθρωπολεπτό ανθρωπολογία ανθρωπολόγος ανθρωπολόι ανθρωπομάζεμα ανθρωπομάζωμα
ανθρωπομετρία ανθρωπομορφισμός ανθρωποπάζαρο ανθρωποπούλι ανθρωποσφαγή
ανθρωποφάγος ανθρωποφαγία ανθρωποφοβία ανθρωποώρα ανθρωπωνυμία ανθρωπωνυμικό
ανθρωπότης ανθρωπότητα ανθυγιεινότης ανθυγιεινότητα ανθυπίατρος ανθυπίλαρχος
ανθυπαστυνόμος ανθυποβρύχιο ανθυποκτηνίατρος ανθυπολοχαγός ανθυπομειδίαμα
ανθυποπλοίαρχος ανθυποσμηναγός ανθυποτάξη ανθυποφορά ανθυποψήφια ανθυποψήφιος
ανθόγαλα ανθόγαλο ανθόκηπος ανθόκρινο ανθόμελο ανθόνερο ανθόρροια ανθός
ανθότυρο ανθύλλι ανθύλλιο ανθύλλιον ανθύπας ανθύπατος ανθώνας ανιαρότης
ανιδιοτέλεια ανιθαγενής ανικανότης ανικανότητα ανιλίνη ανιμαλισμός ανιματέρ
ανιολότο ανισοκατανομή ανισομέρεια ανισοπεδοποίηση ανισορροπία ανισοσκέλιστος
ανισοτροπία ανισότητα ανιχνευτής ανιχνεύτρια ανιψάκι ανιψίδι ανιψιά ανιψιός
ανιόντες ανκορά ανκόρ ανοησία ανοιγοκλείσιμο ανοικοδόμηση ανοικτότητα
ανοιχτοχέρα ανοιχτόχρωμα ανομία ανομβρία ανομοίωση ανομοίωσις ανομοιογένεια
ανομοιομέρεια ανομοιομορφία ανομοιότης ανομοιότητα ανοξία ανοράκ ανοργανωσιά
ανορεξιά ανορεξιογόνα ανορθογραφία ανορθωτής ανορθώτρια ανοσία ανοσιουργία
ανοσιότης ανοσιότητα ανοσμία ανοσοανεπάρκεια ανοσοαντιδραστικότητα
ανοσογνωσία ανοσοθεραπεία ανοσοκαθήλωση ανοσοκαταστολή ανοσολογία
ανοσοποίηση ανοσοποίησις ανοσοπροσδιορισμός ανοσοσφαιρίνη ανοσοτροποποίηση
ανοσοχρωματογραφία ανοσοϊστοχημεία ανοστιά ανοσφρησία ανουρία ανοφθαλμία ανοχή
αντάμειψη αντάμωμα αντάμωση αντάπτορας αντάρα αντάρτης αντάρτικο αντάρτισσα
αντέγγραφον αντέγκληση αντέγκλησις αντέκθεση αντέκθεσις αντέκταση αντέκτασις
αντένδειξη αντένδειξις αντένσταση αντένστασις αντέρεισμα αντέτι αντέφεση
αντήλιο αντήχηση αντήχησις αντίβαρο αντίβαρον αντίγονον αντίγραφο αντίγραφον
αντίδι αντίδικος αντίδοτο αντίδοτον αντίδραση αντίδρασις αντίδωρο αντίδωρον
αντίζηλος αντίζυγο αντίθεση αντίθεσις αντίθετο αντίκα αντίκενο αντίκλειθρον
αντίκλινο αντίκλινον αντίκοιλο αντίκοιλον αντίκρισμα αντίκρουσις αντίκρυσμα
αντίλαλος αντίλημμα αντίληψη αντίληψις αντίλογος αντίμετρο αντίντερο αντίνυξη
αντίπαλος αντίπαπας αντίπασχα αντίποδας αντίποινα αντίποινο αντίποινον
αντίπραξη αντίπραξις αντίρευμα αντίρρηση αντίρρησις αντίρροπο αντίσκηνο
αντίσταση αντίστασις αντίστιξη αντίστιξις αντίστοιχο αντίστυλο αντίσωμα
αντίτιμον αντίτυπο αντίτυπον αντίφα αντίφαση αντίφραση αντίφωνα αντίφωνο
αντίχαρη αντίχειρας αντίχριστος αντίχτυπος αντίψυχο ανταγωγή ανταγωνίστρια
ανταγωνιστής ανταγωνιστικότης ανταγωνιστικότητα ανταλής ανταληγείς
ανταλλαγή ανταλλακτήριο ανταλλακτικό ανταμοιβή αντανάκλαση αντανάκλασις
αντανακλαστικό ανταπάντηση ανταπάντησις ανταπαίτηση ανταπαίτησις ανταπαιτητής
ανταπεργός ανταποκρίτρια ανταποκρισιμότητα ανταποκριτής ανταπόδειξη ανταπόδοση
ανταπόκριση ανταπόκρισις ανταρσία ανταρτοπόλεμος αντασφάλεια αντασφάλιση
αντασφαλιστής ανταύγεια αντεγγύηση αντεισαγγελέας αντεκδίκηση αντεκδίκησις
αντεμπρησμός αντενέργεια αντενοκάταρτο αντενοκατάρτι αντεξέταση αντεπένδυση
αντεπίθεσις αντεπαγωγή αντεπανάσταση αντεπανάστασις αντεπαναστάτης
αντεπισταλία αντεπιχείρημα αντεράστρια αντερί αντεραστής αντεροβγάλτης
αντευρωπαϊσμός αντευρωπαϊστής αντζουγόπαστα αντζουριά αντζούγα αντζούγια
αντηλάρισμα αντηλιά αντηλιακό αντηρίδα αντηρίς αντηχείο αντηχείον
αντιήρωας αντιαγγειογένεση αντιαγνωστικός αντιαιμοπεταλιακά αντιαιμορραγικά
αντιαλλεργικό αντιαμερικανισμός αντιαναθεωρητής αντιανδρογόνα αντιανεμικό
αντιατομικισμός αντιβίωση αντιβαπτισμός αντιβαρύτητα αντιβασίλισσα
αντιβασιλεία αντιβασιλεύς αντιβασιλιάς αντιβηχικά αντιβιόγραμμα αντιβούισμα
αντιβρόχιο αντιβρόχιον αντιγαμητικό αντιγιβεριλήνη αντιγκέα αντιγκεϊκά
αντιγνωμία αντιγνωσιαρχικός αντιγραφέας αντιγραφή αντιγραφεύς αντιγόνο
αντιδάνειο αντιδήμαρχος αντιδανεισμός αντιδεξιός αντιδημαρχία αντιδημοτικότης
αντιδιαβητικά αντιδιαδήλωση αντιδιαδήλωσις αντιδιαδηλωτής αντιδιανοσαλάτα
αντιδιαστολή αντιδικία αντιδογματικότητα αντιδογματισμός αντιδραστήρας
αντιδραστήριον αντιδραστικότητα αντιδρόμηση αντιδόνημα αντιδόνηση αντιεθνικός
αντιεθνισμός αντιεισαγγελέας αντιεισαγγελεύς αντιελκωτικά αντιεμετικά
αντιεξουσιαστής αντιεπιληπτικά αντιερωτικότητα αντιερωτισμός αντιευρωπαϊσμός
αντιζηλία αντιζυγία αντιζύγι αντιζύγιασμα αντιηλεκτρόνιο αντιημικρανικά
αντιθάλαμος αντιθεϊστής αντιθρησκευτικότητα αντιθρομβωτικά αντιθρομβωτικό
αντιθωράκιση αντιιλιγγικά αντιιμπεριαλισμός αντιισταμινικά αντιισταμινικό
αντικάμαρα αντικέρ αντικέρης αντικίνητρο αντικαθρέφτισμα αντικαθρεφτισμός
αντικανονικότητα αντικαπιταλισμός αντικαπνίστρια αντικαπνιστής αντικατάσκοπος
αντικατάστασις αντικαταβολή αντικαταθλιπτικά αντικαταθλιπτικό
αντικατασκοπία αντικατασκοπεία αντικαταστάτης αντικαταστάτις αντικαταστάτρια
αντικείμενο αντικείμενον αντικειμενικότης αντικειμενικότητα αντικειμενισμός
αντικειμενοποίηση αντικεμαλιστής αντικενό αντικλείδι αντικληρικαλισμός
αντικληρισμός αντικνήμιο αντικνήμιον αντικοινοβουλευτισμός αντικοινωνικότητα
αντικομματισμός αντικομμουνισμός αντικομμουνιστής αντικομουνίστρια
αντικομουνιστής αντικομφορμίστας αντικομφορμίστρια αντικομφορμισμός
αντικουάρκ αντικουνουπικό αντικούκου αντικριστής αντικρυστής αντικυκλών
αντικυριώτης αντιλάμπισμα αντιλήπτορας αντιλήπτωρ αντιλαβή αντιλεξικό
αντιλεϊσμανιακά αντιληπτικότης αντιληπτικότητα αντιληπτότητα αντιλογάριθμος
αντιλογισμός αντιλόπη αντιμάμαλο αντιμέτρηση αντιμέτρησις αντιμήνσιο
αντιμανιακά αντιμαχία αντιμερκελιστής αντιμετάθεση αντιμετάθεσις αντιμετάταξη
αντιμεταρρύθμισις αντιμεταφυσίτης αντιμεταφυσική αντιμεταφυσικός
αντιμεταχώρησις αντιμετώπιση αντιμετώπισις αντιμικροβιακά αντιμιλιταρίστρια
αντιμιλιταριστής αντιμισθία αντιμολία αντιμονή αντιμονίτης αντιμοναρχικός
αντιμυκητιασικά αντιμυοσπασμωδικά αντιμωλία αντιμόνιο αντιμόνιον αντιναύαρχος
αντινομισμός αντινομιστής αντιντετερμινισμός αντιξιφισμός αντιξοότης
αντιοικονομία αντιολίσθηση αντιορός αντιπάθεια αντιπάπας αντιπαγκοσμιοποίηση
αντιπαλότητα αντιπαράδειγμα αντιπαράθεση αντιπαράθεσις αντιπαράσταση
αντιπαράταξη αντιπαράταξις αντιπαραβολή αντιπαρκινσονικά αντιπαροχή
αντιπατριώτης αντιπατριώτισσα αντιπελάργηση αντιπερισπασμός αντιπεριφερειάρχης
αντιπηκτικό αντιπιτυριδικό αντιπλάγια αντιπληθωρισμός αντιπλοίαρχος
αντιποίηση αντιποίησις αντιπολίτευση αντιπολίτευσις αντιπραγματισμός
αντιπροεδρία αντιπροεδρίνα αντιπροπαρασκευή αντιπροσαρμογή αντιπροσφορά
αντιπροσωπεία αντιπροσωπευτικότητα αντιπροσώπευση αντιπροσώπευσις
αντιπρόεδρος αντιπρόσκληση αντιπρόσωπος αντιπρόταση αντιπρότασις αντιπρύτανης
αντιπτέραρχος αντιπτέριση αντιπυρά αντιπυρκαγιά αντιπύραρχος αντιπύραυλος
αντιρρευματικά αντιρρησίας αντιρρόπηση αντιρρόπησις αντιρρύπανση αντισήκωμα
αντισεξουαλικότητα αντισημίτης αντισημίτρια αντισημιτισμός αντισηπτικά
αντισκίαση αντισοβιετισμός αντιστάθμιση αντιστάθμισις αντιστάθμισμα αντιστάτης
αντιστήριξη αντιστήριξις αντισταθμισμός αντιστασιακός αντιστικτική
αντιστοιχία αντιστράτηγος αντιστρεπτικότητα αντιστρεπτότητα αντιστρεψιμότητα
αντιστύλι αντισυμμετρία αντισυνταγματάρχης αντισυνταγματικότης αντισυστημισμός
αντισφαίρισις αντισφαιρίστρια αντισφαιριστής αντισχέδιο αντισχέδιον
αντισύλληψη αντισύμπαν αντιτάσσομαι αντιτάσσω αντιτείχισμα αντιτοξίνη
αντιτορπιλλικό αντιτορπιλλικόν αντιτριβή αντιτρομοκρατία αντιυπερτασικά
αντιφάρμακον αντιφέγγισμα αντιφασίστας αντιφασίστρια αντιφασισμός αντιφασιστής
αντιφατικότητα αντιφεγγιά αντιφεμινίστρια αντιφεμινισμός αντιφεμινιστής
αντιφλεγμονώδες αντιφλεγμονώδη αντιφυλετικός αντιφυματικά αντιφωνία αντιφώνηση
αντιχάος αντιχαιρέτισμα αντιχαιρετισμός αντιχαρακτήρας αντιχολινεργικά
αντιχριστιανισμός αντιψυχωσικά αντιψυχωτικά αντιψύχι αντιύλη αντλία
αντλησιοταμιευτήρας αντλιοστάσιο αντλιωρός αντονομασία αντοχή αντράδελφος
αντράκι αντράκλα αντράλα αντρέ αντρακλοσαλάτα αντραμίδα αντρεία αντρειά
αντρειότητα αντρισμός αντρογυναίκα αντρομίδα αντροσύνη αντροχωρίστρα αντρούλης
αντρών αντσούγα αντσούγια αντωνυμία αντώνυμο αντώνυμον αντώσμωση ανυδρία
ανυπαρξία ανυποκρισία ανυποληψία ανυπομονησία ανυποταγή ανυποταξία ανυπόστατο
ανυστεροβουλία ανυφάντρα ανυφάντρια ανυφαντάρης ανυφαντής ανυψωμός ανυψωτήρ
ανυψωτής ανφάς ανωδομή ανωδομία ανωκύκλωση ανωμαλία ανωμαλιάρης ανωμεριά
ανωνυμογράφος ανωνυμογραφία ανωνυμοτηλεφωνητής ανωορρηξία ανωριμότης
ανωτερότης ανωτερότητα ανωφέλεια ανωφέρεια ανόμημα ανόπτηση ανόρθωση ανόρθωσις
ανόρυξις ανύπαρκτο ανύχι ανύψωση ανύψωσις ανώγαιον ανώγειο ανώγι ανώι ανώμαλος
ανώφλι ανώφλιον αξάδα αξάδερφος αξία αξίνα αξίνι αξίωμα αξίωση αξίωσις
αξαδέρφη αξαδέρφισσα αξενία αξεσουάρ αξιά αξιάδα αξινάρ αξιοδότηση αξιοθέατα
αξιολογήτρια αξιολογία αξιολογητής αξιολόγηση αξιολόγησις αξιομισθία
αξιοπλοΐα αξιοποίηση αξιοποίησις αξιοπρέπεια αξιοσημείωτο αξιοσύνη
αξιωματικός αξιωματικότητα αξιωματούχος αξιόγραφο αξιόνιο αξιότης αξιότητα
αξολότλ αξονική αξονομετρία αξυρισιά αξόνι αξόνιο αξόπλασμα αξότητα αξύπνητος
αοιδός αορατότητα αοριστία αοριστολογία αοριστολόγος αορτή αορτήρ αορτήρας
αορτογραφία αοσμία αουρία αουτσάιντερ απάγκειο απάγκιο απάθεια απάκι απάλειψη
απάλυνση απάνθισμα απάντηση απάντησις απάντληση απάρνηση απάρνησις απάρτημα
απάχης απάχισσα απέκκριση απέκκρισις απέλαση απέλασις απέλλα απέξω απέχθεια
απήχηση απήχησις απίδι απίθωμα απίκο απίσχνανση απίσχνανσις απίσχναση απαέριο
απαίτηση απαίτησις απαγγελία απαγκίστρωση απαγορευτικό απαγχονισμός απαγωγέας
απαγόρευσις απαθανάτιση απαθανάτισις απαθανάτισμα απαθανατισμός απαθλίωση
απαιδαγωγησία απαιδευσία απαισιοδοξία απαισιότητα απαιτητικότης απαιτητικότητα
απαλλαγή απαλλοτρίωση απαλοιφή απαλοσύνη απαλότης απαλότητα απαμίνωση απανεμιά
απανθράκωσις απανθρακοποίηση απανθρωπία απανθρωπιά απανθρωπισμός απανταχούσα
απαντοχή απανωβελονιά απανωπροίκι απανωπρούκια απανωσιά απαξία απαξίωση απαράτ
απαράτσνικ απαρέμφατο απαρέμφατον απαρέσκεια απαρίθμηση απαρίθμησις απαργύρωση
απαρνήτρα απαρνησιά απαρνητής απαρτία απαρτεμάν απαρτμάν απαρτχάιντ απαρχές
απασβέστωση απασβέστωσις απασφάλιση απασχολία απασχολησιμότητα
απασχόληση απασχόλησις απατίτης απατεωνία απατεωνίσκος απατεωνιά απατεών
απατεώνισσα απαυτά απαύγασμα απαύτωμα απείθεια απείκασμα απεγγραφή
απειθαρχία απεικονιστής απεικόνιση απεικόνισις απεικόνισμα απειλή απειρία
απειριστής απειροκαλία απειροστημόριο απειροστημόριον απειροσύνολο απελάτης
απελατίκι απελατίκιον απελευθέρωση απελευθέρωσις απελευθερία απελευθερωτής
απελεύθερη απελεύθερος απελπισία απελπισιάρης απελπισμός απεμπλοκή απεμπολή
απεμπόλησις απενεργοποίηση απενημέρωση απενοχοποίηση απενταρία απεντομωτήριο
απεντόμωση απεξάρθρωση απεξάρθρωσις απεξάρτηση απεξάρτησις απερήμωση
απεραθίτισσα απεραντολογία απεραντολόγος απεραντοσύνη απεργία απεργοσπάστης
απεργοσπασία απεργός απεριέργεια απερισκεψία απεριτίφ απευαισθητοποίηση
απευθυσμένο απευθυσμένον απευχή απεψία απεύθυνση απηλιώτης απηχητικότητα
απιδιά απιθανότης απιθανότητα απινίδωση απινιδισμός απινιδωτής απιονισμός
απιστία απλάδα απλίκα απλανόσπορο απλασία απληροφορησία απληρωσιά απληστία
απλικατέρ απλοέπεια απλογράφηση απλογραφία απλοελληνικά απλολογία απλολογικός
απλοποίηση απλοποίησις απλοχεριά απλοχωριά απλοϊκότητα απλούστευση
απλυσιά απλωμός απλωσιά απλωτή απλωταριά απλό σάκχαρο απλότης απλότητα
απνευστική αποίκηση αποίκησις αποίκιση αποίκισις αποαιθανίωση αποαιθανιωτής
αποανθρωποποίηση αποαστικοποίηση αποασυλοποίηση αποβάθρα αποβάμβακας αποβίβαση
αποβιομηχάνιση αποβλάκωμα αποβλάκωση αποβλάκωσις αποβολή αποβορβόρωση
αποβουτύρωση αποβουτύρωσις αποβροχάρης αποβρόχια απογάμημα απογέμιση
απογέννι απογαλάκτιση απογαλάκτισμα απογαλακτισμός απογαμία απογείωση
απογευματάκι απογοήτευση απογοήτευσις απογραφέας απογραφή
απογραφεύς απογύμνωση απογύμνωσις αποδάσωση αποδέκτης αποδέκτρια αποδένδρωση
αποδέσμευσις αποδέχτης αποδήμηση αποδήμησις αποδίωξη αποδεικτέος αποδεικτικό
αποδεικτικότητα αποδειξιμότητα αποδεκάτιση αποδεκάτισμα αποδεκατισμός
αποδελτίωση αποδελτίωσις αποδεξαμενισμός αποδερματισμός αποδημία αποδημητικά
αποδιάρθρωση αποδιάρθρωσις αποδιαλέγια αποδιαλέγουρο αποδιαλεγούδι αποδιαλόγια
αποδιαρθρωτής αποδιαφώτισμα αποδιεθνοποίηση αποδιοργάνωση αποδιοργάνωσις
αποδοκιμασία αποδοτικότης αποδοτικότητα αποδοχές αποδοχή αποδραματοποίηση
αποδυνάμωμα αποδυνάμωση αποδυνάμωσις αποδυτήριο αποδυτήριον αποδόμηση
αποενοποίηση αποεπένδυση αποεπιβίβαση αποεστίαση αποζημίωση αποζημίωσις
αποθάρρυνση αποθάρρυνσις αποθέρμανση αποθέτης αποθέωση αποθέωσις αποθήκευση
αποθήκη αποθαλάσσωση αποθαλάσσωσις αποθαλασσιά αποθαμός αποθανούσα αποθανών
αποθεματικόν αποθεματοποίηση αποθεράπευση αποθεραπεία αποθετήριο αποθηκάκι
αποθηκούλα αποθηλασμός αποθηρίωση αποθηρίωσις αποθησαυρισμός αποθησαυριστής
αποθησαύριση αποθησαύρισις αποθησαύρισμα αποθορυβοποίηση αποθράσυνση
αποθυμιά αποικία αποικιοκρατία αποικισμός αποικιστής αποικοδομητής
αποκάθαρση αποκάθαρσις αποκάλυψη αποκάλυψις αποκάμωμα αποκάρωμα αποκάρωση
αποκέντρωση αποκέντρωσις αποκήρυξη αποκήρυξις αποκαΐδι αποκαθήλωση
αποκαλυπτήρια αποκαλυπτικότητα αποκαλύψιμος αποκανονικοποίηση αποκαρβοξυλίωση
αποκαρδίωσις αποκαρδιωμός αποκαρτέρηση αποκατάσταση αποκατάστασις
αποκεράτωση αποκερματισμός αποκεφάλιση αποκεφάλισμα αποκεφαλισμός
αποκηρύσσω αποκλάδι αποκλήρωση αποκλήρωσις αποκλεισμός αποκλειστικότητα
αποκλιμάκωσις αποκοίμιση αποκοίμισμα αποκολοκύνθωση αποκομιδή
αποκοπή αποκορύφωμα αποκορύφωση αποκορύφωσις αποκοτιά αποκούμπι
αποκριά αποκρυπτογράφηση αποκρυπτογράφησις αποκρυπτογράφος αποκρυστάλλωμα
αποκρυστάλλωσις αποκρυσταλλοποίηση αποκρυφισμός αποκρυφιστής αποκρυφολογία
αποκωδικοποίηση αποκωδικοποιητής αποκόλληση αποκόλλησις αποκόμιση αποκύημα
απολάκτιση απολάκτισις απολέπιση απολέπισις απολέπισμα απολίθωμα απολίθωση
απολίνωση απολίνωσις απολίπανση απολίπανσις απολαβή απολαδώνω απολείτουργα
απολειφάδι απολειφαδάκι απολεπισμός απολησμονιά απολιγνιτοποίηση
απολιτικός απολιχνίδι απολιόρκητος απολλώνιος απολογήτρια απολογία απολογητής
απολογισμός απολογιστικότητα απολταριά απολυμαντήριο απολυμαντήριον
απολυμαντικό απολυτήριο απολυτήριον απολυτίκιο απολυτίκιον απολυταρχία
απολυταρχικότητα απολυταρχισμός απολυτρωμός απολυτρωτής απολυτότης απολυτότητα
απολύμανσις απολύτρωση απολύτρωσις απομάγευση απομάκρυνση απομάκρυνσις
απομίμηση απομίμησις απομαγνήτιση απομαγνητισμός απομαγνητοφώνηση απομείωση
απομεσήμερο απομετάλλωση απομιξία απομνημονευματογράφος απομνημονευματογραφία
απομνημόνευμα απομνημόνευση απομνημόνευσις απομονωτήριο απομονωτήριον
απομυελίνωση απομυζητήρ απομυζητήρας απομυθοποίηση απομυθοποίησις απομόλυνση
απομόνωση απομόνωσις απομύζηση απομύζησις απονάρκωση απονάρκωσις απονέκρωμα
απονέκρωσις απονέρι απονέρια απονέρωση απονήωση απονίτρωση απονίψιμο
αποναζιστικοποίηση αποναρκοθέτηση απονεριά απονευρωσίτιδα απονεύρωση
απονιά απονιψίδι απονομή απονομιμοποίηση απονομισματοποίηση απονύχι απονύχτερο
αποξένωση αποξένωσις αποξήλωμα αποξήλωση αποξήρανση αποξήρανσις αποξηραντήριο
αποορθοδοξοποίηση αποπάτημα αποπάτηση αποπάτησις αποπαίδι αποπαγοποίηση
αποπεράτωσις αποπλάνεμα αποπλάνηση αποπλάνησις αποπλανητής αποπλεύριση
αποπληθωρισμός αποπληθωριστικός αποπληξία αποπληρωμή αποπληρωτής αποπνευμάτωση
αποπνιγμός αποπνικτικότητα αποπνικτικώς αποποίηση αποποίησις αποποινικοποίηση
αποπροσανατολισμός αποπροσγείωση αποπροσγειάλωση αποπροσθαλάσσωση αποπροσνήωση
αποπυρήνωση αποπυρηνικοποίηση αποπωμάτιση αποπωμάτισις απορία απορριματοδοχείο
απορριξίμι απορριξιμιό απορροή απορροφητήρας απορροφητικότης απορροφητικότητα
απορρόφηση απορρόφησις απορρύθμιση απορρύπανση απορρύπανσις απορφάνιση
απορφανισμός αποσάθρωση αποσάθρωσις αποσάριδο αποσάρωμα αποσαρίδι αποσαφήνιση
αποσαφηνισμός αποσβεστήρας αποσβόλωμα αποσιδήρωση αποσιωπητικά αποσιώπηση
αποσκίρτηση αποσκίρτησις αποσκελέτωση αποσκευή αποσκλήρυνση αποσκλήρυνσις
αποσκληρυντικά αποσκληρυντικό αποσκοράκιση αποσκορακισμός αποσκωρίαση
αποσπερίτης αποσπερμάτιση αποσπερμάτωση αποσπερματισμός αποσπερνός αποσπορία
αποστάλαγμα αποστάτης αποστάτισσα αποστάτρια αποστάφυλα αποστάφυλο αποστέγνωμα
αποστέρηση αποστέωση αποστήθιση αποστήθισμα αποσταγματοποιείο αποσταγματοποιός
αποστακτήρ αποστακτήρας αποστακτήριο αποσταμάρα αποσταμός αποστασία αποστασίλα
αποστείρωση αποστειρωτήρας αποστειρωτής αποστολέας αποστολή αποστράβωμα
αποστράγγιση αποστράγγισμα αποστράτευση αποστραγγίδι αποστραγγισμός
αποστρακισμός αποστρατεία αποστρατικοποίηση αποστρατιωτικοποίηση αποστροφή
αποστόμωση αποσυγκέντρωση αποσυγχρονισμός αποσυγχώνευση αποσυμπίεση
αποσυναρμολόγηση αποσυρραπτικό αποσυσκευασία αποσυσχέτιση αποσυσχετισμός
αποσφαλματωτής αποσφράγιση αποσφράγισις αποσφράγισμα αποσχηματισμός αποσχιστής
αποσόβησις αποσύνδεση αποσύνθεση αποσύνθεσις αποτέλειωμα αποτέλεσμα αποτέφρωση
αποτίμηση αποτίμησις αποτίναγμα αποτίναξη αποτίναξις αποταμίευμα αποταμίευση
αποταμιευτήρας αποταμιευτής αποταμιεύτρια αποτελείωμα αποτελεσματικότης
αποτελμάτωση αποτελμάτωσις αποτερματίζω αποτερματισμός αποτεφρωτήρας
αποτιτάνωσις αποτοίχιση αποτολμιά αποτοξίνωση αποτοξίνωσις αποτράβηγμα
αποτρίχωσις αποτραβηγμός αποτρεπτικότητα αποτριχωτικό αποτροπή αποτροπιασμός
αποτρυγίδι αποτρόπαιο αποτρύγι αποτσάμπι αποτσίγαρο αποτσιμεντοποίηση
αποτυπωτής αποτυχία αποτόλμημα αποτύπωμα αποτύπωση αποτύπωσις απουσία
απουσιολόγιο απουσιολόγιον απουσιολόγος αποφάγι αποφάι αποφαγούδι αποφαλάκρωση
αποφασιστικότητα αποφατισμός αποφθορίωση αποφλοίωση αποφλοίωσις αποφλοιωτής
αποφοίτησις αποφοιτήριο αποφοιτήριον αποφολίδωση αποφορά αποφούρνισμα αποφράδα
αποφυγή αποφυλάκιση αποφυλάκισις αποφυλακιστήριο αποφυλακιστήριος αποφόρι
αποφόρτισις αποφώλιον αποφώνηση αποχέτευση αποχέτευσις αποχή αποχαιρέτημα
αποχαιρετισμός αποχαιρετιστήρια αποχαιρετούρα αποχαλίνωση αποχαλίνωσις
αποχαύνωμα αποχαύνωση αποχαύνωσις αποχείμωνο αποχειροτονία αποχιονισμός
αποχουντοποίηση αποχρεμπτικά αποχρωμάτιση αποχρωματισμός αποχτένισμα
αποχυμωτής αποχωμάτωση αποχωρητήριο αποχωρισμός αποχωριστής αποχωροθέτηση
αποχώρησις αποψίλωση αποψίλωσις αποψύλωση αποϊδρυματοποίηση αποϋλοποίηση
απρέπεια απραγμοσύνη απραξία απριορισμός απρογραμμάτιστο απροθυμία
απρονοησία απροσάρμοστο απροσαρμοστία απροσδιοριστία απροσεξία απροσωπία
απροχώρητο απροχώρητον απρόοπτο απτάλικος απτέρυξ απτηνοδύτης απτότητα
απωθητής απωθητικό απόαψη απόβαλμα απόβαρο απόβαρον απόβαση απόβασις απόβγαλμα
απόβραδο απόβρασμα απόβροχο απόγαιον απόγειο απόγειον απόγεμα απόγευμα
απόγνωση απόγνωσις απόγονος απόγραφο απόγραφον απόδειξη απόδειξις απόδειπνο
απόδεμα απόδημος απόδιωγμα απόδοση απόδοσις απόδραση απόδρασις απόδυση
απόζευξη απόηχος απόθεμα απόθεση απόθεσις απόκαρσις απόκερο απόκληρος απόκλιση
απόκομμα απόκρια απόκριση απόκρουση απόκρουσις απόκρυψη απόκρυψις απόκτημα
απόκτησις απόλαυση απόλαυσις απόλαψη απόληξη απόληξις απόληψη απόληψις
απόλυση απόλυσις απόλυτο απόλυτο απόλυτον απόμακτρο απόμακτρον απόμαλλο
απόνερο απόνιμμα απόνιψις απόξεση απόξεσις απόξεσμα απόξυσμα απόπαιδο απόπατος
απόπεμψη απόπιμα απόπιομα απόπλους απόπλυμα απόπλυση απόπλυσις απόπνιξη
απόπτυση απόπτυσις απόπτυσμα απόπτωση απόπτωσις απόρρευμα απόρρητο απόρριμμα
απόρριψις απόρροια απόσαξη απόσαξις απόσβεση απόσβεσις απόσειση απόσεισις
απόσμηξις απόσμηση απόσπαση απόσπασμα απόσταγμα απόσταμα απόσταξη απόσταση
απόστημα απόστολος απόστρατος απόστροφος απόσυρση απόσυρσις απόσχιση απόσχισις
απόταξη απόταξις απότιση απότισις απότμημα απότμηση απότμησις απότριμμα
απόφανσις απόφαση απόφασις απόφθεγμα απόφραξη απόφραξις απόφυση απόφυσις απόχη
απόχρεμμα απόχρεμψη απόχρεμψις απόχρωση απόχρωσις απόχτημα απόχτηση απόχυμα
απόψυξις απύρι απώθηση απώθησις απώλεια απώλειες αρά αράδα αράδιασμα αράουτ
αράπης αράπισσα αράχνη αρένα αρέσκεια αρίδα αρίθμηση αρίθμησις αρίς αρίστευση
αραίωμα αραίωση αραίωσις αραβίδα αραβίς αραβικά αραβισμός αραβοσιτέλαιο
αραβόσιτος αραγκονικά αραγονικά αραγωνικά αραθυμιά αραιόμετρο αραιόμετρον
αραιότητα αρακάς αρακόσουπα αραλίκι αραμαϊκά αραμπάς αραμπαδάκι αραμπατζής
αραουκάρια αραπάκι αραπίνα αραπιά αραπλής αραποκαύλης αραποσίταρο αραποσίτι
αραποφάσουλο αραπόσταρο αραρούτι αρασέ αραχίδα αραχίς αραχιδέλαιο αραχιδέλαιον
αραχνοφοβία αραχοβίτης αρβανίτης αρβανίτισσα αρβανιτιά αρβανιτοβλάχικα
αρβανιτόβλαχος αρβαντοβλάχικα αρβαντόβλαχος αρβύλα αργάτης αργία αργίλιο
αργαντινή αργαστέρ αργαστήρι αργατιά αργεντίνος αργεντινέζος αργεντινός
αργιλές αργιλοπλαστική αργιλόχωμα αργινίνη αργιολόι αργιόλογο αργκό αργομισθία
αργοσχολία αργυρά αργυραμοιβός αργυρογλυπτική αργυροπελεκάνος αργυροχοΐα
αργυροχρυσοχόος αργυροχόος αργυρωρυχείο αργυρωρυχείον αργό αργύριο αργύριον
αρδεύτρια αρειανισμός αρειανός αρεοπαγίτης αρεσιά αρεσκιά αρετή αρετσίνωτο
αρθρίδιο αρθρίδιον αρθρίτιδα αρθρίτις αρθραλγία αρθρεκτομή αρθρογράφημα
αρθρογραφία αρθροπάθεια αρθροπλαστική αρθροσκόπηση αρθροσκόπιο αρθρόποδα
αριάνι αριβίστας αριβίστρια αριβισμός αριβιστής αριθμητήριο αριθμητήριον
αριθμητική αριθμητικό αριθμοί αριθμοδείκτης αριθμολογία αριθμολόγος
αριθμομηχανή αριθμομνήμονας αριθμομνήμων αριθμοσειρά αριθμοσοφία αριθμός
αριστείο αριστείον αριστερά αριστερίστρια αριστερισμός αριστεριστής
αριστερόχειρ αριστερόχειρας αριστοκράτης αριστοκράτις αριστοκράτισσα
αριστοκρατικοποίηση αριστοκρατικότης αριστοκρατικότητα αριστοκρατισμός
αριστοτέχνης αριστοτέχνις αριστοτέχνισσα αριστοτελισμός αριστούργημα αριόζο
αρκαντάσης αρκιώτης αρκομηλιά αρκουδάκι αρκουδιάρα αρκουδιάρης αρκουδιάρισσα
αρκουδοτόμαρο αρκούδα αρκούδι αρκούδος αρκτικόλεξο αρκτικόσαυρος αρλεκίνος
αρλουμπατζής αρλουμπολογία αρλουμπολόγημα αρλουμπολόγος αρλούμπα αρλούμπας
αρμάθα αρμάθιασμα αρμάρι αρμάτωμα αρμένης αρμένισμα αρμίδι αρμαδίλλος
αρμαδόρος αρμαθιά αρματαγωγό αρματαγωγόν αρματηλάτης αρματηλασία αρματοδρομία
αρματολίκι αρματολός αρματομαχία αρματοφορέας αρματούρα αρματωσιά αρματόρος
αρμενικά αρμενιστής αρμενοβελόνα αρμεξιά αρμογή αρμοδιότης αρμοδιότητα
αρμοκάλυπτρο αρμολογία αρμολόγημα αρμολόγηση αρμολόγησις αρμονία αρμονική
αρμονικότητα αρμοστής αρμοστεία αρμπαρόριζα αρμπιτράζ αρμπουρέτο αρμυρά
αρμυρίκι αρμυροφαγία αρμόνικα αρμόνιο αρμόνιον αρμός αρμύρα αρνά αρνάδα αρνάκι
αρνί αρναούτης αρναούτισσα αρνεμός αρνησιά αρνησιδικία αρνησιθρησκία
αρνησιπατρία αρνητής αρνητικό αρνητικότητα αρνητισμός αρνόδερμα αροΐδα
αρουραίος αροχλάδα αρούρι αρπάγη αρπέτζιο αρπίστρια αρπαγή αρπακολλατζής
αρπακτικό αρπακτικότης αρπακτικότητα αρπακόλλα αρπακόλλα αρπακόλλας αρπαχτή
αρραβωνιάρης αρραβωνιάσματα αρραβωνιαστικιά αρραβωνιαστικός αρραβώνα αρραβώνας
αρρεβωνιάσματα αρρεβώνας αρρεναγωγείο αρρενογονία αρρενοποίηση αρρενοπρέπεια
αρρενωπότης αρρενωπότητα αρρυθμία αρρωστικόν αρρωστομανία αρρωστοφαγιά
αρσακειάδα αρσανάρης αρσανάς αρσενικό αρσενικόν αρσενικός αρσενοκοίτης
αρσιβαρίστρια αρτάνη αρτέμων αρτίδιο αρτίστα αρτίστας αρτίωση αρτίωσις
αρτεργάτης αρτεργάτρια αρτεσιανό αρτηρία αρτηρίδιο αρτηρίτιδα αρτηρίτις
αρτηριοπάθεια αρτηριοσκλήρυνση αρτηριοσκλήρωση αρτηριοσκλήρωσις αρτιμέλεια
αρτιότης αρτιότητα αρτοβιομηχανία αρτοκλασία αρτοπαρασκευαστής
αρτοποίημα αρτοποιία αρτοποιείο αρτοποιείον αρτοποιός αρτοπωλείο αρτοπωλείον
αρτοπώλις αρτοπώλισσα αρτοσκεύασμα αρτοφαγία αρτοφόριο αρτοφόριον αρτυμή
αρτόδεντρο αρφάνια αρχάγγελος αρχάνθρωπος αρχές αρχέτυπο αρχέτυπον αρχή
αρχίγραμμα αρχίδι αρχίνημα αρχίνισμα αρχαΐζουσα αρχαΐστρια αρχαία
αρχαίος αρχαγγελικός αρχαιγόνιο αρχαιοβακτήριο αρχαιοβοτανική
αρχαιογνωσία αρχαιογνωστικός αρχαιογνώστης αρχαιοδίφης αρχαιοδιφικός
αρχαιοκάπηλος αρχαιοκαπηλία αρχαιοκύτταρο αρχαιολάτρης αρχαιολάτρισσα
αρχαιολογία αρχαιολόγος αρχαιομάθεια αρχαιομανία αρχαιομετρία αρχαιονετρίνο
αρχαιοπληξία αρχαιοπρέπεια αρχαιοπώλης αρχαιοπώλισσα αρχαιοσυλία αρχαιοφιλία
αρχαιρεσίες αρχαιότητα αρχαιόφιλος αρχαϊκότητα αρχαϊσμός αρχαϊστής αρχαϊστικός
αρχείον αρχεγονία αρχεγονιάτες αρχειοδίφης αρχειοδιφικός αρχειοθέτης
αρχειοθέτρια αρχειοθήκη αρχειοφυλάκιο αρχειοφυλακείο αρχειοφύλακας αρχειοφύλαξ
αρχηγία αρχηγίνα αρχηγίς αρχηγίσκος αρχηγείο αρχηγείον αρχηγισμός αρχηγός
αρχιγουναραίος αρχιγραμματέας αρχιγραμματεία αρχιγραμματεύς αρχιδιά
αρχιδιάκος αρχιδικαστής αρχιδούκας αρχιδούκισσα αρχιεπίσκοπος αρχιεπισκοπή
αρχιεργάτης αρχιεργάτισσα αρχιεργάτρια αρχιεροσύνη αρχιθαλαμηπόλος
αρχιθησαυροφύλακας αρχιθύτης αρχικελευστής αρχικλέφτης αρχικλέφτρα
αρχικουμούνι αρχικτηνίατρος αρχιλήσταρχος αρχιλακές αρχιληστής αρχιλογίστρια
αρχιλοχίας αρχιμάστορας αρχιμανδρίτης αρχιμηνιά αρχιμηχανικός αρχιμουσικός
αρχινοσοκόμα αρχινοσοκόμος αρχιπέλαγος αρχιπλοίαρχος αρχιστράτηγος
αρχισυμμορίτης αρχισυντάκτης αρχισυντάκτρια αρχισυντάχτης αρχισυντάχτρια
αρχιτέκτονας αρχιτέκτων αρχιτεκτονική αρχιτεκτόνημα αρχιτεκτόνισσα αρχιτελώνης
αρχιτεμπέλαρος αρχιτεμπέλης αρχιτεχνίτης αρχιτεχνίτις αρχιτεχνίτισσα
αρχιφύλακας αρχιφύλαξ αρχιχρονιά αρχιψεύταρος αρχιψεύτης αρχιψεύτρα
αρχολίπαρος αρχολιπαρία αρχομανία αρχονετρίνο αρχονουκλεοσύνθεση
αρχοντάρης αρχονταρίκι αρχονταριό αρχοντιά αρχοντικό αρχοντογυναίκα αρχοντολόι
αρχοντοχωριάτης αρχοντοχωριάτισσα αρχοντοχωριατιά αρχοντοχωριατισμός
αρχοντόπουλο αρχοντόσπιτο αρχοσπόριο αρχοφωτόνια αρχοφωτόνιο αρχόντισσα
αρωγή αρωγός αρωδαμός αρωματοποιία αρωματοποιείο αρωματοποιός αρωματοπωλείο
αρωματοπώλις αρωματοπώλισσα αρωμουνικά αρόσιμος αρύταινα ασάφεια ασέβεια
ασέλγεια ασέξουαλ ασέξουαλς ασήμι ασήμια ασήμωμα ασαμικά ασανσέρ ασανσεριτζής
ασβέστι ασβέστιο ασβέστωμα ασβέστωση ασβακάνδη ασβεστάδικο ασβεστάς ασβεστίτης
ασβεστοκάμινο ασβεστοκάμινος ασβεστοκονίαμα ασβεστού ασβεστόγαλα ασβεστόλιθος
ασβόλη ασβός ασεξουαλικότητα ασετιλίνη ασετυλίνη ασετόν ασημί ασημαντότης
ασημικά ασημικό ασημοκάντηλο ασημόσκονη ασημότης ασημότητα ασηψία ασθένεια
ασθενικότης ασθενικότητα ασθενοφόρο ασιάτης ασιανολογία ασιανολόγος ασιανός
ασινόφιδο ασιτία ασκέρι ασκήμια ασκήτρια ασκί ασκαλώνιο ασκαψία ασκημάδα
ασκητήριο ασκητής ασκηταριό ασκητεία ασκητισμός ασκιανάδα ασκιανός ασκληπιείο
ασκορδούλακας ασκός ασλάνι ασματογράφος ασπάλαθος ασπάλακας ασπάλαξ ασπίδα
ασπαραγίνη ασπασμός ασπεργκερικός ασπιρίνη ασπλάχνια ασπλαχνία ασπλαχνιά
ασπράδι ασπρίλα ασπρικά ασπριστής ασπριτζής ασπροδέλφινο ασπροθαλασσίτης
ασπρολούλουδο ασπροπάρης ασπροπάρι ασπροπυργιώτης ασπρορουχάδικο ασπρορουχάς
ασπροφρύδα ασπροφρύδης ασπρόξυλο ασπρόρουχα ασπρόρουχο ασπρόχωμα ασπόνδυλα
ασσίτης ασσασίνος ασσυριακά ασσυριολογία ασσυριολόγος αστάθεια αστάρι αστάρωμα
αστέρας αστέρι αστή αστήθι αστήρ αστήρανθος αστίατρος αστακοδεξαμενή
αστακολίβαδο αστακοουρά αστακοτροφία αστακοτροφείο αστακός αστακόσουπα αστείο
αστειότητα αστεράκι αστερίας αστερίσκος αστερισμός αστεροειδής αστεροσκοπείο
αστερόεσσα αστεϊσμός αστιγμία αστιγματισμός αστικοποίηση αστικοποίησις αστικό
αστισμός αστοργία αστουριανά αστοχία αστοχασιά αστράβη αστράγαλος αστράκι
αστρέχα αστρί αστρίτης αστραγαλιά αστρακιά αστραπάρι αστραπή αστραποβρόντι
αστραποφεγγιά αστραπόβροντο αστραπόφεγγο αστραπόφιδο αστραχιά αστραψιά
αστροβιογένεση αστροβιολογία αστροβολίδα αστρογεωλογία αστροκουάρκ αστρολάβος
αστρολούλουδο αστρολόγος αστρομαντεία αστρομαντική αστρομετρία αστροναυτική
αστροναύτισσα αστρονομία αστρονόμος αστροπαλίτης αστροπελέκι αστροφεγγιά
αστρόφεγγο αστυθύρεος αστυκτηνίατρος αστυλογία αστυνομία αστυνομικά
αστυνομικός αστυνομοκρατία αστυνόμευση αστυνόμος αστυσία αστυφιλία αστυφυλακή
αστός ασυγυρισιά ασυδοσία ασυλία ασυλλογισιά ασυμβατότητα ασυμμετρία ασυμφωνία
ασυνέχεια ασυναισθησία ασυναρτησία ασυνείδητο ασυνειδησία ασυνεννοησία
ασυρματίστρια ασυρματιστής ασφάλακας ασφάλεια ασφάλιση ασφάλισις ασφάλισμα
ασφάλτωση ασφάλτωσις ασφέρδουκλας ασφακόμελο ασφαλίτης ασφαλίτισσα
ασφαλισιμότητα ασφαλιστήριο ασφαλιστής ασφαλτολίμνη ασφαλτόπανο ασφαλτόστρωμα
ασφαλτόστρωσις ασφοδέλι ασφοδήλι ασφοδίλι ασφοδελίνη ασφοντύλι ασφυγμία
ασφόδελος ασφόντυλος ασχήμια ασχετίλα ασχετοσύνη ασχημάδα ασχημάνθρωπος
ασχημόπαπο ασχολία ασωματίδιο ασωτία ασύρματος ατάκα ατέλεια ατίμασμα ατίμωση
αταβισμός αταξία αταραξία ατασθαλία ατεκνία ατελιέ ατεχνία ατζάρδος ατζέντα
ατζί ατζαμοσύνη ατζούγα ατζούγια ατημέλεια ατημελησία ατημελησιά ατθιδογράφος
ατιμασμός ατιμαστής ατιμωρησία ατλάζι ατμάκατος ατμάμαξα ατμιστής ατμοβαρίδα
ατμοδρόμωνας ατμοκίνηση ατμοκαθαριστήρας ατμοκαθαριστής ατμοκινητήρας
ατμολέβητας ατμομάγειρας ατμομηχανή ατμομηχανικός ατμοπαγίδα ατμοπλοΐα
ατμοποίησις ατμοσίδερο ατμοστρόβιλος ατμοσφαίρα ατμοτουρμπίνα ατμόιππος
ατμόπλοιο ατμός ατμόσφαιρα ατολμία ατομίκευση ατομίκευσις ατομίστρια ατομιζέρ
ατομικισμός ατομικιστής ατομικότης ατομικότητα ατομισμός ατομιστής ατομοκράτης
ατονία ατονικότης ατονικότητα ατοπία ατοπικός ατού ατρακτίδιο ατραξιόν ατραπός
ατροπίνη ατροφία ατροφικότητα ατρωσία ατσάλι ατσάλωμα ατσάλωση ατσέλεγος
ατσίδα ατσίδας ατσαλάκωτος ατσαλίνα ατσαλιά ατσαλοσύνη ατσαλόπροκα ατσελεράντο
ατταπουλγίτης αττικίζουσα αττικίστρια αττικισμός αττικιστής ατυχία ατόλη
ατόνησις ατόπημα ατύχημα αυγή αυγίτης αυγινή αυγοθήκη αυγολέμονο αυγομαντεία
αυγοσαλάτα αυγοτάραχο αυγουλάδικο αυγουλάκι αυγουλάς αυγουλομάτης αυγουστιά
αυγούλι αυγό αυγότσουφλο αυθάδεια αυθέντης αυθαίρετο αυθαιρεσία αυθεντία
αυθεντικότητα αυθορμησία αυθορμητισμός αυθυπαρξία αυθυποβολή αυθυποστασία
αυθυπόστατο αυλάκι αυλάκιασμα αυλάκισμα αυλάκωμα αυλάκωση αυλάρχης αυλή
αυλαία αυλακιά αυλαρχία αυλαρχείο αυλητής αυλητρίδα αυλιδιώτης αυλικός
αυλοκόλακας αυλωθητήρας αυλωνίτης αυλόγυρος αυλόθυρα αυλόπορτα αυλός
αυνανισμός αυξίνη αυξομείωση αυξορρύθμιση αυξότητα αυριανά αυριανισμός
αυστηρότητα αυστραλέζος αυστραλοπίθηκος αυστραλός αυτάδελφος αυτάρκεια αυτί
αυταδέλφισσα αυτανάφλεξη αυταξιολόγηση αυταπάρνηση αυταπάτη αυταρέσκεια
αυταρχικότης αυταρχικότητα αυταρχισμός αυτασφάλεια αυτασφάλιση αυτεγκλωβισμός
αυτεμβόλιο αυτεμπλοκή αυτενέργεια αυτενδοσκόπηση αυτεξουσιότητα αυτεπίγνωση
αυτεπιστασία αυτερωτισμός αυτηκοΐα αυτισμός αυτιστικός αυτοΐαση αυτοάμυνα
αυτοέπαινος αυτοαμφισβήτηση αυτοανάδειξη αυτοαναίρεση αυτοανοσία
αυτοαντίληψη αυτοαξιολόγηση αυτοαποτίμηση αυτοαποτελεσματικότητα
αυτοβιογένεση αυτοβιογράφημα αυτοβιογράφηση αυτοβιογράφος αυτοβιογραφία
αυτοβουλία αυτογένεση αυτογαμία αυτογνωσία αυτογνώστης αυτογονιμοποίηση
αυτοδέσμευση αυτοδιάγνωση αυτοδιάθεση αυτοδιάλυση αυτοδιάψευση αυτοδιέγερση
αυτοδιαφήμιση αυτοδιαχείριση αυτοδιαχειρίζομαι αυτοδικία αυτοδικαίωση
αυτοδιορισμός αυτοδιπλασιασμός αυτοδραστικότητα αυτοδυναμία αυτοεγκλωβισμός
αυτοειρωνεία αυτοεκσπλαχνισμός αυτοεκτίμηση αυτοεμπιστοσύνη αυτοεμπλοκή
αυτοεξαίρεση αυτοεξορία αυτοεξυπηρέτηση αυτοεξόφληση αυτοεπίγνωση
αυτοεπιδιόρθωση αυτοεπικονίαση αυτοεποπτεία αυτοερωτισμός αυτοθέσμιση
αυτοθεραπεία αυτοθυσία αυτοκάθαρση αυτοκέφαλο αυτοκίνητο αυτοκαθαρισμός
αυτοκαθορισμός αυτοκαλλιέργεια αυτοκατάργηση αυτοκαταδίκη αυτοκατανάλωση
αυτοκατεύθυνση αυτοκεφαλία αυτοκινητάδα αυτοκινητάκι αυτοκινητάμαξα
αυτοκινητισμός αυτοκινητιστής αυτοκινητοβιομηχανία αυτοκινητοδρομία
αυτοκινητοθυρίδα αυτοκινητοπομπή αυτοκινητοτράπεζα αυτοκινητόδρομος
αυτοκολλητάκι αυτοκράτειρα αυτοκράτορας αυτοκράτωρ αυτοκρατία αυτοκρατορία
αυτοκριτική αυτοκτονία αυτοκτόνος αυτοκυβέρνηση αυτοκυριαρχία αυτοκόλλητο
αυτολογοκρισία αυτοματισμός αυτοματοποίηση αυτομείωση αυτομελέτη αυτομετάγγιση
αυτομόληση αυτομόλυνση αυτομόρφωση αυτονομία αυτονομίστρια αυτονομιστής
αυτοοικολογία αυτοπάθεια αυτοπαγίδευση αυτοπαλίνδρομος αυτοπαλινδρόμηση
αυτοπαρακίνηση αυτοπαρηγορία αυτοπαρηγοριά αυτοπαρουσίαση αυτοπειθάρχηση
αυτοπεποίθηση αυτοπερίπλεξη αυτοπεριορισμός αυτοπεριπλοκή αυτοπορτρέτο
αυτοπροβολή αυτοπρομηθευτής αυτοπροσδιορισμός αυτοπροστασία αυτοπροσωπογράφος
αυτοπροώθηση αυτοπυρπόληση αυτοραδιογράφημα αυτορρύθμιση αυτοσαρκασμός
αυτοσεβασμός αυτοσκοπός αυτοστοχασμός αυτοσυγκέντρωση αυτοσυγκράτημα
αυτοσυνείδηση αυτοσυνειδησία αυτοσυντήρηση αυτοσυντηρησία αυτοσυσχέτιση
αυτοσχεδιάστρια αυτοσχεδιασμός αυτοσχεδιαστής αυτοσχεδιαστικός αυτοσύμπλεξη
αυτοτέλεια αυτοτελείωση αυτοτελειοποίηση αυτοτιμωρία αυτοτομία αυτοτραυματίας
αυτοτροφοδότηση αυτουργία αυτουργός αυτοφαγία αυτοφθορισμός αυτοφωράκιας
αυτοχαρακτηρισμός αυτοχειρία αυτοχειριασμός αυτοχθονισμός αυτοχρηματοδότηση
αυτοϊκανοποίηση αυτοϋπέρβαση αυτοϋπονόμευση αυτόγραφο αυτόγυρο αυτόκαυστο
αυτόματο αυτόμολος αυτόπτης αυτόπτις αυτότητα αυτόφωρο αυτόχειρ αυτόχειρας
αυτόχθων αυτώνυμο αυχένας αφάλι αφάνα αφάνεια αφάνισμα αφέλεια αφέλειες
αφέντισσα αφέντρα αφέτης αφέψημα αφή αφήγημα αφήγηση αφήλιο αφήνιασμα αφίδα
αφίππευση αφίσα αφαίμαξη αφαίρεση αφαγία αφαγιά αφαιμαξομετάγγιση αφαιρέτης
αφαιρετική αφαλάτωση αφαλατώνω αφαλός αφανισμός αφανιστής αφασία αφγανός
αφελληνισμός αφεντάνθρωπος αφεντιά αφεντικίνα αφεντικό αφεντικός
αφεντόπαιδο αφεντόπουλο αφερεγγυότητα αφερμάτιση αφερμάτισμα αφερματισμός
αφηγήτρια αφηγηματικότητα αφηγητής αφηνίαση αφηνίασμα αφηνιασμός αφηρημάδα
αφθαρσία αφθονία αφιέρωμα αφιέρωση αφιαπωνισμός αφιδνιώτης αφιερωτής
αφιλία αφιλανθρωπία αφιλοκέρδεια αφιλοκαλία αφιλομουσία αφιλοξενία αφιλοπατρία
αφιλοτιμία αφιλοτιμιά αφιλοχρηματία αφιονισμός αφισοκολλήτρια αφισοκολλητής
αφισορύπανση αφισούλα αφιόνι αφιόνισμα αφλογιστία αφοβία αφοβιά αφοδευτήριο
αφοπλισμός αφορία αφορδακός αφορεσμός αφορισμός αφορμή αφοσίωση αφουγκράστρα
αφούγκρασμα αφραγκία αφριά αφρικάανς αφρικανολλανδικά αφρισμός αφροέλληνας
αφροδίσιο αφροδισία αφροδισιακό αφροδισιασμός αφροδισιαστής αφροδισιολογία
αφρολέξ αφρολλανδικά αφρομηλιά αφροντισία αφροντισιά αφροξυλιά αφροσύνη
αφρόγαλο αφρόκρεμα αφρόλουτρο αφρόξυλο αφρός αφρόστοκος αφρόψαρο αφτί αφυΐα
αφυδάτωση αφυδρογόνωση αφυλαξία αφυπηρέτηση αφωνία αφόδευμα αφόδευση αφόπλιση
αφόρμισμα αφύγρανση αφύπνιση αχάμνια αχάνεια αχάτης αχέπανς
αχαμνά αχαμνάδα αχανές αχαριστία αχείλι αχερώνα αχερώνας αχεσιά αχηβάδα
αχθοφόρος αχιβάδα αχιλλαία αχινιός αχινός αχινόσουπα αχιουρές αχλάδα αχλάδι
αχλαδιά αχλαδομηλιά αχλαδόμηλο αχλαδόσχημος αχλύς αχμάκης αχνάδα αχνάρι
αχνοφεγγιά αχνός αχνόφεγγο αχολογή αχολόγημα αχολόι αχονδροπλασία αχορταγιά
αχορτασιά αχούλ αχούρι αχρήστευση αχρήστευσις αχρειολογία αχρειολόγος
αχρειότης αχρειότητα αχρηματία αχρησία αχρηστία αχρωμία αχρωματοψία
αχτίδα αχτίνα αχταρμάς αχυράνθρωπος αχυροκαλύβα αχυροσκεπή αχυρόστρωμα αχυρώνα
αχωνεψιά αχός αψάδα αψέντι αψήφιση αψίδα αψίδωμα αψίδωση αψίνθιο αψίς αψηφισιά
αψιθιά αψιθυμία αψιλία αψιμαχία αψινθιά αϊβαλιώτης αϊμάρα αϊνσταΐνιο αϊράνι
αϊτινός αϊτονύχης αϊτονύχισσα αϊτόπουλο αϊτός αϋλισμός αϋπνία αόριστος αύλακα
αύλαξ αύξηση αύρα αύριο αἰώρα αἴγειρος αὐγόν β-λακτάμες βάβισμα βάβω βάγιο
βάδιση βάδισμα βάζελος βάζο βάθεμα βάθος βάθρακας βάθρο βάθυνση βάι βάιο
βάκλα βάκτρο βάκτρον βάλανος βάλσαμο βάλσιμο βάλτος βάλτωμα βάμβαξ βάμμα
βάνα βάνδαλος βάπτιση βάπτισις βάπτισμα βάραθρο βάραθρον βάρβαρος βάρβιτος
βάρδος βάρδουλο βάρεμα βάριο βάριον βάρκα βάρνα βάρος βάρσαμο βάρσαμος βάσανο
βάσανος βάση βάσις βάσκαμα βάσταγμα βάτα βάτεμα βάτευμα βάτο βάτος βάτραχος
βάφλα βάφτιση βάφτισμα βάψη βάψιμο βάψις βέγγε βέγκε βέδες βέλασμα βέλγος βέλο
βέμβικας βένγκε βένδα βένθος βέντο βέξιμον βέρα βέργα βέσπα βέτο βήμα βήξιμο
βήτα βήχας βήχιο βία βίβλος βίβλος βίγλα βίδα βίδρα βίδωμα βίζα βίζιτα βίκι
βίλα βίλλος βίντεο βίντζι βίντσι βίος βίπερ βίρα βίσονας βίσων βίτζι βίτσα
βίωμα βίωση βίωσις βαένι βαβά βαβά βαβεσίωση βαβουίνος βαβουκλί βαβούλι
βαβυλωνία βαγένι βαγαποντιά βαγγέλιο βαγενάρης βαγενάς βαγεναρείο βαγεναριό
βαγιοβδομάδα βαγιόκλαδο βαγιόκλαρο βαγκνεριστής βαγκόν-λι βαγκόν-ρεστοράν
βαγόνι βαδιστής βαζάκι βαζελίνη βαζιβουζούκος βαθμίδα βαθμοθέτης βαθμοθέτηση
βαθμοθηρία βαθμολογία βαθμολογητής βαθμολόγηση βαθμολόγιο βαθμονομία
βαθμονόμηση βαθμονόμος βαθμοφόρος βαθμωτό βαθμός βαθομέτρηση βαθούλωμα
βαθυμέτρηση βαθυμετρία βαθυσκάφος βαθυτυπία βαθόμετρο βαθύμετρο βαθύνοια
βαθύτητα βαθύχορδο βακέσιο βακέτα βακαλάος βακελίτης βακούφι βακούφιο βακτήριο
βακτηρίαση βακτηρίδιο βακτηρίωση βακτηριαιμία βακτηριολογία βακτηριοσίνη
βακτηριοχλωροφύλλη βακτηριόσταση βακχεία βακχευτής βακχεύτρια βακχιστόρημα
βαλάντωμα βαλέρ βαλές βαλής βαλίνη βαλίτζα βαλίτσα βαλαάς βαλανίδι βαλανίτιδα
βαλανιδιά βαλανιδόψωμο βαλανόστρακο βαλβίδα βαλβιδοπάθεια βαλβιδοπλαστική
βαλβολίνη βαλελίκι βαλεριάνα βαλιδέ βαλιντέ βαλιτσάκι βαλιτσάρα βαλιτσούλα
βαλκανιονίκης βαλκανολογία βαλκανολόγος βαλκανοποίηση βαλλίστρα βαλλισμός
βαλμάς βαλμαδιό βαλμαριό βαλονικά βαλς βαλσάκι βαλσάμωμα βαλσάμωση βαλσαμέλαιο
βαλτονέρι βαλτοποταμίδα βαλτοτόπι βαλτόμπουφος βαλτόνερο βαλτότοπος βαμβάκι
βαμβακέμπορος βαμβακίαση βαμβακιά βαμβακοπαραγωγή βαμβακοπαραγωγός
βαμβακουργία βαμβακουργείο βαμβακοφυτεία βαμβακούλα βαμβακόμελο βαμβακόπιτα
βαμβακόσχοινο βαμβακώνας βαμπάκι βαμπίρ βανάδιο βανίλια βαναυσούργημα
βαναυσότητα βανγκαρντισμός βανγκαρντιστής βανδαλισμός βανιλίνη βανοστάσιο
βαπέρ βαποράκι βαποράρα βαποριά βαποριζατέρ βαπτίσια βαπτισμός βαπτιστής
βαράθρωση βαράθρωσις βαρέλα βαρέλι βαρίδι βαρίδιο βαρίδιον βαρίτης βαρβαρισμός
βαρβαρότητα βαρβατίλα βαρβατιά βαρβατότητα βαρβιτουρικά βαρδάρης βαρδαβέλα
βαρδατέντα βαρδιάνος βαρδιάτορας βαρεία βαρελάδικο βαρελάκι βαρελάς
βαρελοποιός βαρελοσάνιδο βαρελοσανίδα βαρελοσανίς βαρελοστεφάνη βαρελότο
βαρεμένη βαρεμός βαρηκοΐα βαρηκούω βαριά βαριάντ βαριάντα βαριαναστεναγμός
βαριεμάρα βαριεστημάρα βαριεστιμάρα βαριεστισμάρα βαριετέ βαριοπούλα βαρκάδα
βαρκάρης βαρκάρισσα βαρκαδιάτικα βαρκαρόλα βαρκούλα βαρκό βαρονέσα βαρονέτος
βαρονίς βαρούλκο βαρυγκόμια βαρυγκώμια βαρυθυμία βαρυθυμιά βαρυκαιριά
βαρυπνάς βαρυποινίτης βαρυποινίτισσα βαρυστομάχιασμα βαρυστομαχιά βαρυτήμετρο
βαρυόνιο βαρόμετρο βαρόμετρον βαρόνη βαρόνος βαρύαυλος βαρύκεντρο βαρύμαγκας
βαρώνος βασάλτης βασάνισμα βασίλειο βασίλειον βασίλεμα βασίλισσα βασανάκι
βασανισμός βασανιστήρια βασανιστήριο βασανιστήριον βασανιστής βασεόφιλα
βασιβουζούκος βασιλέας βασιλίδα βασιλίκι βασιλίσκος βασιλεία βασιλεμός
βασιλιάς βασιλική βασιλικός βασιλιᾶς βασιλοκτονία βασιλοκόρη βασιλομήτωρ
βασιλοπούλα βασιλόπιτα βασιλόπουλο βασιλόφρων βασιμότης βασιμότητα βασκανία
βασκικά βασοπρεσίνη βαστάζος βασταγή βατ βατήρ βατήρας βατίστα βατερλό
βατομουρέλαιο βατομουριά βατράχι βατραχάκι βατραχάνθρωπος βατραχίνα
βατραχοπέδιλο βατραχοφαγία βατραχόσουπα βατσέλι βατσίνα βατσιμάνης βατσινιά
βατταρισμός βαττολογία βατόμουρο βατότης βατότητα βαυαροκρατία βαυαρός
βαφέας βαφή βαφείο βαφείον βαφεύς βαφιάς βαφικά βαφτίσια βαφτισιμιά
βαφτιστήρα βαφτιστήρι βαφτιστής βαφτιστηράκι βαφτιστικά βαφτιστικό βαϊοφόρος
βγία βδέλλα βδέλυγμα βδία βδελλοπώλης βδελυγμία βδελυγμός βδομάδα βδομαδιάρης
βεβήλωση βεβαίωση βεβαιότητα βεβηλωτής βεγγέρα βεγγαλικό βεγόνια βεδισμός
βεδουίνος βεδούρα βεδούρι βεελζεβούλ βεζίρη βεζίρης βεζιροπούλα βεζιρόπουλο
βελάδα βελάκι βελέντζα βελανίδι βελανιδιά βελανιδόψωμο βελγίδα βελζεβούλ
βεληνεκές βελοθήκη βελονάκι βελονάκιας βελονίστρια βελονιά βελονισμός
βελονοθήκη βελονοθεραπεία βελούδο βελούχι βελτίωση βελτιοδοξία βελτιστοποίηση
βελόνη βελόνι βελόνιασμα βενεδικτίνη βενεζουελανός βενετικά βενετσιάνικα
βενζίνα βενζίνη βενζαλδεΰδη βενζινάδικο βενζινάκατος βενζινάροτρο
βενζιναντλία βενζινοκινητήρας βενζινομηχανή βενζινοπώλης βενζινοπώλισσα
βενζινόπλοιο βενζόη βενζόλη βενζόλιο βεντάγια βεντάλια βεντέμα βεντετισμός
βεξιλολογία βεράντα βερέμης βερέμι βερίκοκκον βερίκοκο βερίνα βεραντάκι
βερβερίτσα βεργάδι βεργάλι βεργίτσα βεργαντίνο βεργολυγερή βεργούλα βερεσέδια
βερζεβούλης βερικοκέλαιο βερικοκιά βερικοκκέα βερικοκκία βερικόκκιον
βερμουτέλαιο βερμούτ βερμπαλίστρια βερμπαλισμός βερμπαλιστής βερνίκι βερνίκιον
βερνισάζ βεροιώτης βερολινέζος βερσιόν βεσέ βεσπάκι βεστιάριο βεστιάριον
βετούλι βηματάκι βηματάρης βηματισμός βηματοδότης βηματοδότηση βημόθυρο
βηρύλλιο βηρύλλιον βησιγότθος βητάς βηχαλάκι βιάρισμα βιάση βια βιαιοπραγία
βιασμός βιαστής βιασύνη βιβάρι βιβίλιο βιβιγλίον βιβλίο βιβλιάριο βιβλιαγορά
βιβλιεκδότης βιβλιεκδότρια βιβλιεμπόριο βιβλιογνωσία βιβλιογνώστης
βιβλιοδέτης βιβλιοδέτηση βιβλιοδέτρια βιβλιοδεσία βιβλιοδετείο βιβλιοδετικά
βιβλιοθήκη βιβλιοθηκάριος βιβλιοθηκονομία βιβλιοθηκονόμος βιβλιοκάπηλος
βιβλιοκλόπος βιβλιοκρισία βιβλιοκριτική βιβλιολάτρης βιβλιολάτρισσα
βιβλιολογία βιβλιομανία βιβλιοπαρουσίαση βιβλιοπωλείο βιβλιοπώλης βιβλιοπώλις
βιβλιοστάτης βιβλιοσυλλέκτης βιβλιοσυλλέκτρια βιβλιοτεχνία βιβλιοφάγος
βιβλιοφύλακας βιβλιοχαρτοπωλείο βιβλιοχαρτοπώλης βιβλιοχαρτοπώλισσα βιβλισμός
βιβλιόσημο βιβλιόσημον βιβλιόψειρα βιβλοπλημμυρισμός βιγλάτορας βιγλατόρισσα
βιδάνιο βιδέλο βιδολόγος βιδωτήρι βιδωτής βιενέζα βιενέζος βιεννέζα βιεννέζος
βιετναμέζος βιετναμικά βιζέρ βιζόν βικάριος βικαριάτο βικιγράφος
βικιλεξικό:ζητούμενα άρθρα/αρχείο2 βικιλεξικό:σχέδιο για ελληνικά λήμματα
βικιποίηση βικιστήμιο βιλάρα βιλίτσα βιλαέτι βιλαέτιο βιμπράτο βιμπράφωνο
βιμπραφόν βινεγκρέτ βινιέτα βιντεογράφηση βιντεογραφία βιντεοδίσκος
βιντεοεγγραφή βιντεοενδοσκόπιο βιντεοθήκη βιντεοκάμερα βιντεοκασέτα
βιντεοπειρατής βιντεοπειρατεία βιντεοπροβολέας βιντεοπροτζέκτορας
βιντεοσκόπιο βιντεοτέξ βιντεοτέξτ βιντεοταινία βιντοεφημερίδα βιντς βινυλίτης
βινύλ βινύλιο βιο βιο-οπτική βιοαγροδιατροφή βιοαιθανόλη βιοαπορρόφηση
βιοαστροναυτική βιοαστρονομία βιοαστροχημεία βιογένεση βιογενετική
βιογονία βιογράφος βιογραφία βιοδείκτης βιοδεδομένα βιοδιάσωση
βιοδιασπασιμότητα βιοδιατήρηση βιοενεργητική βιοεπαγρύπνηση βιοηθική
βιοθεραπεία βιοκαλλιέργεια βιοκαταχώνιασμα βιοκαύσιμο βιοκλιματολογία
βιολoγία βιολέ βιολέτα βιολί βιολίστρια βιολιστής βιολιτζής βιολογία βιολογικά
βιολοντσέλο βιολοντσελίστας βιολοντσελίστρια βιολόγος βιομάζα βιομήχανος
βιομετρία βιομηχανία βιομηχανισμός βιομηχανοποίηση βιομηχανοποίησις
βιομόριο βιονική βιονομία βιοπάλη βιοπαθολογία βιοπαθολογικός βιοπαθολόγος
βιοπαλαιστής βιοπαρείσφρηση βιοπειρατεία βιοπληροφορική βιοποικιλότητα
βιοπορισμός βιοπροστασία βιορομποτική βιορυθμός βιος βιοσοφία βιοσπηλαιολογία
βιοσύνθεση βιοτέχνης βιοτή βιοτεχνία βιοτεχνολογία βιοτεχνολόγος βιοτικά
βιοτσίπ βιοτυπολογία βιοφυσική βιοφωσφορισμός βιοφωταύγεια βιοφωτογραφία
βιοχρονολόγηση βιοψία βιοψυχολογία βιοϊατρική βιοϊσοδυναμία βιοϋλικό βιπεράκι
βιράρισμα βιρμανικά βιρτουόζα βιρτουόζος βισκόζ βισμούθιο βισμούθιον
βιταμίνα βιταμίνες βιταμίνη βιτζιρέλο βιτρίνα βιτρινομάγαζο βιτρινούλα
βιτριόλιον βιτρό βιτσιά βιτσιόζα βιχουέλα βιωματικότητα βιωσιμότητα βιόκοσμος
βιόλυση βιόρυθμος βιόσφαιρα βιότοπος βιότυπος βλάβη βλάκας βλάμης βλάμισσα
βλάος βλάστη βλάστημα βλάστηση βλάστησις βλάττη βλάχα βλάχικα βλάχος βλέμμα
βλέφαρο βλέφαρον βλέψη βλέψις βλήμα βλήτρο βλίτο βλίτον βλαβερότης βλαβερότητα
βλακέντιος βλακεία βλακοκρατία βλακόμετρο βλακόμουτρο βλαμάκι βλαντζί
βλαπτικότητα βλαστάρι βλαστάριον βλαστήμια βλαστίδιο βλαστημιά βλαστημιάρης
βλαστικότητα βλαστοκύτταρο βλαστολόγημα βλαστομυκητίαση βλαστομυκητίασις
βλαστομύκητας βλαστός βλασφημία βλατί βλατίδα βλαχαδερό βλαχιά βλαχογιάπης
βλαχοδημαρχίνα βλαχοκυριλές βλαχομπαρόκ βλαχοπούλα βλαχουριό βλαχοχώρι
βλεννογονεκτομή βλεννογόνος βλεννολυτικά βλεννορραγία βλεννόρροια βλεπάτορας
βλεφάρισμα βλεφαρίδα βλεφαρίς βλεφαρίτιδα βλεφαρίτις βλεφαροπλαστική
βλησίδι βλητική βλογιά βλογούδια βλοσυρότης βλοσυρότητα βλυσίδι βλωμός βοή
βοήθεια:γρήγορη δημιουργία/ουσ- βοήθημα βογάρισμα βογγητό βογιάρος βογκητό
βοεβοδάτο βοεβόδας βοηθηματούχος βοηθός βοηλάτης βοθρίο βοθρατζής βοθρατζίδικο
βοθροϋπάλληλος βολ πλανέ βολά βολάν βολέ βολίδα βολίς βολαπιούκ βολαπούκ
βολβός βολεμένος βολεματίας βολεψάκιας βολεϊμπολίστας βολιδοσκόπηση
βολιώτης βολοκόπος βολονταρισμός βολτ βολτάμετρο βολτάμετρον βολτίτσα βολτούλα
βομβάρδα βομβίδα βομβίστρια βομβαρδισμός βομβητής βομβιδοβόλο βομβιστής
βομβυκοτρόφος βομβύκιο βοναπαρτισμός βοοειδή βορά βορβοροφάγος βορβοροφαγία
βοργόνα βορδονάρης βορδοναρειό βορδοναριό βορειοανατολικά βορειοελλαδίτης
βοριάς βοριαδάκι βορράς βοσκή βοσκαρίδι βοσκοπούλα βοσκοτόπι βοσκόπουλο βοσκός
βοσνιακά βοστρύχωμα βοστρύχωση βοστρύχωσις βοτάνι βοτάνισμα βοτίλια βοτανική
βοτανολόγος βοτανομαντεία βοτρύτης βοτσαλάκι βου βουή βουβάλα βουβάλι
βουβαμός βουβουζέλα βουβωνοκήλη βουβών βουβώνας βουδίστρια βουδδιστικός
βουδιστής βουζούνι βουητό βουκέντρα βουκίτσα βουκελλάριος βουκιά βουκόλος
βουλγάρα βουλγαρικά βουλεβάρτο βουλευτήριο βουλευτήριον βουλευτής βουλευτίνα
βουλευτιλίκι βουλευτοκρατία βουλεύτρια βουλησιαρχία βουλιμία βουλκανιζατέρ
βουλοκέρι βουνάκι βουνί βουνίσιος βουνίτης βουναλάκι βουνοκορφή βουνοπλαγιά
βουνοσειρά βουνό βουνόν βουνόχεντρα βουρβουλάκισμα βουρβουλακίδα βουρβουλακητό
βουργράβος βουρδουλιά βουρδουναρειό βουρκάρι βουρκονέρι βουρκοτόπι βουρκόνερο
βουρλισιά βουρτσάκι βουρτσιά βουστάσιο βουτάνιο βουτήματα βουταδένιο
βουτανόλη βουτηματάκι βουτηχτάρα βουτηχτής βουτιά βουτροφία βουτρόφος βουτσέλα
βουτσινάς βουτυράς βουτυρίλα βουτυριέρα βουτυροκομία βουτυροκομείο
βουτυρομπεμπές βουτυροποιία βουτυροποιείο βουτυροποιείον βουτυροποιός
βουτυροπωλείον βουτυροπώλης βουτυρόγαλα βουτυρόπαιδο βοϊβοδίνα βοϊβόδας
βοϊδολάτης βοϊδοτόμαρο βοϊδόμυγα βοϊδόνευρο βοϊδόπουτσα βούβα βούβαλος
βούδι βούζα βούισμα βούκα βούκερος βούκινο βούκκα βούλα βούλγαρος βούλευμα
βούλησις βούλιαγμα βούλιασμα βούλλα βούλωμα βούνευρο βούνευρον βούργια
βούρκος βούρκωμα βούρλα βούρλισμα βούρλο βούρνα βούρτσα βούρτσισμα βούτα
βούτημα βούτυρο βούτυρον βούφος βράβευση βράγχια βράγχιο βράδιασμα βράδυ
βράδυνσις βράκα βράκτειο βράκτιο βράνη βράση βράσιμο βράσκη βράχια βράχμα
βράχνιασμα βράχος βράχυνση βράχυνσις βρέγμα βρέξιμο βρέσιμο βρέφος βρίζα
βραβείο βραβείον βραδάκι βραδιά βραδιανό βραδυαρρυθμία βραδυγλωσσία βραδυδικία
βραδυπορία βραδυσφυγμία βραδυφαγία βραδυψυχισμός βραδύνοια βραδύποδας
βραδύπορο βραδύπους βραδύτης βραδύτητα βραζιλιάνος βρακάκι βρακάς βρακί
βρακοζώνι βρακοφόρος βρασιά βρασμός βραστήρ βραστήρας βρατσέρα βραχάκι
βραχίων βραχιόλι βραχμάν βραχμάνας βραχμάνος βραχμανισμέ βραχμανισμού
βραχμανισμός βραχμανιστής βραχνάδα βραχνάς βραχογραφία βραχομηχανική βραχονήσι
βραχονησίς βραχυγραφία βραχυκύκλωμα βραχυλογία βραχόπευκο βραχότοπος βραχύτης
βρεκτηρία βρεσίδι βρετίκια βρετανός βρετονικά βρετό βρετόνος βρεφοδόχος
βρεφοκομία βρεφοκομείο βρεφοκομείον βρεφοκτονία βρεφοκτόνος βρεφοκόμος
βρεχάμενα βρεχτοκούκια βρεχτούρα βριγαντίνο βριζόνι βρικολάκιασμα βρικόλακας
βρισιά βριτσίλα βρογχίδιο βρογχίτης βρογχίτιδα βρογχίτις βρογχεκτασία βρογχικά
βρογχισμός βρογχιόλιο βρογχοδιασταλτικά βρογχοκήλη βρογχοπνευμονία
βρογχοσκόπησις βρογχοσκόπιο βρογχοσκόπιον βρογχοτομία βρογχόσπασμος βρολβλός
βρομάνθρωπος βρομερότης βρομερότητα βρομισιά βρομογούρουνο βρομοδουλειά
βρομούσα βρομόγλωσσα βρομόκαιρος βρομόλογο βρομόνερο βρομόξυλο βρομόπαιδο
βρομόστομα βρομύλος βροντή βροντείο βροντόσαυρος βρουτήτης βροχή βροχίλα
βροχοπροστασία βροχόλουρο βροχόμετρο βροχόνερο βροχόπτωση βρούβα βρούχος
βρυξελλιώτης βρυσομάνα βρυσούλα βρυχηθμός βρυόφυτα βρωμίδιο βρωμίωση
βρωσιμότητα βρόγχιο βρόγχος βρόμα βρόμη βρόμικο βρόμιο βρόμισμα βρόντημα
βρόχι βρόχος βρύο βρύση βρώμη βρώμιο βρώμιον βρώση βρώσις βυζάκι βυζάρα
βυζάχτρα βυζί βυζανιάρικο βυζαντινισμός βυζαντινολογία βυζαντινολόγος βυζαρού
βυζασταρούδι βυζομαλακία βυζού βυθιότητα βυθοκόρημα βυθοκόρηση βυθοκόρος
βυθομέτρησις βυθοσκόπηση βυθοσκόπιο βυθοσκόπιον βυθόμετρο βυθός βυνοποίηση
βυνοποιείο βυνοσάκχαρο βυνοσάκχαρον βυρσοδέψης βυρσοδεψία βυρσοδεψείο
βυρσοδεψική βυρωνισμός βυσσινάδα βυσσινέα βυσσινί βυσσινιά βυσσινόκηπος βυτίο
βυτιοφόρο βωλάκα βωμολοχία βωμολόχος βωμοστάσιο βωμός βωξίτης βόας βόγγος
βόδι βόθρος βόιδι βόλεμα βόλεϊ βόλεϊ μπολ βόλεϊμπόλ βόλι βόλισμα βόλιτα βόλος
βόλτα βόμβα βόμβος βόμβυκας βόμβυξ βόρακας βόρβορος βόρεια λαπωνικά
βόριο βόριον βόρτο βόσκημα βόσκηση βόσκησις βόστρυχος βότανο βότκα βότρυς
βότσι βόχα βύας ο γνήσιος βύζαγμα βύθια βύθιση βύθισις βύθισμα βύθος βύνη
βύρσωμα βύσμα βύσσινο βύσσινον βώλος βώτριδα βῶλος γάβανο γάβανος γάβγισμα
γάγγλιο γάγγραινα γάγλα γάδαρος γάδος γάζα γάζωμα γάιδαρος γάλα γάλλιο γάλλος
γάμα γάμημα γάμμα γάμος γάμπα γάμπια γάνα γάντζος γάντζωμα γάντι γάνωμα
γάρμπο γάρμπος γάρος γάσα γάστρα γάτα γάτης γάτος γέεννα γέλασμα γέλιο γέλωτας
γέμισις γέμισμα γένεση γένεση γένεσις γένι γέννα γέννημα γέννηση γένος γέρακας
γέρασμα γέρμα γέροντας γέρος γέρσιμο γέρων γέφυρα γέφυρα γέψη γήγερτον γήινος
γήλοφος γήπεδο γήρανση γήρανσις γήρας γήτεμα γίββωνας γίβεντο γίγαντας
γίγας γίγγλυμος γίγνεσθαι γίδα γίδι γίδια γίντις γίνωμα γα γαία γαίμα γαβ
γαβάνα γαβάνι γαβάρα γαβιάλης γαβράνι γαβριάς γαγάτης γαγγλιοπάθεια γαγκάβα
γαδολίνιο γαελικά (ιρλανδικά) γαελικά (σκωτικά) γαζέλα γαζέπι γαζέτα γαζί
γαζώτρια γαιάνθρακας γαιανθρακαποθήκη γαιανθρακωρυχείο γαιογνώρισμα
γαιοκτήμονας γαιοκτήμων γαιοκτησία γαιοπρόσοδος γαιόσακος γαιότοιχος γαιόχωση
γαλάκτωμα γαλάρι γαλέος γαλέρα γαλέτα γαλή γαλήνεμα γαλήνη γαλί γαλαδερφή
γαλαζόπετρα γαλακτοβιομηχανία γαλακτογονία γαλακτοδαισία γαλακτοκεφιρόκοκκοι
γαλακτοκεφιρόκοκκους γαλακτοκομία γαλακτοκομείο γαλακτοκομείον γαλακτοκομικά
γαλακτομπούρεκο γαλακτοπαραγωγή γαλακτοποίηση γαλακτοποίησις γαλακτοπωλείο
γαλακτοπώλης γαλακτοπώλις γαλακτοπώλισσα γαλακτοσάκχαρο γαλακτοσάκχαρον
γαλακτοφαγία γαλακτωματοποίηση γαλακτόζη γαλακτόμετρο γαλακτόρροια γαλανάδα
γαλαναδιώτης γαλαναδιώτισσα γαλαντομία γαλαντόμα γαλανόλευκη γαλαξίας γαλαξίας
γαλαξιδιώτης γαλαξιδιώτισσα γαλαρία γαλατάδικο γαλατάς γαλατερά γαλατιέρα
γαλατσίδα γαλατόμαγκας γαλατόπιτα γαλατόσουπα γαλβάνιση γαλβάνισμα γαλβανισμός
γαλβανοπλαστική γαλβανοσκόπιο γαλβανόμετρο γαλβανόμετρον γαληνίτης γαληνεμός
γαληνότατος γαληνότητα γαλιάντρα γαλικιανά γαλιφιά γαλιότα γαλλίδα γαλλίζω
γαλλικά γαλλική γαλλισμός γαλλομάθεια γαλλομανία γαλλοπροβηγκιανά γαλλοφιλία
γαλλόφωνος γαλομαχία γαλονάς γαλονοστολισμένος γαλονού γαλοπούλα γαλοτύρι
γαλούχησις γαλόνι γαλόπουλο γαλότσα γαμέτης γαμήκος γαμήσι γαμίδι γαμίκος
γαμβρίκι γαμβρός γαμβρός γαμετάγγειο γαμετογένεση γαμετοκύτταρο γαμετόφυτο
γαμιάς γαμιστρώνας γαμιόλα γαμιόλης γαμιώτης γαμοχέρουλο γαμπάρα γαμπάς
γαμπριλίκι γαμπρούλης γαμπρός γαμψοδακτυλία γαμόπουστας γαμώτο γανάδα
γανωματάδικο γανωματής γανωματζής γανωτής γανωτζής γανόδερμο γαρή γαρίδα
γαργάλεμα γαργάλημα γαργάλισμα γαργάρα γαργάρισμα γαργαλητό γαργαλιάρης
γαργαρολογία γαρδέλι γαρδένια γαρδούμπα γαριδάκι γαριδοσαλάτα γαριδοχορτόσουπα
γαριδόσουπα γαριφαλάκι γαριφαλιά γαρμπής γαρμπίλι γαρνίρισμα γαρνιτούρα
γαρούφαλο γαρυφαλλιά γαρύφαλλο γασμούλος γαστέρα γαστερόποδα γαστρίτιδα
γαστραλγία γαστρεκτομή γαστρεντερίτιδα γαστρεντερίτις γαστρεντερολογία
γαστριδίωση γαστριμαργία γαστρονομία γαστρονόμος γαστροπάθεια γαστρορραγία
γαστροσκόπηση γαστροσκόπιο γατάκι γατί γατονουρά γατοπαρδάκι γατούλα γατόνι
γατόπορτα γατόφιδο γατόψαρο γαυδιώτης γαϊδάρα γαϊδουράγκαθο γαϊδουράκι
γαϊδουριά γαϊδουριάρης γαϊδουροκαβαλαρία γαϊδουρολάτης γαϊδουροφωνάρα
γαϊδουρόκομπος γαϊδούρα γαϊδούρι γαϊτάνι γαϊτάνωμα γαϊτανάκι γαϊτανάς
γαϊτανόφρυδο γαύριασμα γαύρος γδάρσιμο γδάρτης γδικιωμός γδούπος γδύσιμο γείσο
γείτονας γείτων γείωση γεγές γεγενημένα γεγονός γεεθάς γειτνίαση γειτνίασις
γειτονοπούλα γειτονόπουλο γειτόνεμα γειτόνισσα γελάδα γελάδι γελάκι γελάστρα
γελέκι γελέκο γελαδάρης γελαδάρισσα γελασίνος γελαστής γελεκάκι γελοιογράφημα
γελοιογραφία γελοιοποίηση γελοιότητα γελωτοποιία γελωτοποιός γεμενί γεμιστά
γεμιστήρας γεμιστής γεμιτζής γεμολόγος γεμοφέγγαρο γεμοφεγγαριά γεν γενάρχης
γενέθλιο γενέτειρα γενίκευση γενίκευσις γενίτσαρος γενεά γενεαλογία γενειάδα
γενειοφόρος γενεσιουργία γενετή γενετική γενετιστής γενιά γενική γενική έννοια
γενικοσχετικότητα γενικούρα γενικός γενικότης γενικότητα γενιτσαρισμός
γεννήτρα γεννήτρια γενναιοδωρία γενναιοφροσύνη γενναιοψυχία γενναιότης
γεννησιμιό γεννητικότης γεννητικότητα γεννητούρια γεννοφάσκια γενοκτονία
γενομική γενόσημο γεράκι γεράματα γεράνι γερακάρης γερακίνα γερανατζής
γερανός γερατειά γερμάνιο γερμανίδα γερμαναράς γερμανιά γερμανικά γερμανικό
γερμανομάθεια γερμανοφιλία γερμανός γεροκομείο γεροκούσαλο γερομπαμπαλής
γεροντάκι γεροντάκος γεροντάματα γεροντίαση γεροντισμός γεροντοέρωτας
γεροντοκορισμός γεροντοκρατία γεροντοκόρη γεροντολογία γεροντολόγος
γεροντομορφισμός γεροντοπαλίκαρο γεροντόπαχο γεροξούρας γεροπαπάς
γεροσύνη γερουνδιακό γερουσία γερουσιαστής γερούνδιο γερούνδιον γερόλυκος
γερόντισσα γευσιγνώστης γευστικότητα γεφυράκι γεφυράς γεφυροπλάστιγγα
γεφυροποιός γεφυρωτής γεφύρι γεφύρωμα γεφύρωση γεωαντίκλινο γεωβιολογία
γεωγονία γεωγράφος γεωγραφία γεωδαίτης γεωδαισία γεωδιασκόπηση γεωδυναμική
γεωεπιστήμη γεωθερμία γεωθερμική γεωκάλυψη γεωκαρπία γεωλογία γεωλόγος
γεωμαγνητισμός γεωμετρία γεωμηχανική γεωμορφολογία γεωμόρος γεωοικονομία
γεωπολιτισμός γεωπονία γεωπυραμίδα γεωπόνος γεωργία γεωργιανά γεωργιανός
γεωργοκτηνοτρόφος γεωργός γεωσεισμική γεωσκοπία γεωσκώληκας γεωστατική
γεωτεκτονική γεωτοπίο γεωτροπισμός γεωτρύπανο γεωφαγία γεωφυσική γεωφυσικός
γεωχημικός γεύμα γεύση γεύσις γεώμηλο γεώμορο γεώσφαιρα γεώτρηση γεώφραγμα
γη γηθοσύνη γηπεδοποίηση γηπεδούχος γηρίατρος γηρασμός γηρατειά γηριατρική
γηροκομείο γηροκομείον γηροκόμηση γηροκόμος γης γητειά γητευτής γητεύτρα
γιάμπολη γιάνκα γιάνκης γιάντες γιάπης γιάρδα γιάτρεμα γιάτρισσα γιάφκα
γιαβουκλού γιαβουκλούς γιαβρί γιαγερμός γιαγιά γιαγιάκα γιαγιούλα γιαγκίνι
γιακάς γιακαδάκι γιακουτικά γιαλαντζί-ντολμάς γιαλός γιαννιτσιώτης γιαννιώτης
γιαουρτάδικο γιαουρτάς γιαουρτοπόλεμος γιαουρτόσουπα γιαούρτη γιαούρτι γιαπί
γιαπράκι γιαπωνέζα γιαπωνέζικα γιαπωνέζος γιαρ γιαραμπής γιαρμάς γιαρόπο
γιασεμί γιασεμόλαδο γιασμάκι γιατάκι γιαταγάνα γιαταγάνι γιατρέσα γιατρέσσα
γιατρειά γιατρικό γιατροσόφι γιατρός γιατρόφιδο γιαχβισμός γιαχβιστής γιαχνί
γιγάντεμα γιγάντισσα γιγαετός γιγαντισμός γιγαντοαφίσα γιγαντομαχία
γιγαντοπανό γιδάρης γιδιά γιδοβοσκός γιδοπρόβατα γιδοστέφανο γιδόστρατα
γιεν γιεσμαν γιλέκο γιλεκάκι γινάτι γινόμενο γιογιό γιολτζής γιοματάρι
γιορούμπα γιορτάσι γιορτή γιορτασμός γιορταστής γιος γιοσμαρίνι γιοτ γιουβέτσι
γιουγκοσλάβα γιουλτζής γιουνίπερος γιουρδέλι γιουρούσι γιουσουρούμ γιουσουφάκι
γιουχάισμα γιουχάρισμα γιουχαϊσμός γιοφύλλι γιοφύρι γιούκα γιούκος γιούλι
γιούρια γιούρτη γιούσουρι γιρλάντα γιωταχής γιωταχί γιόγκα γιόγκι γιόκας γιόμα
γιόρτασμα γιότσα γιώτα γιώτινγκ γκάβακας γκάβαλο γκάγκαρο γκάγκαρος γκάζι
γκάλοπ γκάμα γκάνγκστερ γκάρισμα γκάστρι γκάστρωμα γκάτζετ γκάφα γκέι γκέιλικ
γκέκας γκέλα γκέμι γκέτα γκέτο γκίδα γκίνια γκαβά γκαβωμάρα γκαγκάβα γκαζά
γκαζάκι γκαζιά γκαζιέρα γκαζιερατζής γκαζοζέν γκαζοντενεκές γκαζόζα γκαζόμετρο
γκαιμπελίσκος γκαλά γκαλερί γκαλερίστας γκαλόπ γκαμήλα γκαμπί γκαμπαρντίνα
γκαμπονέζος γκαναϊανός γκανγκστερισμός γκανιότα γκαντέμης γκαντεμιά
γκαράζ γκαράζι γκαρίγκ γκαρίλα γκαρίστρα γκαρίστρω γκαραζιέρης γκαραζόπορτα
γκαρδιλάγκος γκαρμπολάχανο γκαρνταρόμπα γκαρσονάκι γκαρσονιέρα γκαρσόν
γκαρσόνι γκασμάς γκασπάτσο γκασταρμπάιτερ γκαστριά γκατζετάκιας γκατζόλι
γκαφαδόρος γκαφατζής γκαφατζού γκεβεζελίκι γκεβεζιλίκι γκελ γκεμπελίσκος
γκεσέμι γκεστάλτ γκεστάπο γκι γκιαούρ γκιαούρης γκιζέρι γκιλοτίνα γκινέα
γκιουβέτσι γκιούμι γκισέ γκιόνης γκιόσα γκιώνης γκλάβα γκλάμουρ γκλάσνοστ
γκλίτσα γκλαβανή γκλαμουράτος γκλαμουριά γκλασάρισμα γκλασέ γκλομπ
γκλομπαλιστής γκνου γκοβέρνο γκολ γκολκίπερ γκολτζής γκολφ γκομενάκιας
γκομενίτσα γκομενιάρης γκομενιλίκι γκομενοδουλειά γκομενότσαρκα γκομπλέν
γκορτσά γκορτσιά γκουίρο γκουανό γκουαρανί γκουβερνάντα γκουγκλάρισμα
γκουρμέ γκουρού γκουσμάνια γκουτζαράτι γκοφρέτα γκούντα γκούσα γκούτζης γκράπα
γκρέιπφρουτ γκρέκα γκρέμισμα γκρέξιτ γκρήκλις γκρίζο γκρίκλις γκρίνια γκρίφι
γκραβαρίτης γκραβούρα γκραν πρι γκραν σουξέ γκρανγκινιόλ γκρανκάσα γκραντζ
γκραφίτι γκρελίνη γκρεμνός γκρεμοτσάκισμα γκρεμός γκρενά γκρι γκριλ γκριμάτσα
γκρο γκρο γκρεν γκρο πλαν γκροτέσκο γκρουμ γκρουπ γκρουπάκι γκρουπιέρης
γκρουπούσκουλο γκρόβερ γκόγκες γκόγκιζες γκόλφι γκόμα γκόμενα γκόμενος γκόρτσο
γλάκι γλάκιο γλάρος γλάρωμα γλάσνοστ γλάσο γλάστρα γλέντι γλήνι γλίνα γλίστρα
γλίτσα γλαδίολος γλαδιόλα γλαρέντζα γλαροδόλωμα γλαροπούλι γλαροφωλιά γλαρόνι
γλασάρισμα γλασέ γλασσέ γλαφυρότης γλαφυρότητα γλαύκα γλαύκωμα γλείφτης
γλείψιμο γλειφιντζούρι γλειφιτζούρι γλειφομούνι γλειψιματίας γλεντζές γλεντζού
γλεντοκόπι γλεντοκόπος γλετζές γλεύκος γλιστρίδα γλιτσίνα γλιτωμός
γλοιός γλουταθειόνη γλουταμίνη γλουτός γλυκάδα γλυκάδι γλυκάνισο γλυκίνη
γλυκασμός γλυκατζής γλυκερίνη γλυκερόλη γλυκερότητα γλυκογόνο γλυκοκορτικοειδή
γλυκολέμονο γλυκομίλημα γλυκομηλιά γλυκοπατάτα γλυκοσάλιασμα γλυκοφίλημα
γλυκό γλυκόζη γλυκόλη γλυκόλογο γλυκόμηλο γλυκόριζα γλυκύ γλυκύτητα
γλυναδιώτισσα γλυπτική γλυπτοθήκη γλυπτό γλυτωμός γλυφάδα γλυφή γλυφίδα
γλυφότητα γλωσσάριο γλωσσάς γλωσσίδα γλωσσίδι γλωσσίτικο γλωσσίτσα γλωσσαλγία
γλωσσαμύντορας γλωσσαμύντωρ γλωσσογεωγραφία γλωσσογράφος γλωσσογραφία
γλωσσοκοπάνα γλωσσολογία γλωσσολόγος γλωσσομάθεια γλωσσοπίεστρο γλωσσοπλάστης
γλωσσοπλαστία γλωσσοτομία γλωσσοφαγιά γλωσσού γλωσσόφιλο γλωττίδα γλόμπος
γλύκισμα γλύμμα γλύπτης γλύπτρια γλύστρα γλύτωμα γλύφανο γλώσσα γλώσσημα
γνάφαλο γνέμα γνέσιμο γνέφαλο γνέψιμο γναθοχειρουργική γναθοχειρουργός
γναφεύς γνεύσιος γνησιότητα γνοιάση γνωμάτευση γνωμηγήτορας γνωμικό γνωμοδότης
γνωμοδότρια γνωμολογία γνωμολόγος γνωριμία γνωριμιά γνωριμότητα γνωσιολογία
γνωστικισμός γνωστικός γνωστοποίηση γνωστός γνόφος γνώμη γνώμονας γνώμων γνώρα
γνώση γνώσις γνώστης γνώστρια γοβάκι γοβίτσα γογγυσμός γογγυτό γογγύλη γογγύλη
γοητεία γοκ γολέτα γολιάθ γομάρι γομαλάκα γομαλάστιχα γομαράκι γομολάστιχα
γονάτισμα γονέας γονή γονίδιο γονδολιέρης γονείς γονιδίωμα γονιδιωματική
γονιμότης γονιμότητα γονιοί γονιός γονυκλισία γονόρροια γονότυπος γορίλλας
γοργόνειο γοργότητα γοτθίπλεκτο γοτθισμός γοτθισχιδές γουέστερν
γουίντ σερφ γουίντσερφ γουαδελουπινή γουαδελουπινός γουανό γουβάς γουβίτσα
γουδί γουδοχέρι γουδόχερο γουιντσέρφερ γουλί γουλιά γουλιανός γουμένισσα
γουνάκι γουνάριο γουνάριος γουνέμπορος γουνίτσα γουναράδικο γουναράς
γουναρικό γουνεμπορία γουνοβαφή γουνοβαφείο γουνοποιία γουνόδερμα γουργουρητό
γουργούρα γουργούρισμα γουρλής γουρλομάτα γουρλομάτης γουρλομάτικος γουρουνάκι
γουρουνάς γουρουνιά γουρουνοβοσκός γουρουνομάντρι γουρουνομούρης γουρουνομύτης
γουρουνοπούλα γουρουνοτρίχης γουρουνοτσάρουχο γουρουνοτόμαρο γουρουνόμαντρα
γουρουνόπετσα γουρουνόπετσος γουρουνόπουλο γουρουνότριχα γουρούνα γουρούνι
γουρσουζιά γουστέρα γουστερίτσα γουστόζα γουστόζος γουταπέρκα γουόκι τόκι
γουόλοφ γουότερ πόλο γοφός γούβα γούβωμα γούλα γούμενος γούνα γούπατο γούρι
γούρμασμα γούρνα γούστο γούτος γούφερ γράδο γράμμα γράμματα γράμμωση γράνα
γράσο γράφημα γράψιμο γρέγος γρέζι γρέκι γρίβας γρίλια γρίνα γρίνια γρίνιασμα
γρίπος γρίππη γρίφος γραΐδιο γραΐδιον γραία γραίγος γραβάτα γραβατούλα
γραιγολεβάντες γραιγοτραμουντάνα γραικυλισμός γραικός γραικύλος γραμμάριο
γραμμένο γραμμή γραμμή εργαλείων γραμματέας γραμματεία γραμματεύς γραμματική
γραμματογραφία γραμματοδιδάσκαλος γραμματοκιβώτιο γραμματοκιβώτιον
γραμματολογία γραμματοσήμανση γραμματοσήμανσις γραμματοσειρά γραμματοσυλλέκτης
γραμματόσημο γραμματόσημον γραμμικότητα γραμμογράφημα γραμμογράφηση
γραμμογραφία γραμμοκώδικας γραμμοστρεφής γραμμοσύρτης γραμμόφωνο γραμμόφωνον
γρανάτης γρανίτα γρανίτης γραπτό γρασάρισμα γρασίδι γρασαδοράκι γρασαδόρος
γρασοβαλβολίνη γρατζουνιά γρατζούνισμα γρατσουνιά γρατσούνισμα γραφέας
γραφή γραφίδα γραφίστας γραφίστρια γραφίτης γραφείο γραφειοκράτης
γραφειοκρατία γραφειοκρατικοποίηση γραφεύς γραφιάς γραφιδοπόλεμος γραφικά
γραφισμός γραφιστής γραφιστική γραφοεπεξεργαστής γραφολογία γραφολόγος
γραφοσκόπιο γραφοτυπία γραφτό γραφόμετρο γρεβενιώτης γρεγολεβάντες
γρελίνη γρεναδίνη γρεναδιέρος γρηγοράδα γρηγοροσύνη γρηγορόσημο γρηγορότητα
γριά γριβάδι γριβαδόσουπα γριμόριο γριούλα γριπάρης γριπούλα γριφολογία γροθιά
γροιλανδικά γροιλανδός γρομπαλάκι γρομπούλι γρονθοκόπημα γρουμπούλι γρουσουζιά
γρουσούζα γρουσούζεμα γρούμπος γρούπος γρούτα γρούτη γρυ γρυλισμός γρόθος
γρόσι γρόσσα γρύλισμα γρύλος γρύπας γρύφονας γυάλα γυάλισμα γυάλωμα γυαλάδα
γυαλάκια γυαλάκιας γυαλί γυαλιά γυαλιάς γυαλικά γυαλικό γυαλιστερή
γυαλόχαρτο γυλιός γυμνάσια γυμνάσιο γυμνάσιον γυμνάστρια γυμνίστρια
γυμνασιάρχης γυμνασιάρχισσα γυμνασιοκόριτσο γυμνασιόπαιδο γυμναστήριο
γυμναστική γυμνισμός γυμνιστής γυμνοπαιδία γυμνοσάλιαγκας γυμνοσοφιστές
γυμνό γυμνόσπερμα γυμνότης γυμνότητα γυνή γυναίκα γυναικάδελφος γυναικάδερφος
γυναικάκιας γυναικάρα γυναικάς γυναικαδέλφη γυναικαδέρφη γυναικαδελφός
γυναικαρέσκεια γυναικοδουλειά γυναικοθήρας γυναικοκαβγάς γυναικοκρατία
γυναικολογική γυναικολογικό γυναικολόγι γυναικολόγος γυναικολόι γυναικομάνι
γυναικονόμος γυναικοφέρσιμο γυναικούλα γυναικωνίτης γυναικωτός γυναικόκοσμος
γυπάετος γυπαετός γυράδικο γυρίνος γυρίστρα γυρεοθήκη γυρεόκοκκος γυρισμός
γυρολόγημα γυρολόγος γυροπλάνο γυροσκόπιο γυροφούστανο γυφτάκι γυφταριό γυφτιά
γυφτουριά γυφτοφάσουλο γυφτόπουλο γυψάς γυψοκάμινος γυψοκονία γυψομάρμαρο
γωνέα γωνία γωνίασμα γωνίτσα γωνίωμα γωνιά γωνιόλιθος γωνιόμετρο γωνιόμετρον
γόγγυσμα γόης γόησσα γόητρο γόμα γόμηση γόμος γόμπος γόμφος γόμφωση γόμωση
γόνατο γόνδολα γόνος γόνυ γόος γόπα γόπινγκ γότθος γύλος γύμναση γύμνασις
γύμνια γύμνωμα γύμνωση γύμνωσις γύναιο γύπας γύρα γύρη γύρισμα γύρος γύφτισσα
γύψος γύψωμα γύψωση γύψωσις γώνιασμα γώπα γῆ δάγκαμα δάγκειος δάγκωμα δάδα
δάκρυ δάκρυο δάκρυσμα δάκτυλο δάκτυλος δάνειο δάνεισμα δάπεδο δάπεδον δάρσιμο
δάσκαλος δάσο δάσος δάσυνση δάσωση δάσωσις δάφνη δάχτυλο δάχτυλος δέηση δέησις
δέκαθλο δέκατα δέκατο δέκτης δέλεαρ δέλτα δέλφινας δέμα δέμας δένδρο δένδρον
δέντρος δέξιμο δέοντα δέος δέρας δέρμα δέση δέσιμο δέσις δέσμευση δέσμη
δέσποτας δέστρα δέτης δέψη δήγμα δήλωση δήλωσις δήμαρχος δήμευση δήμευσις
δήμος δήξις δήωσις δίαιτα δίαρμα δίαυλος δίγαμμα δίδαγμα δίδακτρα δίδραχμο
δίδυμο δίδυμοι δίδυμος δίεση δίευρο δίζηση δίζυγο δίζυγον δίκαιο δίκαιον
δίκαρτο δίκας δίκη δίκιο δίκοχο δίκρανο δίκταμο δίκτυο δίκτυον δίκυκλο δίλημμα
δίμιτο δίνη δίοδος δίολκος δίοπος δίοπτρα δίπλα δίπλα δίπλωμα δίπλωση δίπλωσις
δίπτυχο δίπυρος δίσιγμα δίσκος δίστιγμα δίστιγμο δίστιχο δίτερμα δίφθογγος
δίφρος δίχτυ δίψα δίψηφο δίωξη δίωξις δαίδαλος δαίμονας δαίμων δαγγεροτυπία
δαγκαματιά δαγκανιά δαγκεροτυπία δαγκωματάκι δαγκωματιά δαγκωνίτσα δαγκωνιά
δαδί δαδούχος δαημοσύνη δαιμονίστρια δαιμονικά δαιμονικό δαιμονιοπληξία
δαιμονιστής δαιμονιόπληκτος δαιμονοκρατία δαιμονολάτρης δαιμονολάτρισσα
δαιμονοληψία δαιμονολογία δαιμονολόγος δαιμονομανία δαιμονομαντεία
δαιμονοπιστία δαιμονοπληξία δαιμονόπληκτος δαιμόνιο δαιμόνισμα δαιμόνισσα
δακτυλήθρα δακτυλίδι δακτυλίωση δακτυλισμός δακτυλιόλιθος δακτυλοβάμων
δακτυλογράφος δακτυλογραφία δακτυλοκρουσία δακτυλοσκόπηση δακτύλιος δακόσπαθο
δαλτονισμός δαλτωνισμός δαμάλα δαμάλι δαμάσκηνο δαμάσκο δαμάστρια δαμαλίδα
δαμαλισμός δαμαλιώτης δαμαλιώτισσα δαμαριωνίτης δαμαριωνίτισσα δαμασκήνωση
δαμασκηνέλαιο δαμασκηνί δαμασκηνιά δαμασκηνουργία δαμασκηνουργός δαμαστής
δανακιώτισσα δανδής δανδισμός δανείστρια δανειοδότηση δανειοθάλαμος
δανειολήπτρια δανεισμός δανειστήριο δανειστής δανικά δαντέλα δαντέλλα δανός
δαπάνημα δαρβίνιο δαρβινισμός δαρβινιστής δαρμός δασάκι δασάρχης δασαρχείο
δασεία δασκάλα δασκάλεμα δασκάλισσα δασκαλάκος δασκαλίκι δασκαλίστικα
δασκαλισμός δασκαλοπαίδι δασμολογία δασμολόγηση δασμολόγησις δασμολόγιο
δασμολόγος δασμός δασοκαλλιέργεια δασοκομία δασοκτήμονας δασοκόμος δασολογία
δασολόγος δασονομία δασονομείο δασονομείον δασονόμος δασοπονία δασοπυρόσβεση
δασοτόπι δασοφυλακή δασοφυλακείο δασοφυλακείον δασοφυτεία δασοφύλακας
δασωνύμιο δασότοπος δασύλλιο δασύπους δασύτης δασύτητα δατριβογράφος δαυκί
δαυλός δαφνέλαιο δαφνοκέρασος δαφνοκούκουτσο δαφνοστέφανο δαφνόκουκο δαφνόλαδο
δαφνών δαφνώνας δαχτυλάκι δαχτυλήθρα δαχτυλίδι δαχτυλιά δαχτυλιδόπετρα
δαχτυλογράφος δαχτύλι δαψίλεια δείγμα δείκτης δείκτρια δείλη δείλι δείλια
δείξιμο δείπνο δείπνος δείχτης δεδηλωμένη δεδομένα δεδομένο δεδομενικότητα
δειγματοληψία δειγματολόγιο δειγματοχώρος δεικτοποιημένος δειλία δειλινό δεινά
δεινοπάθηση δεινοσαυρολογία δεινόσαυρος δεινότητα δειράς δεισιδαίμονας
δεκάγραμμο δεκάγωνο δεκάδα δεκάδραχμο δεκάευρο δεκάλεπτο δεκάλιρο δεκάλογος
δεκάξι δεκάρα δεκάρι δεκάρικο δεκάριο δεκάτη δεκαέξι δεκαήμερο δεκαδικότητα
δεκαεννιά δεκαεξάδα δεκαεπτά δεκαετία δεκαετηρίδα δεκαεφτά δεκαημερία
δεκαμερία δεκανέας δεκανίκι δεκαοκτάδα δεκαοκτώ δεκαοχτάδα δεκαοχτούρα
δεκαπέντε δεκαπενθήμερο δεκαπενθημερία δεκαπεντάδα δεκαπενταετία δεκαπενταριά
δεκαπενταύγουστος δεκαπλασιασμός δεκαράκι δεκαριά δεκαρολογία δεκαρολόγος
δεκατέσσερα δεκατετράδα δεκατετράστιχο δεκατετραήμερο δεκατημόριο δεκατιανό
δεκατιστής δεκατρία δεκατριάδα δεκατριψήφιο δεκατόμετρο δεκαχίλιαρο
δεκοχτούρα δεκτικότης δεκτικότητα δελέασμα δελεασμός δελεαστικότης
δελτάριο δελτίο δελταπλάνο δελφίνι δελφίνος δελφινάκι δελφινάριο
δεμάτι δεμάτιασμα δεμάτιο δεματάκι δεματάρα δεματάς δεματιά δεματόχορτο
δενδρογαλή δενδρογαλιά δενδροκαλλιέργεια δενδροκομία δενδροκομείο δενδροκόμος
δενδροστοιχία δενδροφυτεία δενδροφύτευση δενδροχρονολόγηση δενδρόκηπος
δενδρώνας δεντράκι δεντρί δεντρογαλιά δεντροκαλλιέργεια δεντρολίβανο
δεντροφυτεία δεντροφύτευση δεντρό δεντρόκηπος δεξίμι δεξίωση δεξίωσις δεξαμενή
δεξαμενόπλοιο δεξιά δεξιοσύνη δεξιοτέχνης δεξιοτέχνις δεξιοτέχνισσα
δεξιοχειρία δεξιότης δεξιότητα δεξιόχειρας δεοντολογία δερβέναγας δερβένι
δερβενάκι δερματέμπορος δερματίνη δερματίτιδα δερματίτις δερματαλοιφή
δερματεμπόριο δερματολογία δερματολόγος δερματοπάθεια δερματοσκόπηση
δερματοστιξία δερματοχειρουργική δερματόκολλα δερμογραφία δερμογραφισμός
δεσμά δεσμίδα δεσμοφύλακας δεσμωτήριο δεσμός δεσμώτης δεσμώτρια δεσποινάριο
δεσποινίς δεσποινιδούλα δεσποσύνη δεσποτάκι δεσποτάτο δεσποτάτον δεσποτεία
δεσποτικόν δεσποτισμός δεσπόζουσα δεσπότη δεσπότης δετηρία δευτέρωμα
δευτεραγωνιστής δευτερεία δευτεροβαπτισμός δευτερολεπτοδείκτης δευτερολογία
δευτεροτρόπιδα δευτερόλεπτο δεφτέρι δεύτερο δη δηκτικότης δηκτικότητα
δηλητήριο δηλητήριον δηλητηρίαση δηλητηρίασις δηλητηριάστρια δηλητηριασμός
δηλοποίηση δηλοποίησις δηλωμένη δηλωσίας δηλωτή δημήτριο δημαγωγία δημαγωγός
δημαρχία δημαρχίνα δημαρχείο δημαρχείον δημαρχιλίκι δημεγέρτης δημηγορία
δημητριακό δημιουργία δημιουργικότης δημιουργικότητα δημιουργισμός
δημιουργός δημιούργημα δημογέροντας δημογέρων δημογεροντία δημογραφία
δημοδιδασκάλισσα δημοκοπία δημοκράτης δημοκράτισσα δημοκράτορας δημοκρατία
δημοκρατισμός δημοκόπος δημοπράτης δημοπράτηση δημοπράτησις δημοπρασία
δημοπρατήριον δημοσίευμα δημοσίευση δημοσιά δημοσιογράφος δημοσιογραφία
δημοσιοκρατία δημοσιολογία δημοσιολόγος δημοσιονομία δημοσιονόμος
δημοσιοποίησις δημοσιοσχεσίστας δημοσιοσχεσίτης δημοσιοϋπαλληλία
δημοσιότης δημοσιότητα δημοσκόπηση δημοσκόπος δημοτική δημοτικίστρια
δημοτικιστής δημοτικό δημοτικόν δημοτικότης δημοτικότητα δημοτολόγιο
δημοφιλία δημοψήφισμα δημόσιο δημότης δημότισσα δηνάριο διάβα διάβαση διάβασις
διάβημα διάβολος διάβρωση διάβρωσις διάγγελμα διάγγελος διάγνωση διάγνωσις
διάδημα διάδικος διάδοση διάδοσις διάδοχος διάδραση διάδρομος διάζευξη διάζωμα
διάθεση διάθλαση διάκενο διάκενον διάκεντρος διάκληση διάκονος διάκος
διάκριση διάκρισις διάλεγμα διάλειμμα διάλειψη διάλειψις διάλεκτος διάλεξη
διάλογος διάλος διάλυμα διάλυμα διάλυση διάμεσο διάμεσος διάμετρος διάνεμα
διάνοια διάνοιγμα διάνοιξη διάνοιξις διάνος διάνυσμα διάολος διάπλαση
διάπλευση διάπλευσις διάπλους διάπραξη διάπραξις διάραχο διάρθρωση διάρθρωσις
διάρρηξη διάρρηξις διάρροια διάσειση διάσεισις διάσελο διάσημα διάσιμο
διάσκεψις διάσπαση διάσπασις διάσταση διάστασις διάστημα διάστιξη διάστιξις
διάστρα διάστρεμμα διάσχιση διάσωση διάσωσις διάτα διάταγμα διάτανος διάταξη
διάταση διάτασις διάτρηση διάτρησις διάττοντας διάττων διάφορο διάφραγμα
διάχυσις διάψευση διέγερση διέγερσις διέλαση διέλευση διέλευσις διέλκυση
διένεξις διέξοδος διήγημα διήγηση διήγησις διήθημα διήθηση διήθησις διήμερο
διαίσθηση διαβάθμιση διαβάθμισις διαβάτης διαβάτις διαβάτισσα διαβήτης
διαβίβασις διαβίωση διαβίωσις διαβαστής διαβατάρης διαβατήριο διαβατήριον
διαβεβαίωσις διαβητικός διαβητολόγος διαβιβάστρια διαβιβαστής διαβιβαστικό
διαβολάκος διαβολάνθρωπος διαβολέας διαβολή διαβολιά διαβολικότητα
διαβολοκόριτσο διαβολοσκορπίσματα διαβολόκαιρος διαβολόπαιδο διαβουκόληση
διαβούλιο διαβρέκτης διαβροχή διαβρωτικότητα διαβόλισσα διαγένεση διαγγελέας
διαγνωστική διαγουμιστής διαγούμισμα διαγράμμιση διαγράμμισις διαγραφή διαγωγή
διαγωγιμότητα διαγωνισμός διαγώνιος διαγώνισμα διαδέτης διαδήλωση διαδήλωσις
διαδηλωτής διαδηλώτρια διαδικασία διαδικτυογραφία διαδικτύωση διαδοκίδα
διαδοχή διαδοχικότης διαδοχικότητα διαδραστικότητα διαδρομή διαδρομιστής
διαζευκτικότητα διαζύγιο διαθέρμανση διαθέτης διαθήκη διαθερμία διαθερμοπηξία
διαθλασίμετρο διαθλαστικότητα διαιρέτης διαιρετέος διαιρετότητα
διαισθησιαρχία διαισθητικότητα διαισθητισμός διαιτησία διαιτητής διαιτητική
διαιτολόγος διαιώνιση διακήρυξη διακήρυξις διακίνημα διακίνηση διακίνησις
διακανονισμός διακανόνιση διακειμενικότητα διακεκαυμένη διακενόμετρο
διακινδύνευση διακινητής διακλάδωση διακλάδωσις διακλαδικότητα διακλαδωτήρας
διακοίνωση διακοίνωσις διακομιδή διακομιστής διακονία διακονητής διακονιά
διακονιάρης διακονιάρισσα διακονικό διακοπές διακοπή διακοποδάνειο διακορευτής
διακοσάρι διακοσαριά διακοσιετηρίδα διακοσιομέδιμνος διακοσμήτρια διακοσμητής
διακρίβωση διακρίνουσα διακριτικό διακριτικός διακριτικότης διακριτικότητα
διακρότημα διακτινισμός διακυβέρνηση διακυβέρνησις διακωδικοποίηση διακωμώδηση
διακόμιση διακόνεμα διακόνημα διακόνισσα διακόπτης διακόρευση διακόρευσις
διακόσμησις διακύβευμα διακύβευση διακύβευσις διακύμανση διακύμανσις διαλάλημα
διαλάλησις διαλαλημός διαλαλητής διαλειτουργικότητα διαλεκτική διαλεκτολογία
διαλεύκανσις διαλλαγή διαλλακτικότητα διαλογέας διαλογή διαλογισμός διαλυστήρα
διαλυτήριο διαλυτικά διαλυτικό διαλυτικόν διαλυτότης διαλυτότητα διαλύτης
διαμάχη διαμέλιση διαμέριση διαμέρισμα διαμέτρημα διαμέτρηση διαμήνυση διαμίνη
διαμαντικό διαμαντόπετρα διαμαντόσκονη διαμαρτία διαμαρτυρία διαμαρτυρικό
διαμαρτυρόμενος διαμαρτύρηση διαμαρτύρησις διαμελίστρια διαμελισμός
διαμερισματάκι διαμερισματοποίηση διαμερισμός διαμεσολάβηση διαμεσολαβήτρια
διαμεσόγαμα διαμεταγωγή διαμετακόμιση διαμεταφυσική διαμετρημός διαμοίραση
διαμοιρασμός διαμονή διαμονητήριο διαμορφωτής-αποδιαμορφωτής διαμορφώτρια
διαμόρφωση διανάκτης διανδρία διανεμήτρια διανεμητής διανευρώνας διανθράκωση
διανοήτρια διανοησιαρχία διανοητής διανοητικισμός διανοητικότης διανοητικότητα
διανομή διανομεύς διανοουμενίστικα διανοούμενος διαντίδραση διανυκτέρευση
διανόημα διανόηση διανόησις διαξιφισμός διαολάκι διαολιά διαπάλη διαπήδηση
διαπίδυσις διαπίστευση διαπίστευσις διαπίστωση διαπίστωσις διαπαιδαγώγηση
διαπαρείσφρηση διαπεραίωση διαπεραίωσις διαπερατότης διαπερατότητα
διαπιστευτήριο διαπλάτυνση διαπλάτυνσις διαπληκτισμός διαπλοκή διαπνέω διαπνοή
διαπραγμάτευση διαπραγμάτευσις διαπραγματευτής διαπραγματεύτρια διαπρώκτιση
διαπόμπευσις διαπόρθμευση διαπόρθμευσις διαπόσταση διαπότιση διαπύηση
διαπύλια διαργιλάνιο διαρπαγή διαρρήκτης διαρρήκτρια διαρρήχτης διαρροή
διαρρύθμισις διαρχία διασάκι διασάλευση διασάλευσις διασάφηση διασάφησις
διασαλευτής διασαφήνιση διασαφήνισις διασημότης διασημότητα διασκέδαση
διασκέλισμα διασκεδάστρια διασκεδασμός διασκεδαστήριο διασκεδαστής διασκελιά
διασκευάστρια διασκευή διασκευαστής διασκορπισμός διασκόπηση διασκόπιο
διασκόρπισις διασπάθιση διασπάθισις διασπαστής διασπορά διασπορέας
διασταλτικότητα διαστασιολόγηση διαστασιολόγιο διαστατικότητα διασταύρωση
διαστημάνθρωπος διαστημοδρόμιο διαστημοπλοΐα διαστημοπορία διαστημόπλοιο
διαστολή διαστρέβλωμα διαστρέβλωση διαστρέβλωσις διαστρεβλωτής διαστρεβλώτρια
διαστροφή διαστρωμάτωση διασυμπερίληψη διασυνδεσιμότητα διασυνδετισμός
διασφάλιση διασωλήνωση διασύνολο διασώστης διασώστρια διατάκτης διατάραξη
διατήρηση διατίμηση διατίμησις διαταγή διατακτική διαταράκτης διαταραχή
διατοιχισμός διατομή διατράνωση διατράνωσις διατρέξαντα διατρητήρας διατρητής
διατροπικότητα διατροφή διατροφολογία διατροφολόγος διατσέντο διατυμπάνιση
διατύπωση διατύπωσις διαυλοεπιλογέας διαυλοποίηση διαφάνεια διαφέντεμα
διαφέροντα διαφήμιση διαφήμισις διαφανοσκόπιο διαφημίστρια διαφημιζόμενος
διαφθορά διαφθορέας διαφθορείο διαφιλονίκηση διαφιλονίκησις διαφορά
διαφορετικότητα διαφορικό διαφοροποίηση διαφοροποίησις διαφοροποιητής
διαφραγματοκήλη διαφυγή διαφωνία διαφωτίστρια διαφωτισμός διαφωτισμός
διαφόριση διαφύλαξη διαφύλαξις διαφώτιση διαφώτισις διαχάραξη διαχάραξις
διαχείμασις διαχείριση διαχείρισις διαχειρίσιμος διαχειρίστρια
διαχειρισιολογία διαχειριστής διαχρονία διαχρονικότης διαχρονικότητα
διαχυτικότητα διαχωρισμός διαχύσεις διαόλια διαύγεια διβάνι διβάνιο διβάνιον
διβοράνιο διβουλία διβόλισμα διγένεια διγαμία διγλυκερίδιο διγλωσσία διγνωμία
διδάκτορας διδάκτρια διδάκτωρ διδάσκαλος διδάχος διδακτήριο διδακτική
διδακτορία διδακτορικό διδασκάλισσα διδασκαλία διδασκαλείο διδαχή διδυμία
διδύμιο διείσδυση διείσδυσις διεγέρτης διεγέρτις διεγέρτρια διεγερσιμότης
διεθνής διεθνίστρια διεθνικότης διεθνικότητα διεθνισμός διεθνιστής
διεθνολογία διεθνολόγος διεθνοποίηση διεθνοποίησις διεθνοσοβινισμός
διεισδυτικότητα διεκδίκηση διεκδίκησις διεκδικήτρια διεκδικητής διεκπεραίωση
διεκπεραιωτής διεκπεραιωτικότητα διεκπεραιώτρια διεκτραγώδησις διελκυστίνδα
διεμπλοκέας διεμπλοκή διενέργεια διεξαγωγή διεξοδικότητα διεπαφή διεπιφάνεια
διερευνήτρια διερευνητής διερεύνηση διερεύνησις διερμήνευση διερμήνευσις
διερμηνεία διερμηνευτής διερμηνεύς διερώτηση διερώτησις διεστώτα διετία
διευθέτησις διευθυνσιογράφος διευθυντήριο διευθυντήριον διευθυντής
διευθυντισμός διευθύντρια διευκρίνηση διευκρίνησις διευκρίνιση διευκρινισμός
διευκόλυνσις διευρυνσίας διεύθυνση διεύθυνσις διεύρυνση διεύρυνσις
διηγηματογραφία διηγημός διηγητής διημέρευση διημερίδα διθύραμβος διισχυρισμός
δικάστρια δικάταρτο δικέλλα δικέλλι δικέφαλος δικίτης δικαίωμα δικαίωση
δικαιοδοσία δικαιοδόχος δικαιοκρίτης δικαιοκρατία δικαιοκρισία δικαιολογία
δικαιολόγηση δικαιοπρακτών δικαιοπραξία δικαιοστάσιο δικαιοστάσιον δικαιοσύνη
δικαιόγραφο δικαιόγραφον δικαιόχρηση δικαστήριο δικαστήριον δικαστής δικαστίνα
δικαστικός επιμελητής δικηγοράκος δικηγορία δικηγορίνα δικηγορίσκος
δικηγόρος δικιολογιά δικλίδα δικλείδα δικογραφία δικολάβος δικολαβισμός
δικομματισμός δικονομία δικράνι δικτάτορας δικτάτωρ δικτατορία δικτατορίσκος
δικτύωση δικόγραφο δικόγραφον διμήνι διμεταλλισμός διμετρόδοντας διμηνία
διμηνιό διμοιρία διμοιρίτης διμορφία διμορφισμός διμορφοθήκη διοίκηση
διοικήτρια διοικητήριο διοικητής διοικητολόγος διοισοφάγειο διολίσθηση
διομολόγηση διομολόγησις διονυσιασμός διονυσιαστής διοξείδιο διοπτρία
διορία διορατικότης διορατικότητα διοργάνωση διοργάνωσις διοργανωτής
διορθωπόλεμος διορθωτής διορθωτικό διορθώτρια διορισμός διοριστήριο διοσημία
διουρητικά διουρητικό διοχέτευση διούρηση διούρησις διπλάρια διπλάρωμα
διπλοέλικα διπλοβαπτισμός διπλοβδόμαδο διπλογραφία διπλοθεσία διπλοκατοικία
διπλοπροσωία διπλοσάγονο διπλοσέλινο διπλοσίγμα διπλοτυπία διπλοχαιρέτισμα
διπλοψήφισμα διπλοψηφία διπλούν διπλωμάτης διπλωμάτις διπλωμάτισσα διπλωματία
διπλωματικότητα διπλωμός διπλωπία διπλό διπλότυπο διποδισμός διπολικότητα
διπροσωπία διπυρίτης δις δισάκι δισέγγονη δισέγγονο δισέγγονος δισακχαρίτης
δισεγγονός δισεγγόνα δισεγγόνι δισεκατομμυριοστό δισεκατομμυριούχος
δισεκατομμύριον δισεχτιά δισκάδικο δισκάριο δισκέτα δισκίο δισκίον δισκεκτομή
δισκοβολία δισκοβόλος δισκογραφία δισκοθήκη δισκοπάθεια δισκοπρίονο
δισκοπότηρο δισκοπότηρον δισκόβαθμο δισκόφρενο δισταγμός διστακτικότης
δισταυρία διυλιστήριο διυλιστήριον διυπουργική διφθέρα διφθερίτιδα διφθερίτις
διφραγκάκι διφυΐα διφωνία διφωσφορυλίωση διφωσφορύλιο διχάλα διχάστρια
διχαστής διχερέα διχλωρίδιο διχογμωνοσύνη διχογνωμία διχοστασία διχοτομία
διχοτόμος διχρωμία διχτάκι διχόνοια διωγμός διωδία διωματάρα διωματάρης
διωστήρας διόγκωση διόγκωσις διόδιο διόπτευση διόπτευσις διόπτρα διόραμα
διόρασις διόρθωμα διόρθωση διόρθωσις διόρυξη διόφθαλμο διύλιση διύλισις
διώκτης διώκτις διώκτρια διώμα διώνυμο διώξιμο διώροφο διώρυγα διώρυξ διώχτης
δοβλέτι δογματικότης δογματικότητα δογματισμός δοθιήν δοθιήνας δοθιήνωση
δοιάκι δοκάρι δοκίμι δοκίμιο δοκίμιον δοκησισοφία δοκιμή δοκιμασία
δοκιμαστήριον δοκιμαστής δοκιμιογράφος δοκιμιογραφία δοκούν δοκτορέσα δοκός
δολίευση δολερότης δολερότητα δολιοφθορά δολιχοδρομία δολιχοκεφαλία
δολιότητα δολλάριο δολλάριον δολομίτης δολοπλοκία δολοπλόκος δολοφονία
δολοφόνισσα δολοφόνος δομή δομίστρια δομινικανός δομισμός δομιστής δομομονάδα
δομοστοιχείωση δομόφερτος ήχος δον δονάκιο δονάκον δονζουάν δονζουανισμός
δονητής δονκιχοτισμός δονκιχωτισμός δονουσιώτης δοντάκι δοντία δοξάρι
δοξαριά δοξαρισμός δοξασία δοξολογία δοξολόγημα δορά δορκάς δορυφοροποίηση
δοσάς δοσίλογος δοσατζής δοσατζού δοσοληψία δοσολογία δοσού δοτική δουβλόνι
δουκάτον δουκέσα δουλάκι δουλέμπορος δουλίτσα δουλεία δουλειά δουλεμπορία
δουλεμπόριο δουλεμπόριον δουλευτάρης δουλευτής δουλευταράς δουλευταρού
δουλικό δουλικότης δουλικότητα δουλοκτήτης δουλοκτησία δουλοπάροικος
δουλοπρέπεια δουλοσύνη δουλοφροσύνη δουξ δουρβάνι δοχείο δοχείον δοχειάρης
δούκας δούκισσα δούλα δούλεμα δούλεψη δούλος δούναι δράγα δράγμα δράκα
δράκισσα δράκοντας δράκος δράκουλας δράμα δράμι δράνα δράξ δράπανο δράση
δράστης δράστιδα δράστις δράστρια δρέπανο δρέπανον δρίματα δρίμες δραγάνα
δραγάτισσα δραγουμάνος δραγόνος δρακολίμνη δρακοντιά δρακουλιάρης δρακόμυγα
δραμαμίνη δραματικότης δραματικότητα δραματογράφος δραματογραφία δραματολογία
δραματολόγιον δραματοποίηση δραματοποίησις δραματουργία δραματουργός δραμινός
δραπέτευσις δραπέτης δραπέτις δραπέτισσα δρασκέλισμα δρασκελιά δρασκελισμός
δραστηριοποίησις δραστηριότητα δραστικοποιητής δραστικότης δραστικότητα δραχμή
δραχμοφονιάς δραχμούλα δρεπάνι δρεπάνισμα δρεπανοκυττάρωση δρεπανοκύτταρο
δριμόνι δριμύτητα δριστέλα δρογογνωσία δρολάπι δρομάδα δρομάκι δρομάκος
δρομίσκος δρομολόγηση δρομολόγησις δρομολόγιο δρομολόγιον δρομόμετρο
δροσέρα δροσερότητα δροσιά δροσοπηγή δροσοστάλα δροσοσταλίδα δροσοσταλιά
δροσό δροσόπαγο δροσόπαγος δρουγγάριος δρυΐδης δρυάδες δρυμός δρυμώνας
δρυοκόπος δρυς δρυόπτερις δρωτάρι δρωτσίλα δρόγη δρόλαπας δρόμος δρόμωνας
δρόσισμα δρόσος δρύφακτο δρώμα δρώμενο δυάδα δυάρα δυάρι δυάς δυαδικότητα
δυνάμωμα δυνάστης δυναμίτης δυναμίτιδα δυναμική δυναμικό δυναμικόν δυναμικότης
δυναμισμός δυναμιστής δυναμιτάκι δυναμιτιστής δυναμογονία δυναμογράφος
δυναμοσύνολο δυναμό δυναμόμετρο δυναστεία δυνατόν δυνατότης δυνατότητα
δυνητικότητα δυοσμαρίνι δυσίδρωση δυσαισθησία δυσανάγνωση δυσαναλογία
δυσανασχέτησις δυσανασχέτιση δυσανεξία δυσαρέσκεια δυσαρέστηση δυσαρέστησις
δυσαρμονία δυσαυτονομία δυσβαρισμός δυσβασία δυσβουλία δυσγενεσία δυσγνωσία
δυσενδοκρινία δυσενσυναίσθηση δυσεντερία δυσεντερικός δυσηκοΐα δυσθανασία
δυσιδρωσία δυσκαμψία δυσκαταποσία δυσκινησία δυσκοιλιότης δυσκοιλιότητα
δυσκολία δυσκρασία δυσλειτουργία δυσλεξία δυσλιπιδαιμία δυσμένεια δυσμαί
δυσμνησία δυσμορφία δυσοσμία δυσουρία δυσπαρευνία δυσπεψία δυσπιστία δυσπλασία
δυσπροσαρμοστία δυσπροφερσιμότητα δυσπρόσιο δυσταξινόμηση δυστοκία δυστονία
δυστροπία δυστροφία δυστυχία δυστύχημα δυσυχρονισμός δυσφήμηση δυσφήμησις
δυσφαγία δυσφασία δυσφημία δυσφημία δυσφορία δυσφράδεια δυσφρασία δυσφωνία
δυσχρηστία δυσχρωμία δυσχρωματοψία δυσωδία δυτικισμός δυφίο δυφιοαπεικόνιση
δυφιοδιαφάνεια δυφιονιάδα δυφιοοκτάδα δυφιόρρευμα δυχατέρα δυϊκός δυϊσμός
δωδεκάγωνο δωδεκάδα δωδεκάεδρο δωδεκάθεο δωδεκάθεον δωδεκάμερο δωδεκάορτο
δωδεκάς δωδεκάωρο δωδεκαήμερο δωδεκαήμερον δωδεκαδάκτυλο δωδεκαδάχτυλο
δωδεκαδακτυλίτιδα δωδεκαδακτυλογαστρεκτομή δωδεκαδακτυλονηστιδοστομία
δωδεκαδακτυλοπηξία δωδεκαδακτυλοπυλωρεκτομή δωδεκαδακτυλοσκόπηση
δωδεκαδακτυλοτομία δωδεκαετία δωδεκανήσιος δωδεκαριά δωδεκατημόριο δωδεκαωρία
δωματιάκι δωματιάρα δωρήτρια δωρεά δωρεοδότης δωρεοδόχος δωρητής δωροδοκία
δωροδόκος δωροεπιταγή δωρολήπτης δωροληψία δωρόσημο δωσίλογος δωσιδικία
δόγης δόγμα δόκανο δόκανον δόκιμος δόκτορας δόκτωρ δόλιχος δόλος δόλωμα δόλων
δόμησις δόμος δόνα δόνηση δόνησις δόντι δόξα δόρυ δόση δόσιμο δόσιμον δόσις
δότρια δύναμη δύνη δύση δύσις δύσπνοια δύτης δύτρια δώμα δώρημα δώρο δώρον
είδος είδωλο είκοσι είλωτας είναι είρων είρωνας είσδυση είσοδος είσπλους
είσπραξις εαρινοποίηση εαροσύνη εαυτοσκοπία εαυτούλης εβαπορίτης εβδομάδα
εβδομήντα εβδομηκονταετία εβδομηκονταετηρίδα εβδομηκοντούτης εβδομηκοντούτις
εβδομηντάρα εβδομηντάρης εβδομηντάχρονη εβδομηντάχρονος εβδομηνταριά
εβενουργική εβενουργός εβενούργημα εβολουσιονισμός εβονίτης εβραΐστρια εβραία
εβραίος εβραιο-ισπανικά εβραιοφοβία εβραϊκά εβραϊκή εβραϊσμός εβραϊστής εγίρα
εγγενώς ανώνυμο εγγλέζα εγγλέζος εγγονή εγγονός εγγραμματισμός εγγραμματοσύνη
εγγραφή εγγραφοφυλάκιο εγγραφοφυλακείο εγγυητής εγγυοδοσία εγγυοδότης εγγόνα
εγγύηση εγγύτητα εγελιανισμός εγερσιμότητα εγερτήριο εγκέφαλος εγκαίνια
εγκαθίδρυση εγκαινίαση εγκαινιασμός εγκαλλώπισμα εγκαρίτης εγκαρδίωση
εγκαρτέρηση εγκατάλειψη εγκατάσταση εγκατάστατος εγκαταβίωση εγκαταστάτης
εγκεντρισμός εγκεφαλίτιδα εγκεφαλικό εγκεφαλικότητα εγκεφαλογράφημα
εγκεφαλολόγος εγκεφαλομυελίτιδα εγκεφαλοπάθεια εγκιβωτισμός εγκλεισμός
εγκληματικότητα εγκληματολογία εγκληματολόγος εγκλητήριο εγκλιμάτιση
εγκλιτικό εγκλωβισμός εγκοίλιο εγκοινωνισμός εγκοπή εγκράτεια εγκρέτα εγκρεμός
εγκυκλοπαιδικότητα εγκυκλοπαιδισμός εγκυκλοπαιδιστές εγκυμοσύνη εγκυρότητα
εγκωμιαστής εγκόλληση εγκόλπιο εγκόσμια εγκύκλιος εγκύστωση εγκώμια εγκώμιο
εγχάραξη εγχείρημα εγχείρηση εγχείριση εγχειρίδιο εγχειρηματοποίηση
εγχυματόζωο εγχυτρισμός εγωίσταρος εγωίστρια εγωισμός εγωιστής εγωισταράς
εγωκεντρισμός εγωλάτρης εγωλάτρις εγωλάτρισσα εγωλατρία εγωπάθεια εγωτιστής
εγώ εδάφιο εδαφικότητα εδαφοκάλυψη εδαφοκτησία εδαφολογία εδαφομηχανική
εδεσσαίος εδραίωση εδραίωσις εδωδιμοπωλείο εδωδιμοπωλείον εδωδιμοπώλης εδώδιμα
εδώλιον εθελοδουλία εθελοθυσία εθελοντής εθελοντισμός εθελοτυφλία εθελόντρια
εθισμός εθνάριο εθνάρχης εθναπόστολος εθναρχία εθνεγέρτης εθνεγερσία
εθνική εθνικίστρια εθνικισμός εθνικιστής εθνικοποίηση εθνικοσοσιαλίστρια
εθνικοσοσιαλιστής εθνικοφροσύνη εθνικόν εθνικός ύμνος εθνικότητα εθνισμός
εθνογράφος εθνογραφία εθνοκάθαρση εθνοκεντρισμός εθνοκράτος εθνοκρατία
εθνοκρατοκεντρισμός εθνολογία εθνομάρτυρας εθνομάρτυς εθνομεθοδολογία
εθνομηδενιστής εθνομουσικολογία εθνοπατέρας εθνοσυνέλευση εθνοσφαγέας
εθνοσωτήρας εθνοφοβία εθνοφονία εθνοφονιάς εθνοφρουρά εθνοφρουρός εθνοφυλακή
εθνοψυχιατρική εθνοψυχολογία εθνόσημο εθνότητα εθολογία ειδή ειδήμονας ειδήμων
ειδημοσύνη ειδησάριο ειδησεογράφος ειδησεογραφία ειδησεολογία ειδησούλα
ειδισμός ειδοί ειδογένεση ειδογονία ειδογράφημα ειδοποίηση ειδοποιητήριο
ειδωλολάτρης ειδωλολάτρισσα ειδωλολατρία ειδωλοσκόπιο ειδωλόθυτα ειδωνυμία
ειδύλλιο ειδώλιο εικασία εικαστικός εικονίδιο εικονίτσα εικονικοποίηση
εικονικότητα εικονισμός εικονογράφημα εικονογράφηση εικονογράφος εικονογραφία
εικονοκλασία εικονολάτρης εικονολήπτης εικονολήπτρια εικονολατρία εικονολογία
εικονομάχος εικονομήνυμα εικονομαχία εικονοσκόπιο εικονοστάσι εικονοστάσιο
εικονοσύμβολο εικονοτυπία εικονοχαρακτήρας εικονόγραμμα εικοσάδα εικοσάδραχμο
εικοσάευρο εικοσάλεπτο εικοσάλεπτο εικοσάρι εικοσάρικο εικοσάχρονος εικοσαετία
εικοσιένα εικοσιπεντάευρο εικοσιτετράωρο εικοσιτετράωρον εικοτολογία εικόνα
εικός εικών ειλεός ειλητάριο ειλητάριον ειλητό ειλικρίνεια ειμαρμένη ειρήνεμα
ειρήνη ειρεσιώνη ειρηνίστρια ειρηνευτής ειρηνικά ειρηνισμός ειρηνιστής
ειρηνοδικείο ειρηνοποιός ειρηνοφιλία ειρκτή ειρμός ειρωνεία εισήγηση
εισαγγελία εισαγωγέας εισαγωγή εισαγωγικά εισαγωγούλα εισακτέος εισβολέας
εισδοχή εισηγήτρια εισηγητής εισιτήριο εισιτήριον εισιτηριοαποφυγή
εισοδηματίας εισοδισμός εισπήδηση εισπίεση εισπνευστήρ εισπνευστήρας εισπνοή
εισπράκτωρ εισπράχτορας εισπρακτορίνα εισπρακτόρισσα εισροή εισφορά
εισφοροδιαφυγή εισχώρηση εισχώρησις εισόδημα εισόδια εισόρμηση εισόρμησις
εκάρ εκατομμυριοστό εκατομμυριούχα εκατομμυριούχος εκατομμύριο εκατοντάδα
εκατοντάδραχμον εκατοντάς εκατοντάχρονα εκατονταετία εκατονταετηρίδα
εκατονταρχία εκατοντούτης εκατοντούτις εκατοστάρα εκατοστάρης εκατοστάρι
εκατοσταριά εκατοστημόριο εκατοστό εκατοστόγραμμο εκατοστόμετρο εκατοστόμετρον
εκατοχρονίτισσα εκατό εκατόγραμμο εκατόλιτρο εκατόλιτρον εκατόμβη εκατόνταρχος
εκατόφυλλον εκβάθυνση εκβάθυνσις εκβίαση εκβίασις εκβαρβάρωση εκβαρβάρωσις
εκβιασμός εκβιαστής εκβιομηχάνιση εκβιομηχάνισις εκβιομηχανισμός εκβλάστημα
εκβλάστησις εκβολή εκβραχισμός εκγηπέδωση εκγλύφανο εκγλύφανον
εκγύμναση εκγύμνασις εκδάσωση εκδάσωσις εκδήλωση εκδήλωσις εκδίκαση εκδίκηση
εκδίπλωση εκδίωξη εκδίωξις εκδημοκρατισμός εκδημοτικισμός εκδικήτρια εκδικητής
εκδορά εκδορέας εκδορεύς εκδοροσφαγέας εκδοτήριο εκδοχέας εκδοχή εκδούλευση
εκδούλεψη εκδρομέας εκδρομή εκδρομισμός εκδυσόζωα εκδυτικισμός εκδόσεις
εκδότρια εκεχειρία εκζήτηση εκζήτησις εκθέτης εκθέτις εκθέτρια εκθήλυνση
εκθαμβωτικότητα εκθείαση εκθειάστρια εκθειασμός εκθειαστής εκθεμελίωση
εκθετήριο εκθρονισμός εκθρόνιση εκθρόνισις εκκένωση εκκένωσις εκκίνηση
εκκαθάριση εκκαθάρισις εκκαθαρίστρια εκκαθαριστής εκκαθαριστικό εκκαμίνευση
εκκεντρικότητα εκκεντρότης εκκεντρότητα εκκενωτής εκκινητήρας εκκινητής
εκκλησάρης εκκλησάρισσα εκκλησία εκκλησίασμα εκκλησίδιο εκκλησίτσα εκκλησιά
εκκλησιάρισσα εκκλησιάρχης εκκλησιασμός εκκλησιαστήριο εκκλησιαστικός
εκκλησούλα εκκοκκισμός εκκοκκιστήριο εκκοκκιστήριον εκκολαπτήριο εκκρεμές
εκκρεμότης εκκρεμότητα εκκόκκιση εκκόλαψη εκκόλαψις εκκόλπωμα εκκύκλημα
εκλέκτωρ εκλέπτυνση εκλέπτυνσις εκλέρ εκλαΐκευση εκλαΐκευσις εκλαμπρότης
εκλαμπτήρας εκλαμψία εκλατόμηση εκλαϊκευτής εκλαϊκεύτρια εκλειπτική
εκλεκτικισμός εκλεκτικιστής εκλεκτικότης εκλεκτικότητα εκλεκτισμός εκλεξιμότης
εκλιπάρηση εκλογέας εκλογές εκλογή εκλογίκευση εκλογιμότης εκλογιμότητα
εκλογοδικείον εκλογολογία εκλογολόγος εκλογομάγειρας εκλογομάγειρος
εκλογομαγειρείο εκμάθηση εκμάθησις εκμέκ εκμίσθωση εκμίσθωσις εκμαίευση
εκμαυλίστρια εκμαυλισμός εκμαυλιστής εκμετάλλευση εκμετάλλευσις εκμεταλλευτής
εκμηδένιση εκμηδένισις εκμηδενισμός εκμηδενιστής εκμηχάνιση εκμηχανισμός
εκμισθώτρια εκμοντερνισμός εκμυζητής εκμυστήρευση εκμύζηση εκνέφωμα εκναυλωτής
εκναύλωση εκνευρισμός εκνεφωτής εκπίεση εκπίεσμα εκπαίδευση εκπαίδευσις
εκπαιδευτήριον εκπαιδευτής εκπαιδευτικοί εκπαιδευτικός εκπαιδεύτρια
εκπαραθύρωσις εκπαρθένευση εκπαρθένευσις εκπατρισμός εκπειρατισμός εκπεσμός
εκπλήρωσις εκπλειστηρίασμα εκπλειστηριασμός εκπλειστηριαστής εκπνοή εκποίηση
εκπολιτισμός εκπομπή εκπορθητής εκπροσώπευση εκπροσώπηση εκπροσώπησις
εκπρόσωπος τύπου εκπτώσεις εκπυρήνιση εκπυρσοκρότηση εκπυρσοκρότησις
εκπωματιστήρας εκπόνηση εκπόνησις εκπόρευση εκπόρευσις εκπόρθηση εκπόρθησις
εκπόρνευσις εκπώμαστρον εκράν εκρίζωση εκρίζωσις εκρηκτικό εκρηκτικότης
εκροή εκσκαφέας εκσκαφή εκσκαφεύς εκσλαβισμός εκσλαυισμός εκσπερμάτιση
εκσπερμάτωσις εκσπερματισμός εκσπλαχνισμός εκσπρέσο εκστρατεία εκστόμιση
εκσυγχρονισμός εκσφαλμάτωση εκσφενδονισμός εκσφενδόνιση εκσφενδόνισις εκτάριο
εκτέλεση εκτέλεσις εκτίμηση εκτίμησις εκτίναξη εκτίναξις εκτακτοσυστολή
εκταμίευσις εκτατικότητα εκταφή εκτελεστής εκτελεστικό εκτελωνίστρια
εκτελωνιστής εκτελώνιση εκτελώνισις εκτεχνίκευση εκτιμήτρια εκτιμητής
εκτοκισμός εκτομή εκτομίας εκτοξευτήρας εκτοξευτής εκτοπία εκτοπισμός
εκτράχυνση εκτράχυνσις εκτραχηλισμός εκτροπέας εκτροπή εκτροφέας εκτροφή
εκτροφείον εκτροχίαση εκτροχίασις εκτροχιασμός εκτροχιαστής εκτυπωτής εκτόνωση
εκτόξευσις εκτόπιση εκτόπισις εκτόπισμα εκτόπλασμα εκτύλιξη εκτύλιξις εκτύπωση
εκφασισμός εκφαυλισμός εκφοβισμός εκφοβιστής εκφορά εκφορτωτής εκφραστής
εκφυλισμός εκφυλόφατσα εκφωνήτρια εκφωνητής εκφόβηση εκφόβησις εκφόβιση
εκφόρτωσις εκφύλιση εκφύλισις εκφώνηση εκφώνησις εκχέρσωμα εκχέρσωση
εκχείλιση εκχείλισις εκχιονισμός εκχιονιστήρας εκχρηματισμός εκχριστιανισμός
εκχυλιστήρας εκχωμάτωση εκχωμάτωσις εκχωρήτρια εκχωρητήριο εκχωρητής εκχύλιση
εκχύλισμα εκχύμωση εκχύμωσις εκχώρηση εκχώρησις ελάτη ελάτι ελάττωμα ελάττωση
ελάφι ελάφρυνση ελάφρυνσις ελάφρωμα ελάχιστο κοινό πολλαπλάσιο ελέγκτρια
ελέφας ελίτ ελίτσα ελίφι ελαία ελαιογραφία ελαιοδιαχωριστήρας ελαιοδοχείο
ελαιοπαραγωγή ελαιοπαραγωγός ελαιοπιεστήριο ελαιοπολτός ελαιοπυρήνας
ελαιοτριβείο ελαιουργία ελαιουργείο ελαιουργός ελαιοφαγία ελαιοφυτεία
ελαιοχρωματιστής ελαιόδεντρο ελαιόθερμο ελαιόκαρπος ελαιόλαδο ελαιόμετρο
ελαιών ελαιώνας ελαμικά ελασματοποίηση ελασματοποίησις ελασματουργείο
ελαστίνη ελαστικό ελαστικότης ελαστικότητα ελαστογραφία ελατήριο
ελαττωματικότητα ελατόμελο ελατόπισσα ελαφάκι ελαφίδες ελαφίνα ελαφηβολία
ελαφοκρέας ελαφονησιώτης ελαφράδα ελαφρόνοια ελαφρόπετρα ελαφρότης ελαφρότητα
ελαφόπουλο ελαχιστοποίηση ελαχιστοποίησις ελβετίδα ελβετογερμανικά ελβετός
ελγίνεια ελεήτρα ελεήτρια ελεγεία ελεγείο ελεγκτήριο ελεγκτής ελεγχοσυνάρτηση
ελεεινολόγηση ελεεινολόγησις ελεεινότης ελεεινότητα ελεημοσύνη ελεητής
ελεμενταρισμός ελευθέρωση ελευθέρωσις ελευθερία ελευθεριά ελευθεριότης
ελευθεροκοινωνία ελευθεροπλοΐα ελευθεροστομία ελευθεροτέκτονας
ελευθεροτυπία ελευθεροφροσύνη ελευθερωτής ελευθερώτρια ελευσινιώτης ελεφαντάδα
ελεφαντίαση ελεφαντίασις ελεφαντίνα ελεφαντοκόκαλο ελεφαντοστούν ελεφαντοστό
ελεφαντόδοντο ελεφαντόδους ελεύθερο ελεύθερος ελεύθερος σκοπευτής ελιά ελιγμός
ελικοβακτηρίδιο ελικοδρόμιο ελικοπτερατζής ελικοπτεροφόρο ελικοπτερόσχημος
ελικόπτερο ελικόρρευμα ελιξήριο ελιξίριο ελιοκούκουτσο ελιτισμός ελιόδεντρο
ελκυσμός ελκυστήρας ελκυστής ελκυστικότητα ελλέβορος ελλαδίτης ελλανοδίκης
ελλειπτικότητα ελληνάδικο ελληνάρας ελληνίδα ελληνίς ελληναράς ελληνικά
ελληνική ελληνικούρα ελληνικό ελληνικός ελληνικότητα ελληνισμός ελληνιστής
ελληνοκεντρισμός ελληνολάτρης ελληνολατρία ελληνομάθεια ελληνομάχος
ελληνοπούλα ελληνοπρέπεια ελληνορθοδοξία ελληνοφοβία ελληνόπουλο ελλιμένιση
ελλογιμότητα ελλύχνιον ελμινθίαση ελμινθίασις ελονοσία ελπίδα ελπίς εμίρης
εμβάθυνσις εμβάπτιση εμβάς εμβέλεια εμβαδομέτρηση εμβαδομέτρησις εμβαδό
εμβαδόν εμβαπτισμός εμβατήριο εμβατίκια εμβληματολογία εμβοή εμβολή
εμβολιοθεραπεία εμβολιοθεραπευτική εμβολισμός εμβρίθεια εμβροντησία εμβροχή
εμβρυογονία εμβρυοθυλάκιο εμβρυοθύλακος εμβρυοκαρδία εμβρυοκτόνία εμβρυολογία
εμβρυοπλαστία εμβρυοσκόπηση εμβρυοτομή εμβρυοτόμος εμβρυουλκός εμβρυωρία
εμβόλιμο εμβόλιο εμετοδοχείο εμετοκαθαρτικά εμετολογία εμετός εμιγκρέ εμιγκρές
εμμέλεια εμμηναγωγό εμμηνοληξία εμμηνοπαυσία εμμηνορραγία εμμηνορρυσία
εμμηνόπαυση εμμηνόρροια εμμονή εμμονοκρατία εμορφάδα εμορφιά εμού εμπάθεια
εμπέδωση εμπέτασμα εμπαίκτης εμπαίκτρια εμπαιγμός εμπειρία εμπειρισμός
εμπειρογνώμονας εμπειρογνώμων εμπειροτεχνία εμπιστοσύνη εμπλεκόμενος εμπλοκή
εμπνευστής εμπνεύστρια εμπνοή εμποδίστρια εμποδισμός εμποδιστής εμποράκος
εμπορείο εμπορείον εμπορευματογνωσία εμπορευματοκιβωτιοφόρο εμπορευματοκιβώτιο
εμπορευματοποίηση εμπορευόμενος εμπορικάκι εμπορικολόγος εμπορικοποίηση
εμπορικόν εμπορικότης εμπορικότητα εμποριολογία εμποροδικείο εμποροκιβώτιο
εμποροκρατισμός εμπορομεσίτης εμποροπάζαρο εμποροπανήγυρη εμποροπανήγυρις
εμποροράπτης εμποροράφτης εμποροραφείο εμπορορράπτης εμπορορράφτης
εμποροϋπάλληλος εμποτισμός εμπρήστρια εμπρεσιονισμός εμπρεσιονιστής εμπρησμός
εμπριμέ εμπροσθοφυλακή εμπτυσμός εμπυρομαντεία εμπόδιο εμπόδιση εμπόδισμα
εμπόριο εμπόριον εμπόρισσα εμπότιση εμπότισις εμπύημα εμπύρευμα εμπύρωση
εμφάνισις εμφανιστήριο εμφανιστής εμφιάλωση εμφιάλωσις εμφιλοχωρώ εμφυτοκρατία
εμφύσημα εμφύσηση εμφύσησις εμφύτευμα εμφύτευση εμφύτευσις εμψυχωτής
εμψύχωση εμψύχωσις εμότζι ενάργεια ενάρθρωση ενάσκηση ενέδρα ενέργεια ενέργημα
ενέχυρον ενήλικας ενήλικος ενίδρυση ενίδρυσις ενίσχυση ενίσχυσις εναέριος
εναερίτης εναιώρημα εναλλάκτης εναλλαγή εναλφαβητισμός ενανθράκωση
ενανθρώπηση ενανθρώπιση ενανθρώπισις εναντίωση εναντιομορφία εναντιομορφισμός
εναντιότης εναντιότητα εναποθήκευση εναπόθεση εναρμόνιση ενασχόληση ενατένιση
ενδαγγειοχειρουργός ενδαρτηρεκτομή ενδείκτης ενδεικτικό ενδεκάγωνο ενδεκάδα
ενδεχομενικότητα ενδεχόμενο ενδημία ενδημικότητα ενδημισμός ενδημοεπιδημία
ενδιαφέρον ενδιαφέρουσα ενδοέκκριση ενδοβένθος ενδογένεια ενδογένεση ενδογαμία
ενδοδαπέδιο ενδοδοντία ενδοδοντιστής ενδοεπικοινωνία ενδοθήλιο ενδοθήλιον
ενδοθύλακας ενδοθύλακος ενδοιασμός ενδοκάρδιο ενδοκάρδιον ενδοκάρπιο
ενδοκαρδίτιδα ενδοκαρδίτις ενδοκρινικά ενδοκρινολογία ενδοκρινολόγος
ενδομήτριον ενδομεταφορά ενδομητρίτιδα ενδομητρίωση ενδοουρολογία
ενδοσκοπία ενδοσκόπηση ενδοσκόπησις ενδοσκόπιο ενδοσκόπιον ενδοσπέρμιο
ενδοσύνδεση ενδοτάξη ενδοτικότης ενδοτικότητα ενδοφάση ενδοφλεβίτιδα ενδοχώρα
ενδυμασία ενδυματολογία ενδυματολόγος ενδυνάμωση ενδυνάμωσις ενδυναμωτής
ενδόπλασμα ενδόρρηξη ενδόστρακο ενδώνυμο ενεδρευτής ενενηκοντούτης
ενενηντάδα ενενηντάρα ενενηντάρης ενενηνταριά ενεργειοκρατία ενεργητικό
ενεργητικότητα ενεργοποίηση ενεργοποίησις ενεργούμενο ενεσάκιας ενεστώτας
ενετοκρατία ενετός ενεχυρίαση ενεχυρίασις ενεχυριάστρια ενεχυριασμός
ενεχυροδανείστρια ενεχυροδανειστήριο ενεχυροδανειστήριον ενεχυροδανειστής
ενεχυρόγραφο ενζυμολογία ενζυμοπάθεια ενζωοτία ενηλικίωση ενηλικίωσις
ενηλικότης ενηλικότητα ενημέρωση ενημερότης ενημερότητα ενθάρρυνση ενθάρρυνσις
ενθουσίαση ενθουσίασις ενθουσιάστρια ενθουσιασμός ενθουσιαστής ενθρονισμός
ενθρόνισις ενθυλάκωση ενθυλάκωσις ενθύμημα ενθύμηση ενθύμησις ενθύμιο ενθύμιον
ενιαυσιότητα ενιαυτός ενικός ενισμός ενισχυτής εννεάγωνο εννιάγωνο εννιάμερα
εννιακοσαριά εννοιογράφημα εννοιοδιάγραμμα εννοιοκρατία εννοιολογία
εννοιολόγηση εννοιοπλασία εννοιοποίηση εννοιοσυσχέτιση εννοιοσύνολο
ενοίκιο ενοίκιον ενοικίαση ενοικίασις ενοικιάστρια ενοικιαστήριο
ενοικιαστής ενοικιοστάσιο ενοικιοστάσιον ενοποίηση ενορία ενορίτης ενορίτις
ενορχήστρωση ενορχήστρωσις ενορχηστρωτής ενοφθαλμία ενοφθαλμισμός ενοχή
ενούρηση ενούρησις ενσάκιση ενσάρκωση ενσάρκωσις ενσίρωση ενσακιστής
ενσιροδιανομέας ενσταντανέ ενστασιολογία ενστερνισμός ενσυναίσθηση
ενσφήνωση ενσωμάτωση εντέλεια ενταμίευση ενταμιευτής εντατική εντατικολόγος
ενταφίαση ενταφιασμός ενταφιαστής εντεκάδα εντεκάρι εντελέχεια εντελβάις
εντεραλγία εντερεκτομή εντεριώνη εντεροβακτήριο εντεροκήλη εντεροκινάση
εντεροπάθεια εντερορραγία εντεροσκόπηση εντεροτοξίνη εντερόκλυση εντερόκοκκος
εντευκτήριο εντεψίζης εντεψίζικα εντεψίζικο εντιμότητα εντοίχιση εντοιχισμός
εντολή εντολοδότης εντολοδότρια εντολοδόχος εντομή εντομοκτόνο εντομολογία
εντομοφαγία εντοπισμός εντοπιστής εντοπιότητα εντορμία εντούρο εντράδα εντριβή
εντροπία εντροπισμός εντρυφισμός εντρύφημα εντρύφηση εντρύφησις εντυπωσιασμός
εντόπισις εντόσθια εντόσθιο εντύπωση εντύπωσις ενυδάτωση ενυδάτωσις ενυδρίδα
ενυδρείο ενωμοτάρχης ενωμοτία ενωτίκευση ενωτικό ενωτικός ενόραση ενόρασις
ενότης ενότητα ενόχλημα ενόχληση ενύπνιο ενώτιο εξάγγελος εξάγνιση εξάγωνο
εξάδελφος εξάδερφος εξάεδρο εξάλειψη εξάμβλωμα εξάμβλωμα εξάμβλωση εξάμηνο
εξάνθημα εξάντας εξάντληση εξάπλωση εξάπλωσις εξάρα εξάρθρημα εξάρθρωση
εξάρι εξάρτημα εξάρτηση εξάρτιση εξάρτισις εξάρτυση εξάρτυσις εξάσκηση
εξάσφαιρο εξάτμιση εξάτμισις εξάχνωση εξάχνωσις εξάψαλμος εξάωρο εξέγερση
εξέλεγξη εξέλεγχος εξέλιξη εξέλκωση εξέταση εξέταστρα εξήγηση εξήντα εννιά
εξίδρωση εξίδρωσις εξίσωση εξαέρωση εξαέρωσις εξαήμερο εξαίρεση εξαίρεσις
εξαΰλωσις εξαγγελία εξαγιασμός εξαγνισμός εξαγορά εξαγρίωση εξαγρίωσις
εξαγωγή εξαγόμενο εξαγόραση εξαγόρασις εξαδέλφη εξαδέρφη εξαερισμός εξαεριστήρ
εξαερωτήρ εξαερωτήρας εξαετία εξαθλίωση εξαθλίωσις εξαιρετικότης
εξακολούθηση εξακολούθησις εξακοντισμός εξακοσαριά εξακρίβωση εξακόντιση
εξαλλαγή εξαλλοίωση εξαλλοσύνη εξαμερικανισμός εξαμηνία εξανάσταση εξανέμιση
εξανδραποδισμός εξανθράκωση εξανθρωπισμός εξαντλητικότητα εξαπάτηση
εξαποδός εξαποδώ εξαποστειλάριο εξαπτέρυγα εξαπόλυση εξαρίτης εξαργύρωση
εξαρμογή εξαρτία εξαρτημένος εξαρχάτο εξαρχία εξαρχαϊσμός εξασθένηση
εξασθένιση εξασθένισις εξαστισμός εξασφάλιση εξασφάλισις εξατμιστής
εξατομίκευσις εξαφάνιση εξαφάνισις εξαφανισμός εξαχρείωση εξαχρείωσις
εξεδρόκανο εξειδίκευση εξεικόνιση εξελικτισμός εξελιξιαρχία εξελιξικρατία
εξερέθιση εξεργασία εξερευνήτρια εξερευνητής εξερεύνηση εξετάστρια εξεταστήριο
εξευγένιση εξευγενισμός εξευμένιση εξευμενισμός εξευρωπαϊσμός εξευτελισμός
εξηγητής εξηκονταετία εξηκοντούτης εξηκοντούτις εξηλεκτρισμός εξημέρωμα
εξημέρωσις εξηντάδα εξηντάρα εξηντάρης εξηνταβελόνης εξηνταδικός εξηνταριά
εξιδανίκευσις εξιλέωση εξιλέωσις εξιλασμός εξισλαμισμός εξισορρόπηση
εξιστόρηση εξιτήριο εξιχνίαση εξιχνίασις εξιχνιάστρια εξιχνιαστής εξοίδημα
εξοίδησις εξοβελισμός εξοδολόγιο εξοδούμπα εξοδούχος εξοικείωση εξοικείωσις
εξοικονόμησις εξολίσθημα εξολίσθηση εξολκέας εξολοθρευτής εξολοθρεύτρα
εξολόθρευση εξολόθρευσις εξομάλιση εξομάλισις εξομάλυνση εξομάλυνσις εξομοίωση
εξομολογητήριο εξομολογητής εξομολόγηση εξομολόγησις εξομολόγος εξονειδισμός
εξονύχιση εξονύχισις εξοπλισμός εξορία εξορισμός εξορκίστρια εξορκισμός
εξοστρακισμός εξουδετέρωση εξουδετέρωσις εξουθένωση εξουσία εξουσιάστρα
εξουσιαστής εξουσιοδότηση εξουσιομανία εξοφθαλμία εξοφλητήριο εξοχή εξοχικό
εξπέρ εξπρές εξπρεσιονισμός εξπρεσιονιστής εξτρά εξτρέ εξτρεμίστρια
εξτρεμισμός εξτρεμιστής εξυγίανση εξυπηρέτηση εξυπηρετητής εξυπνάδα εξυπνάκιας
εξυπνοπούλι εξωβιολογία εξωγήινος εξωγαμία εξωγναθία εξωεδαφικότητα εξωθητήρας
εξωθύλακος εξωκκλήσι εξωκλήσι εξωκοσμικός εξωμοσία εξωμότης εξωμότρια
εξωπολιτική εξωραϊσμός εξωστρέφεια εξωσωματική εξωτερίκευση εξωτερίκευσις
εξωτισμός εξωφρενισμός εξόγκωμα εξόγκωση εξόγκωσις εξόντωση εξόντωσις εξόπλιση
εξόργιση εξόργισις εξόριση εξόρκιση εξόρμηση εξόρμησις εξόρυξη εξόρυξις
εξύβριση εξύμνηση εξύφανση εξύψωση εξώδερμα εξώθηση εξώθησις εξώθυρα εξώκοσμος
εξώνυμο εξώπλατο εξώπορτα εξώπροικα εξώραφο εξώστης εξώσφαιρα εξώφυλλο εορτή
εορταστής εορτοδάνειο εορτολόγιο επάγγελμα επάλειμμα επάλειψη επάνδρωση
επάνοδος επάρκεια επάρτης επέ επέκεινα επέκταση επέκτασις επέλαση επέλασις
επέλευσις επέμβαση επέμβασις επένδυμα επένδυση επένδυσις επέτειος επήρεια
επίατρος επίβλεψη επίβλεψις επίγευση επίγνωση επίγνωσις επίγονος επίγραμμα
επίδειξις επίδεση επίδεσις επίδεσμος επίδομα επίδοση επίδοσις επίδραση
επίθεμα επίθεση επίθεσις επίθετο επίθημα επίκανθος επίκεντρο επίκληση επίκλυση
επίκρανο επίκριση επίκρουση επίκρουσις επίκυψη επίκυψις επίλαρχος επίλημμα
επίλυση επίλυσις επίμετρο επίναυλος επίνειο επίνευση επίνευσις επίνοια
επίπαση επίπασις επίπασμα επίπεδο επίπλευση επίπλευσις επίπληξη επίπληξις
επίπλους επίπλωση επίπλωσις επίπτωση επίπτωσις επίρρημα επίρρωση επίρρωσις
επίσκεψη επίσκοπος επίσπευση επίσπευσις επίσταξη επίσταξις επίστεγο επίστεψη
επίστρατος επίστρωμα επίστρωση επίσχεση επίσχεσις επίταξη επίταξις επίταση
επίτευγμα επίτευξη επίτευξις επίτοκος επίτροπος επίφαση επίφυση επίφυσις
επίχριση επίχρισις επίχρισμα επίχωμα επίχωση επίψαυση επίψαυσις επαΐων επαίτης
επαγγελματίας επαγγελματικότητα επαγγελματισμός επαγγελματοβιοτέχνης
επαγρύπνησις επαγωγέας επαγωγή επαγωγισμός επαινέτης επαιτεία επακολουθία
επακολούθηση επακολούθησις επακούμβηση επακόλουθο επαλήθευση επαλήθευσις
επαμεινώνδας επαμφοτερισμός επανάκτηση επανάκτησις επανάληψη επανάληψις
επανάσταση επανάστασις επανάχρηση επανέκδοση επανέκδοσις επανένταξη επανένωση
επανίδρυσις επαναγγείωση επαναγορά επαναγωγή επαναδίπλωση επαναδίπλωσις
επαναδιαπραγμάτευση επαναδιασταύρωση επαναδιατύπωση επαναδραστηριοποίηση
επαναθεσμοποίηση επαναιμάτωση επανακανονικοποίηση επανακεφαλαιοποίηση
επαναλήπτης επαναλειτουργία επαναλογισμός επαναμεταβίβαση επανανάκτηση
επαναπατρισμός επαναπληροφόρηση επαναπροκήρυξη επαναπροσέλκυση
επαναπρόσληψη επανασήμανση επανασίτιση επανασημασιολόγηση επαναστάτης
επαναστάτισσα επαναστάτρια επαναστατικότης επαναστατικότητα επαναστατισμός
επαναστόχευση επανασύνδεση επανασύνδεσις επανασύνθεση επανατιμολόγηση
επαναφορά επαναφόρτωση επαναχρησιμοποίηση επανεγκατάσταση επανεγχείρηση
επανεκβιομηχάνιση επανεκκίνηση επανεκλογή επανεκλογιμότητα επανεκμίσθωση
επανεμφάνιση επανεμφάνισις επανενίσχυση επανενεργοποίηση επανεξέταση
επανεξαγωγή επανεπέμβαση επανεπίχωση επανεπικύρωση επανυγροποίηση
επανωφόρι επανωφόριον επανόρθωση επανόρθωσις επαργύρωση επαργύρωσις επαρχία
επαρχείον επαρχιωτισμός επαρχιώτης επαρχιώτις επαρχιώτισσα επασφαλιστήριο
επαύξηση επαύξησις επείγον επεισόδιο επεισόδιον επεκτασιμότητα επεκτατισμός
επεμβατισμός επενέργεια επενδυτής επενδύτης επενδύτρια επεξήγηση επεξήγησις
επεξεργαστής επερώτηση επερώτησις επετηρίδα επετηρίς επευφημία επηρεασμός
επιβάρυνση επιβάρυνσις επιβάτης επιβάτιδα επιβάτις επιβάτισσα επιβάτρια
επιβήτωρ επιβίβαση επιβίβασις επιβίωση επιβίωσις επιβατάμαξα επιβατηγό
επιβεβαίωσις επιβιβασμός επιβλητικότης επιβλητικότητα επιβοήθεια επιβοήθημα
επιβουλή επιβράβευση επιβράβευσις επιβράδυνση επιβράδυνσις επιβραδυντής
επιγαμία επιγενόμενοι επιγκενίδα επιγλωττίδα επιγνώμων επιγονάτιο επιγονατίδα
επιγονισμός επιγραμματοποιός επιγραφή επιγραφική επιγραφολόγος επιγραφοποιία
επιδίκαση επιδίκασις επιδίωξη επιδίωξις επιδαψίλευση επιδαψίλευσις επιδείνωση
επιδεικτισμός επιδειξίας επιδειξιμανία επιδεκτικότης επιδεκτικότητα
επιδεξιότης επιδεξιότητα επιδερμίδα επιδερμίς επιδερμικότητα επιδεσμολογία
επιδημητικά επιδημιολογία επιδημιολόγος επιδιαιτησία επιδιαιτητής επιδιασκόπιο
επιδιδυμίς επιδιδυμίτιδα επιδιδυμίτις επιδικία επιδιορθωτής επιδιορθώτρια
επιδιόρθωση επιδιόρθωσις επιδοκιμασία επιδομή επιδοματούχος επιδοτήριο
επιδρομή επιδόρπια επιδόρπιο επιδότηση επιδότησις επιείκεια επιζήτηση
επιζωοτία επιθήλιο επιθήλιον επιθαλάμιο επιθετικός επιθετικότης επιθετικότητα
επιθεωρησιογράφος επιθεωρητής επιθεώρηση επιθεώρησις επιθυμία επιθόρυβος
επικάλυψη επικάλυψις επικάρδιο επικάρπιο επικέντρωση επικήδειος επικήρυξη
επικαθορισμός επικαιροποίηση επικαιρότης επικαιρότητα επικαλεστής επικαρπία
επικασσιτέρωση επικασσιτερωτής επικαταλλαγή επικεφαλής επικεφαλίδα
επικοινωνία επικοινωνιολόγος επικοινώνηση επικονίαση επικονίασις επικονιασμός
επικοντισμός επικοντιστής επικουρία επικουρισμός επικούρειοι επικράτεια
επικράτησις επικρίτρια επικριτής επικρουστήρας επικρότηση επικτηνίατρος
επικόλληση επικόλλησις επικόπανο επικύρωση επικύρωσις επιλάθευση επιλαρχία
επιλεκτικότητα επιλεξιμότητα επιληψία επιλογέας επιλογή επιλοχίας επιλοχαγός
επιμέτρηση επιμέτρησις επιμήδιο επιμήθεια επιμήκυνση επιμήκυνσις επιμήριο
επιμαρτυρία επιμειξία επιμελήτρια επιμελητήριο επιμελητής επιμελητεία
επιμετάλλωση επιμετάλλωσις επιμεταλλωτής επιμετρητής επιμηθέας επιμηθεύς
επιμονή επιμορφισμός επιμόλυνση επιμόλυνσις επιμόρφωση επιμόρφωσις επιμύθιο
επινεφρίδια επινεφρίδιο επινικέλωση επινικέλωσις επινοήτρια επινοητής
επινοητικότητα επινόημα επινόηση επινόησις επιορκία επιούσα επιούσιος
επιπεδοποίηση επιπεδότητα επιπεφυκίτιδα επιπεφυκίτις επιπεφυκώς επιπλάδικο
επιπλοκή επιπλοποιία επιπλοποιείο επιπλοποιός επιπλόο επιπολή επιπολαιότης
επιπολασμός επιπραγματικότητα επιπωμάτιση επιπωμάτισις επιπωματισμός επιπόλαση
επιρροή επισήμανση επισήμανσις επισίτιση επισείων επισεσυρμένη επισημοποίηση
επισημότης επισημότητα επισιτισμός επισκέπτης επισκέπτρια επισκίαση
επισκεπτήριο επισκευάστρια επισκευή επισκευαστής επισκεψιμότητα επισκεψούλα
επισκοπάτο επισκοπή επισκοπεία επισκοπείο επισκοπικό επισκόπηση επισκόπησις
επισκότιση επισμηνίας επισμηναγός επιστάτης επιστάτις επιστάτισσα επιστάτρια
επιστέγασμα επιστήθιο επιστήλιο επιστήμη επιστήμονας επισταλία επιστασία
επιστημολογία επιστημονάρχης επιστημονισμός επιστημοσύνη επιστημόνισσα
επιστολάριο επιστολή επιστολογράφος επιστολογραφία επιστράτευση επιστράτευσις
επιστροφή επιστρόφιο επιστόμιο επιστύλιο επισυναλλαγματική επισφάλεια
επισφράγισις επισφράγισμα επισύμπαν επισύναψη επισώρευση επισώρευσις
επιτάχυνσις επιτέλεση επιτέλεσις επιτήδευμα επιτήδευση επιτήδευσις επιτήρηση
επιτίμηση επιτίμησις επιτίμιο επιταγή επιταχυνσιογράφος επιταχυνσιόμετρο
επιτελάρχης επιτελής επιτελείο επιτηδειότητα επιτηδευματίας επιτηρήτρια
επιτολή επιτομή επιτονισμός επιτραπέζιο επιτραχήλιο επιτρεπτότητα
επιτροπή επιτροπεία επιτροπείο επιτρόπευση επιτρόπευσις επιτυχία επιτόκιο
επιφαινομενολογία επιφαινόμενο επιφοίτηση επιφοίτησις επιφυλακή
επιφυλακτικότητα επιφυλλίδα επιφυλλίς επιφυλλιδογράφος επιφυλλιδογραφία
επιφόρτιση επιφόρτισις επιφόρτωση επιφύλαξη επιφύλαξις επιφώνημα επιφώνηση
επιφώτιση επιχάλκωση επιχάλκωσις επιχάνδρωση επιχείρημα επιχείρηση επιχείρησις
επιχειρηματικότης επιχειρηματικότητα επιχειρηματολογία επιχειροτονία
επιχορήγηση επιχορήγησις επιχρυσωτής επιχρωμίωση επιχρωμίωσις επιχρωματισμός
επιχρύσωση επιχρύσωσις επιχωμάτωση επιχωμάτωσις επιψήφιση επιψήφισις
εποίκηση εποίκησις εποίκιση εποίκισις εποικισμός εποικοδομή εποικοδόμημα
εποικοδόμησις επομένη επονομασία εποξείδιο εποποιία εποπτεία εποστρακίζω
εποχή εποχικότητα επούλωση επούλωσις επτάγωνο επτάδα επτάδυμα επτάμηνο
επτάστιχο επταέτις επταήμερο επταετία επωαστήρας επωαστής επωδή επωδός επωμίδα
επωνυμία επωτίδα επόπτευση επόπτευσις επόπτης επόπτρια επώαση επώασις επώνυμο
εράστρια ερέα ερέβινθος ερέθισμα ερέτης ερήμωση ερήμωσις ερίκι ερίφης ερίφι
ερίφιον ερίφισσα εραλδική ερανίστρια ερανισμός ερανιστής ερασιτέχνης
ερασιτέχνις ερασιτέχνισσα ερασιτεχνία ερασιτεχνισμός ερασμιότης ερασμιότητα
εργάτης εργάτρια εργένης εργένισσα εργαλείο εργαλειοδοτήριο εργαλειοθήκη
εργαλειοποίηση εργασία εργασιοθεραπεία εργασιοκρατία εργασιολογία εργασιομανία
εργαστήριο εργαστήριον εργατιά εργατικά εργατικότης εργατικότητα εργατοδικείο
εργατοκρατία εργατολόγος εργατοπατέρας εργατοπατερισμός εργατοτεχνίτης
εργατοώρα εργατόκρανο εργενιλίκι εργογραφία εργοδηγός εργοδικότητα εργοδοσία
εργοδότισσα εργοδότρια εργοθεραπεία εργοθεραπευτής εργολάβος εργολήπτης
εργολαβία εργολαβικά εργοληψία εργομετρία εργονομία εργονομικότητα
εργοστάσιο εργοστασιάρχης εργοτάξιο εργοφυσιολόγος εργόμετρο εργόχειρο ερείκη
ερείπωση ερείπωσις ερεθισμός ερεθιστικότης ερεθιστικότητα ερειπιώνας
ερεισίνωτον ερευγμός ερευνήτρια ερευνητής ερευνητικότης ερευνητικότητα ερημία
ερημίτις ερημίτισσα ερημητήριο ερημιά ερημοδικία ερημοκλήσι ερημοκλησιά
ερημονησίδα ερημοποίηση ερημοσπίτης ερημόνησο ερημόνησος ερημότοπος ερημόφιδο
εριουργία εριουργείο εριστικότητα ερμάρι ερμάριο ερμάριον ερμάτιση ερμάτισμα
ερμίνα ερματισμός ερμαφροδισία ερμαϊσμός ερμηνεία ερμηνευτής ερμηνευτική
ερμηνεύτρια ερμηνισμός ερμητικότης ερμητικότητα ερμητισμός ερμιά ερπετολογία
ερπυσμός ερπυστριοφόρο ερπύστρια ερτζιανά ερυγή ερυθρά ερυθρίαση ερυθρίασις
ερυθραιμία ερυθρελάτη ερυθροδιόλη ερυθροκύτταρο ερυθροποίηση ερυθροποιητίνη
ερυθροσταυρίτισσα ερυθρόδερμη ερυθρόδερμος ερυθρότης ερυθρότητα ερυσίβη
ερφαφροδιτισμός ερχομός ερωδιός ερωμένη ερωμένος ερωταπόκριση ερωταπόκρισις
ερωτηματοθέτης ερωτηματοθέτηση ερωτηματολόγιο ερωτιδέας ερωτιδεύς ερωτισμός
ερωτομανία ερωτοτροπία ερωτόλογα ερωτύλος ερύθημα ερώτηση ερώτησις εσάνς
εσατζής εσθήτα εσθονικά εσμός εσοδεία εσοδιαστής εσοχή εσπέρα εσπέρας
εσπερία εσπερίδα εσπερίς εσπεραντιστής εσπεριδοειδή εσπρέσο εστέρας εστέρες
εστία εστίασις εστιάτορας εστιάτωρ εστιατοριάκι εστιατόριο εσχάρα εσχάρωση
εσχατολογία εσχατόγηρος εσωστρέφεια εσωτερίκευση εσωτερικοποίηση
εσωτερικό εσωτερικότης εσωτερικότητα εσωτερισμός εσωτρόπιο εσώρουχο εσώφυλλο
εταίρος εταζέρα εταιρία εταιρεία εταιρισμός εταλονάζ εταλονέρ ετεραρχία
ετεροίωσις ετεροαπασχόληση ετεροβίωτος ετεροβιωματικός ετεροβιωματικότητα
ετερογένεια ετερογένεση ετερογαμία ετερογενές ετερογονία ετεροδημότης
ετεροδημότισσα ετεροδικία ετεροδοξία ετεροεπαγγελματίας ετεροκαθορισμός
ετερομέρεια ετερομορφία ετερομορφισμός ετερονομία ετεροπροσδιορισμός
ετεροσκεδαστικότητα ετεροσωματικός ετεροφυλία ετεροφυλοφιλία ετεροφυλόφιλος
ετεροχρονισμός ετερόκλιτο ετερότης ετερότητα ετησίαι ετιά ετικέτα ετικετάρισμα
ετοιμασία ετοιματζίδικο ετοιμολογία ετοιμότης ετοιμότητα ετρουσκικά ετρούσκος
ετυμηγορία ετυμολογία ετυμολόγημα ετυμολόγηση ετυμολόγος ευήθεια ευαγγέλιο
ευαγγελισμός ευαγγελιστής ευαισθησία ευαισθητοποίηση ευαισθητοποίησις
ευαρέσκεια ευαρέστηση ευαρέστησις ευβοιώτης ευβοιώτισσα ευβουλία ευβραδύπορα
ευγενής ευγενικότητα ευγευσία ευγηρία ευγλωττία ευγνωμοσύνη ευγονία ευγονική
ευγραμμία ευδία ευδαίμονας ευδαιμονία ευδαιμονίστρια ευδαιμονισμός
ευδιαθεσία ευδιαλυτότητα ευδοκία ευδοκίμηση ευδοκίμησις ευδόκηση ευελιξία
ευεργέτημα ευεργέτης ευεργέτιδα ευεργέτις ευεργέτισσα ευεργέτρια ευεργεσία
ευεργετικότητα ευερεθιστότης ευερεθιστότητα ευετηρία ευζωία ευζωνάκι ευζωνικό
ευημερία ευθέτησις ευθανασία ευθεία ευθιξία ευθραυστότης ευθραυστότητα
ευθυγράμμιση ευθυγράμμισις ευθυδικία ευθυκρισία ευθυμία ευθυμογράφημα
ευθυμογραφία ευθυμολογία ευθυμολόγημα ευθυμολόγος ευθυνοφοβία ευθύαυλος ευθύνη
ευθύτητα ευκάλυπτος ευκή ευκαιρία ευκαλυπτέλαιο ευκαμψία ευκινησία ευκοίλια
ευκοιλιότης ευκοιλιότητα ευκολάκι ευκολία ευκοσμία ευκρίνεια ευκρασία ευκτική
ευλαλία ευληπτότητα ευλογία ευλογητάρια ευλογητάριο ευλογιά ευλογοφάνεια
ευλόγηση ευλόγησις ευλύγιστος ευμάθεια ευμάρεια ευμένεια ευμεταβλησία
ευνή ευνήκτης ευνοιοκρατία ευνομία ευνουχισμός ευνούχος ευορκία ευοσμία
ευπατρίδης ευπείθεια ευπεψία ευπιστία ευποιία ευπορία ευπρέπεια ευπραγία
ευπροσηγορία ευπώλητο ευρέτης ευραπηλιώτης ευρειαγγεία ευρεσιτέχνης
ευρεσιτυχία ευρετήριο ευρετηρίαση ευρετηριασμός ευρετική ευρηματικότητα
ευρυαγγεία ευρυεκπομπή ευρυθμία ευρυμάθεια ευρυχωρία ευρωαστυνομία ευρωβουλή
ευρωβουλευτίνα ευρωβουλεύτρια ευρωδίπλωμα ευρωδιαβατήριο ευρωδολάριο
ευρωεπιταγή ευρωεταίρος ευρωκοινοβουλευτής ευρωκοινοβούλιο ευρωκοινοβούλιον
ευρωκομουνιστής ευρωκράτης ευρωλιμένας ευρωναζί ευρωνόμισμα ευρωομολογία
ευρωπαΐστρια ευρωπαία ευρωπαίος ευρωπαϊσμός ευρωπαϊστής ευρωπύραυλος
ευρωσκεπτικισμός ευρωσκεπτικιστής ευρωστία ευρωστρατός ευρωτίαση ευρωτίασις
ευρωχώρος ευρύτης ευρύτητα ευρώ ευρώπιο ευρώπιον ευρώπουλο ευρώς ευσέβεια
ευσεβισμός ευσπλαχνία ευστάθεια ευστατισμός ευστοχία ευστροφία ευσυγκινησία
ευσχημοσύνη ευτέλεια ευταξία ευτελισμός ευτηξία ευτολμία ευτονία ευτρεπισμός
ευτροφισμός ευτυχία ευτύχημα ευφημισμός ευφλογιστία ευφορία ευφράδεια
ευφυΐα ευφυολογία ευφυολόγημα ευφυολόγος ευφωνία ευφώνιο ευχέλαιο ευχέρεια
ευχέτις ευχή ευχαρίστηση ευχαριστία ευχαριστώ ευχολόγιο ευχρηστία ευψυχία
ευωδιά ευωχία ευόδωση ευόδωσις εφάπαξ εφάπλωμα εφέ εφέδρανο εφένδης εφέντης
εφήβαιο εφίδρωση εφίδρωσις εφίππιον εφαλτήριο εφαπλωματοποιός εφαπτομένη
εφαρμοσμένα μαθηματικά εφαρμοστήριο εφαρμοστής εφαψίας εφεδρεία εφεκτικότητα
εφελκίς εφελκυσμός εφετείο εφευρέτης εφευρέτρια εφευρετικότητα εφεύρεση
εφηβεία εφηλίδα εφηλίς εφημέριος εφημερία εφημερίδα εφημεριδογράφος
εφημεριδοπώλης εφημεριδοπώλισσα εφημεριδοφάγος εφησυχασμός εφησύχαση εφιάλτης
εφικτότητα εφιός εφκιός εφοδιασμός εφοδιαστική εφοδιοπομπή εφοπλίστρια
εφοπλιστής εφοπλιστίνα εφορία εφορεία εφτάδα εφτάδυμα εφτάζυμο εφτάμηνο εφτάρι
εφτάστιχο εφταήμερο εφταετία εφτακοσαριά εφταμηνίτης εφταμηνίτισσα εφταπλέτο
εφυάλωση εφφέ εφόδιο εφόδιον εφόρμηση εφόρμησις εχέγγυο εχίνος εχεμύθεια
εχθρά εχθρικότητα εχθροπάθεια εχθροπραξία εχθρός εχθρότητα εχινοκοκκίαση
εχινόκοκκος εχταγή εχτρός εψιδίνη εωθινό εύδρομο εύελπις εύζωνας εύζωνος
εύνοια εύρεση εύρεσις εύρετρα εύρημα εύρυνση εύσημο εύσημον εἰρήνη ζάβαλης
ζάλισμα ζάλο ζάντα ζάπι ζάπινγκ ζάρα ζάρι ζάρωμα ζάφτι ζάχαρη ζάχαρις ζάχαρο
ζέβρος ζέον ζέπελιν ζέρμπερα ζέρσεϊ ζέρσεϋ ζέση ζέστα ζέσταμα ζέστη ζέφυρος
ζήλεια ζήλια ζήλος ζήση ζήτημα ζήτηση ζήτουλας ζίζιρος ζίλι ζίνια ζίννια
ζαΐφης ζαβάδα ζαβαλής ζαβαλίδικο ζαβαλού ζαβαρακατρανέμια ζαβλάκωμα
ζαβολιά ζαβομάρα ζαγάρι ζαγαρομάτης ζαζάκι ζακέτα ζακετάκι ζακετούλα
ζακόνι ζαλάδα ζαλίκα ζαλίκι ζαλιά ζαμάνι ζαμάνια ζαμανφουτίστας ζαμανφουτισμός
ζαμανφουτιστικός ζαμενής ο μαύρος ζαμενής της ρόδου ζαμπάκι ζαμπίτης
ζαμπαράς ζαμπονοπατατοκροκέτα ζαμπονοτυρόπιτα ζαμπονόπιτα ζαμπόν ζαμπόνια
ζαρίφης ζαρίφισσα ζαργάνα ζαρζαβάτι ζαρζαβατικό ζαριά ζαριφλίκι ζαρκάδι
ζαρταλούδι ζαρτιέρα ζαρωματιά ζατρίκιο ζατρίκιον ζαφείρι ζαφειρόπετρα ζαφορά
ζαχάρωμα ζαχαράσβεστος ζαχαρένια ζαχαρί ζαχαρίνη ζαχαριέρα ζαχαροδιάλυμα
ζαχαροκάλαμο ζαχαροκεφιρόκοκκος ζαχαρομάζα ζαχαρομύκητας ζαχαρονερόκοκκος
ζαχαροπλάστης ζαχαροπλάστισσα ζαχαροπλάστρια ζαχαροπλαστείο ζαχαροπλαστική
ζαχαρουργείο ζαχαρωτό ζαχαρόζη ζαχαρόνερο ζαχαρόπιτα ζαχαρότευτλο ζαϊφλίκι
ζεβζεκιά ζεδοάρειο ζεια ζελέ ζελές ζελατίνα ζελατίνη ζελεδάκι ζεμάν φου
ζεμανφουτίστας ζεμανφουτίστρια ζεμανφουτισμός ζεμανφουτιστικός ζεμπίλι
ζεν πρεμιέ ζενίθ ζερβοκουτάλα ζερβοκουτάλας ζερζεβούλης ζερνεκαδές ζερό
ζεσεοσκόπιο ζεσεόμετρο ζεστασιά ζεστοκόπημα ζεστούλα ζεστό ζετέ ζευγάρι
ζευγάρωμα ζευγάς ζευγίτης ζευγαράκι ζευγαρονήσι ζευγηλάτης ζευγηλατρίς
ζευγολάτισσα ζευγολατειό ζευγολατιό ζευγού ζευγόλουρο ζευκτήρ ζευκτήρας
ζεόλιθος ζεύγλα ζεύγμα ζεύγος ζεύκι ζεύξη ζηλαδέρφια ζηλιαρόγατα ζηλιαρόγατος
ζηλοφθονία ζηλωτής ζηλώτρια ζημία ζημιά ζην ζητακισμός ζητεία ζητητής ζητιάνα
ζητιανάκι ζητιανιά ζητούμενο ζητωκραυγή ζιαμέτι ζιαφέτι ζιβάγκο ζιβέτ ζιβανία
ζιγκ-ζαγκ ζιγκλέρ ζιγκλεράκι ζιγκολέτα ζιγκολό ζιγκουράτ ζιζάνιο ζιζανιοκτόνο
ζιλέ ζιλές ζιλεδάκι ζιμπελίνα ζιμπούλι ζιπ κιλότ ζιρκόνιο ζιτούνι ζιφιός ζλάπι
ζνίχι ζο ζογκλέρ ζολότα ζορζέτα ζοριλίκι ζορμπάς ζορμπαλής ζορμπαλίκι ζουάβος
ζουζουνάκι ζουζουνίτσα ζουζουνιά ζουζούνα ζουζούνι ζουζούνισμα ζουλάπι
ζουλού ζουλού ζουμ ζουμί ζουμπάς ζουμπουλάκι ζουμπούλι ζουνάρι ζουρίδα
ζουρλοκαμπέρω ζουρλομανδύας ζουρλοπαντιέρα ζουρνάς ζουφάδα ζοφερότητα ζοχάδα
ζοχαδιάρης ζοχός ζούγκλα ζούδι ζούδος ζούζουλο ζούλα ζούληγμα ζούλημα ζούλια
ζούμπερο ζούπηγμα ζούπισμα ζούρα ζούρια ζούριασμα ζούρλα ζούρλια ζυγαριά ζυγιά
ζυγιστής ζυγιστικά ζυγολούρι ζυγολόγιο ζυγοστάθμιση ζυγοταινία ζυγούρι
ζυγός ζυθεστιατόριο ζυθοζύμη ζυθοποιία ζυθοποιείο ζυθοποιός ζυθοποσία
ζυθοπώλης ζυμάρι ζυμαράκι ζυμαρικό ζυμοκαλλιέργεια ζυμομυκητίαση ζυμομύκητας
ζυμωτήριο ζυμωτής ζυμωτικά ζυμώτρα ζυμώτρια ζυφτήρι ζω ζωάκι ζωάνθρωπος ζωάριο
ζωέμπορας ζωέμπορος ζωή ζωανθρωπία ζωγράφισμα ζωγράφος ζωγραφιά ζωγραφική
ζωηράδα ζωηρότητα ζωμάρι ζωμός ζωνάρι ζωνάτο ζωντάνεμα ζωντάνια ζωντανό
ζωντοχήρος ζωντόβολο ζωοαγορά ζωοανθρωπονόσος ζωοβένθος ζωογεωγραφία ζωογόνηση
ζωοδότρα ζωοδόχος πηγή ζωοθεραπευτική ζωοθεϊσμός ζωοκλέφτης ζωοκλοπή ζωοκομία
ζωολάτρης ζωολάτρισσα ζωολατρία ζωολογία ζωολόγος ζωομορφισμός ζωονομία
ζωοπανήγυρη ζωοπλαγκτόν ζωοποίηση ζωοτεχνία ζωοτεχνικός ζωοτοκία ζωοτομία
ζωοτροφή ζωοτροφία ζωοτροφείο ζωοτρόφος ζωοφαγία ζωοφιλία ζωοφοβία ζωοφυσική
ζωοχημεία ζωοψία ζωούλα ζωροαστρισμός ζωστήρα ζωστήρας ζωτικότητα ζωφόρος
ζωόγλοια ζωύφιο ζόλος ζόμπι ζόρε ζόρι ζόρισμα ζόρκος ζόφος ζύγι ζύγιασμα
ζύγισμα ζύγωμα ζύθος ζύμη ζύμωμα ζύμωση ζώδιο ζώμη ζώνη ζώο ζώον ζώπυρο ζώσιμο
ηγέτης ηγέτιδα ηγήτορας ηγεμονία ηγεμονίδα ηγεμονίσκος ηγεμονικότητα
ηγεμόνας ηγεμόνευση ηγερία ηγεσία ηγετίσκος ηγουμένη ηγουμένισσα ηγουμενία
ηγουμενιάρης ηγουμενιτσιώτης ηγουμενοσυμβούλιο ηγούμενος ηδονή ηδονίστρια
ηδονιστής ηδονοβλεψία ηδονοβλεψίας ηδονοθήρας ηδονολάτρης ηδονολάτρισσα
ηδυλογία ηδυπάθεια ηδύοσμος ηδύποτο ηδύτητα ηθική ηθικοδιδάσκαλος ηθικοκρατία
ηθικολόγος ηθικοποίηση ηθικό ηθικότητα ηθμοσωλήνες ηθμός ηθογράφημα ηθογράφηση
ηθογραφία ηθολογία ηθολόγος ηθοποιία ηθοποιός ηλάγρα ηλέκτριση ηλίανθος ηλίαση
ηλακάτη ηλεκτράμαξα ηλεκτρικός ηλεκτρισμός ηλεκτροακουστική ηλεκτροακτινολογία
ηλεκτροαμφιβληστροειδογραφία ηλεκτροβιογένεση ηλεκτροβιολογία ηλεκτρογεννήτρια
ηλεκτροδυναμική ηλεκτροδυναμόμετρο ηλεκτροδότηση ηλεκτροεγκεφαλογράφημα
ηλεκτροεγκεφαλογραφία ηλεκτροθεραπεία ηλεκτροκάμινος ηλεκτροκίνηση
ηλεκτροκαρδιογράφος ηλεκτροκαρδιογραφία ηλεκτροκεφαλογράφημα ηλεκτροκινητήρας
ηλεκτροληψία ηλεκτρολογία ηλεκτρολογείο ηλεκτρολόγος ηλεκτρολύτης
ηλεκτροματσάκονο ηλεκτρομεταλλουργία ηλεκτρομετρία ηλεκτρομηχανή
ηλεκτρομηχανικός ηλεκτρομυογράφημα ηλεκτρομυογραφία ηλεκτρονική
ηλεκτρονικός ηλεκτρονιοβόλτ ηλεκτρονόμος ηλεκτροπαραγωγή ηλεκτροπληξία
ηλεκτροπόρωση ηλεκτροσκόπιο ηλεκτροστατική ηλεκτροσυγκολλητής
ηλεκτροσυσσωρευτής ηλεκτροσόκ ηλεκτροσύντηξη ηλεκτροτεχνία ηλεκτροτεχνίτης
ηλεκτροφωταύγεια ηλεκτροφωτισμός ηλεκτροφόρηση ηλεκτροφώτιση ηλεκτροχημεία
ηλεκτρόλυση ηλεκτρόμετρο ηλεκτρόνιο ηλεκτρόφωνο ηλεκτρώσμωση ηλεμήνυμα
ηλιέλαιο ηλιακός ηλιανθόμελο ηλιασμός ηλιαστήριο ηλιαχτίδα ηλιθιότητα ηλικία
ηλιοβασίλεμα ηλιοβολή ηλιοβολία ηλιογράφος ηλιογραφία ηλιοθεραπεία ηλιολάτρης
ηλιολατρία ηλιοπληξία ηλιοροφή ηλιοσκοπία ηλιοσκόπιο ηλιοστάσιο ηλιοσυλλέκτης
ηλιοτροπία ηλιοτροπισμός ηλιοτρόπιο ηλιοτυπία ηλιοφάνεια ηλιοφοβία ηλιόβγαλμα
ηλιόγερμα ηλιόκαμα ηλιόλουτρο ηλιόπετρα ηλιόσκονη ηλιόσπορος ηλιόσφαιρα
ημέιλ ημέρα ημέρευση ημέρωμα ημέρωση ημίθεος ημίμετρο ημίονος ημίτονο ημίφωνο
ημίχρονο ημίψηλο ημίωρο ημεράδα ημερίδα ημεραλωπία ημεραργία ημεροδείκτης
ημερολόγιο ημερομήνια ημερομίσθιο ημερομηνία ημερονύκτιο ημερονύχτιο
ημερόπλοιο ημερότητα ημιέκταση ημιαγωγός ημιαθροιστής ημιαμινάλη ημιανάπαυση
ημιαποθετικό ημιαργία ημιδιατήρηση ημιδιατροφή ημιεπεξεργαστής ημικίονας
ημικύκλιο ημικύκλιο ημιμάθεια ημιμόριο ημιοκτάβα ημιολία ημιονηγός ημιπερίοδος
ημιπληγία ημιπληγικός ημισέληνος ημιστίχιο ημιστύλιο ημισυντήρηση ημισφαίριο
ημιταυτοχρονισμός ημιτελικά ημιτελικός ημιτονισμός ημιτόνιο ημιφορτηγό
ημιχρόνιο ημιχόριο ημιώροφος ηνίο ηνίοχος ηπάτωμα ηπατίτιδα ηπατίτις ηπαταλγία
ηπατισμός ηπατοκήλη ηπατολογία ηπατομεγαλία ηπατοπάθεια ηπατορραγία ηπατοτομία
ηπειρωτικά ηπειρώτης ηπειρώτισσα ηπιότητα ηρέμηση ηραίο ηρακλειώτης ηρεμία
ηρεμότητα ηρωίδα ηρωίνη ηρωινισμός ηρωισμός ηρωολατρία ηρωολατρεία ηρωοποίηση
ηρώο ησυχία ησυχασμός ησυχαστήριο ησυχαστής ηττοπάθεια ηφαίστειο
ηφαιστειολόγος ηφαιστειότητα ηχείο ηχηρότητα ηχοαίσθημα ηχοβολή ηχοβολίδα
ηχοβόλιση ηχογράφημα ηχογράφηση ηχογράφος ηχοεντοπισμός ηχοεπεξεργασία
ηχοκαταστολή ηχοκινησία ηχοκυματική ηχολήπτης ηχολήπτρια ηχολαλία ηχοληψία
ηχομετρία ηχομιμία ηχομόνωση ηχοπέτασμα ηχορύπανση ηχοσκόπιο ηχοτοπίο
ηχωεντοπισμός ηχωκαρδιογραφία ηχόμετρο ηχόχρωμα ηχώ ηωσίνη ηώς θάλαμος θάλασσα
θάλπος θάμα θάμασμα θάμβος θάμβωμα θάμβωση θάμνος θάμπος θάμπωμα θάνατος
θάψιμο θέα θέμα θέαινα θέαμα θέαση θέατρο θέλγητρο θέλγητρον θέλημα θέληση θέλησις
θέμελο θέρετρο θέριεμα θέρισμα θέρμανση θέρμη θέση θέσμιο θέσμιση θέσπιση
θέσπισμα θέσφατο θήκη θήλασμα θήλαστρο θήλαστρον θήλεια θήλιασμα θήλυ θήλωμα
θήραμα θήρευμα θήτα θήτης θίασος θίνα θίξιμο θα θαλάμη θαλάμι θαλάσσερμα
θαλαμάρχης θαλαμίσκος θαλαμηγός θαλαμηπόλος θαλαμοντόγκ θαλαμοφύλακας
θαλασσάκι θαλασσίλα θαλασσίτσα θαλασσαετός θαλασσαιμία θαλασσασφάλεια
θαλασσινά θαλασσινομανιταρόσουπα θαλασσινός θαλασσινόσουπα θαλασσογράφος
θαλασσοδάνειο θαλασσοδαρμός θαλασσοθεραπεία θαλασσοκαλλιέργεια θαλασσοκράτειρα
θαλασσοκρατία θαλασσοκρατορία θαλασσομάχος θαλασσομαχία θαλασσομαχητό
θαλασσοπνίξιμο θαλασσοπνίχτης θαλασσοποίηση θαλασσοπούλι θαλασσοπόρος
θαλασσοταξιδευτής θαλασσοταξιδιώτης θαλασσοταραχή θαλασσοφοβία θαλασσοχελώνα
θαλασσόβραχος θαλασσόλυκος θαλασσόνερο θαλασσόχορτο θαλερότητα θαλιδομίδη
θαλλόφυτα θαλπερότητα θαλπωρή θαμνόφιδο θαμπάδα θαμπόγυαλο θαμώνας θανάσης
θανή θανατάς θανατολογία θανατοπαγίδα θανατοποινίτης θανατοποινίτισσα
θανατοφοβία θαρθουέλα θασίτης θαυμάστρια θαυμασμός θαυμαστής θαυμαστικό
θαυματοποιός θαυματουργία θαύμα θεά θεάνθρωπος θεία θεία θείο θείον θείος
θείωση θεαθήναι θεαματικότητα θεανθρωπισμός θεατής θεατράκι θεατράνθρωπος
θεατρίνος θεατρικογράφος θεατρινισμός θεατρισμός θεατρολογία θεατρολόγος
θεατρώνης θειάφι θειάφισμα θεια θειαφιστήρι θειαφοκέρι θειικοκάλι θειοπηγή
θειότητα θεληματάρης θεληματίας θελιά θελκτικότητα θεμέλιο θεμέλιωμα
θεματοθέτης θεματοθέτρια θεματολογία θεματολόγιο θεματοφυλακή θεματοφύλακας
θεμελίωση θεμελίωσις θεμελιωτής θεμιστοπόλος θεογεννήτορας θεογεννήτρα
θεογνωσία θεογονία θεοδικία θεοδόλιχος θεοκαπηλία θεοκράτης θεοκρασία
θεοκρισία θεοκτονία θεολογία θεολογείο θεολόγος θεομαχία θεομηνία θεομπαίχτης
θεοπνευστία θεοποίηση θεοσέβεια θεοσκόταδο θεοσοφία θεοσοφίστρια θεοσοφισμός
θεοσύνη θεοτόκιο θεουργία θεουργός θεοφάνεια θεοφαγία θεούσα θεράπαινα
θερίστρια θεραπαινίδα θεραπαινίς θεραπεία θεραπευτήριο θεραπευτής θεραπευτική
θεριακή θεριακλής θεριακλίδισσα θεριακλίκι θεριακλού θερισμός θεριστής
θεριό θερμάστρα θερμίδα θερμίστορ θερμαισθησία θερμαλισμός θερμαντήρας
θερμασιά θερμαστής θερμηλασία θερμιδομετρία θερμιδόμετρο θερμοαίσθηση
θερμοαισθησία θερμοβαθογράφος θερμογέφυρα θερμογονία θερμογράφος
θερμοδιαμόρφωση θερμοδιαχυτότητα θερμοδυναμική θερμοηλεκτρισμός θερμοθεραπεία
θερμοκαυτήρας θερμοκαυτηρίαση θερμοκλιματισμός θερμοκοιτίδα θερμοκρασία
θερμομέτρηση θερμομαγνητισμός θερμομετρία θερμομηχανική θερμομόνωση
θερμοπίδακας θερμοπεριοδισμός θερμοπηγή θερμοπληξία θερμοπομπός θερμοπρόσοψη
θερμοσίφωνας θερμοσίφωνο θερμοσκόπιο θερμοστάτης θερμοσυσσωρευτής
θερμοτροπία θερμοτροπισμός θερμοφιλία θερμοφοβία θερμοφωσφορισμός
θερμοφόρα θερμοχημεία θερμοχωρητικότητα θερμόλουτρο θερμόλυση θερμόμετρο
θερμότητα θερμόφιλος θερμόφοβος θερσίτης θερφοφόρος θεσιθήρας θεσιθηρία
θεσμοθέτηση θεσμοθεσία θεσμοποίηση θεσμοφύλακας θεσμός θεσούλα θεσσαλονικιά
θετικίστρια θετικισμός θετικιστής θετικότητα θεωρία θεωρία πληροφορίας θεωρείο
θεωρητικολογία θεωρητικοποίηση θεωρητικός θεωρικά θεωρός θεϊσμός θεϊστής
θεός θεότητα θεώρημα θεώρηση θηβαία θηβαίος θηκάρι θηκόγραμμα θηλή θηλίτιδα
θηλαστικά θηλαστικολογία θηλαστικό θηλεοποίηση θηλιά θηλορραγία θηλυγονία
θηλυκοποίηση θηλυκωτάρι θηλυκωτήρι θηλυκότητα θηλυμανία θηλυμορφία θηλυπρέπεια
θηλύκι θηλύκωμα θηλύτητα θημωνιά θημώνιασμα θηρίο θηρίον θηραματοπονία
θηρεύτρια θηριοδαμάστρια θηριοδαμαστής θηριομάχος θηριομαχία θηριοτροφείο
θηριωδία θηροφυλακή θηροφύλακας θησαυρισμός θησαυριστής θησαυροθηρία
θησαυροφύλακας θησαυρός θησαύριση θησαύρισμα θητεία θιασάρχης θιασάρχις
θιασώτης θιασώτις θιασώτρια θιβετιανά θιβετιανός θιος θκιάολος θλάση θλίψη
θνησιγένεια θνησιγονία θνησιμότης θνησιμότητα θνητός θνητότης θνητότητα
θολίτης θολερότης θολερότητα θολοστάτης θολούρα θολόλιθος θολότης θολότητα
θορυβισμός θορυβολογία θορυβομηχανή θορύβηση θορύβησις θορύβωση θούλιο θούριο
θούριος θράκα θράσεμα θράσος θράψαλο θρέμμα θρέψη θρέψιμο θρέψις θρήνος
θρίαμβος θρίλερ θρακιάς θρακιώτης θρακιώτισσα θρακοπλαστική θρανίο θρανίον
θρασίμι θρασομάνι θρασυδειλία θρασύτης θρασύτητα θραυστήρας θραύση θραύσις
θραύστης θρεονίνη θρεπτικότης θρεπτικότητα θρεφτάρι θρηνολόγημα θρηνωδία
θρησκεία θρησκειολογία θρησκευτικά θρησκευτικότης θρησκευτικότητα θρησκοληψία
θρησκοφοβία θριάμβευση θριάμβευσις θριαμβευτής θριαμβεύτρια θριαμβολογία
θριναξόδοντας θριξ θριψ θρομβίνη θρομβεκτομή θρομβολυτικά θρομβοπενία
θρομβόλυση θρονί θρος θρουλί θρους θροφή θρούμπα θρούμπη θρούμπι θρυαλλίδα
θρυμμάτισμα θρυμματισμός θρυψάλιασμα θρυψιδόχος θρόισμα θρόμβος θρόμβωση
θρόνιασμα θρόνος θρόος θρύλημα θρύλος θρύμμα θρύο θρύψαλο θυγάτηρ θυγατέρα
θυλάκιο θυλάκιον θυμάρι θυμέλαιο θυμέλη θυμίαμα θυμίασις θυμαριά θυμαρόμελο
θυμεκτομή θυμηδία θυμητάρι θυμητικό θυμιάμα θυμιάτισμα θυμιατήρι θυμιατήριο
θυμιατό θυμικό θυμοειδές θυμοκρατία θυμοσοφία θυμός θυννοσκοπείο θυρίδα θυρίς
θυρεοειδής θυρεοειδίτιδα θυρεοειδίτις θυρεοειδεκτομή θυρεοκήλη θυρεός
θυροκόλλησις θυροξίνη θυροσκόπιο θυροτηλέφωνο θυροτηλεόραση θυροφύλακας
θυρωρείο θυρωρός θυρόφραγμα θυρόφυλλο θυρόφυλλον θυσία θυσανοσωρείτης
θυσιαστήριο θυσιαστής θωμαϊστές θωμισμός θωμιστής θωπεία θωπευτής θωπεύτρια
θωράκιον θωράκιση θωράκισις θωράκισμα θωρακεκτομή θωρακισμός θωρακοκέντηση
θωρακοτομία θωρακωτό θωρηκτό θωρηχτό θωριά θόλωμα θόλωση θόλωσις θόριο θόριον
θύελλα θύλακας θύλακος θύλακος θύλαξ θύμα θύμηση θύμος θύμωμα θύννος θύρα
θύρωμα θύσανος θύτης θύτρια θώκος θώμιγξ θώπευμα θώρακας θώραξ θώρι θώς ιέραξ
ιέρισσα ιαβαϊκά ιαγουάρος ιακοψίτης ιακωβίνοι ιακωβίνος ιακωβινισμός ιαλπαίτης
ιαπωνικά ιαπωνολογία ιασμέλαιο ιατρεία ιατρείο ιατρική ιατροβιολογία
ιατροδικαστίνα ιατροδικαστική ιατροσυμβούλιο ιατροσόφιον ιατροφιλόσοφος ιατρός
ιαχή ιβίσκος ιβηρίδα ιβοριανή ιβοριανός ιβουάρ ιγδίον ιγμορίτιδα ιγμόρειο
ιγνύς ιδέα ιδίωμα ιδαλγός ιδανίκευση ιδανικό ιδανικότητα ιδανισμός ιδεαλίστρια
ιδεαλιστής ιδεασμός ιδεογραφία ιδεοκράτης ιδεοκρατία ιδεοληπτικός ιδεοληψία
ιδεολογισμός ιδεολόγημα ιδεολόγος ιδεοπλασία ιδεοσύμπαν ιδεοσύνολο ιδεόγλωσσα
ιδεόκοσμος ιδεότυπος ιδεώδες ιδιαίτερο ιδιαίτερος ιδιαιτέρα ιδιαιτερότητα
ιδιοκατάσταση ιδιοκατανάλωση ιδιοκατασκευή ιδιοκατασκεύασμα ιδιοκατοίκηση
ιδιοκτήτρια ιδιοκτησία ιδιομορφία ιδιοπάθεια ιδιοπληρωτής ιδιοποίηση
ιδιοσκεύασμα ιδιοστροφορμή ιδιοσυγκρασία ιδιοσυστασία ιδιοσυχνότητα ιδιοτέλεια
ιδιοτροπία ιδιοτυπία ιδιοφυΐα ιδιοχρησία ιδιοχρησιμοποίηση ιδιωματισμός
ιδιωτεία ιδιωτικοποίηση ιδιωτισμός ιδιωφέλεια ιδιόλεκτο ιδιόλεκτος ιδιόμελο
ιδιότητα ιδιώνυμο ιδιώτευση ιδού ο νυμφίος ιδροκόπημα ιδροκόπι ιδρυματισμός
ιδρυτής ιδρωτάρι ιδρωτίλα ιδρωτοθεραπεία ιδρωτοποιία ιδρός ιδρύτρια ιδρώτας
ιεράρχηση ιερέας ιερακοειδές ιερακοτροφία ιερακοτρόφος ιεραποστολή
ιεραρχία ιερατείο ιερεμιάδα ιερογλυφικά ιερογράφος ιερογραφία ιεροδίκης
ιεροδιδάσκαλος ιεροδιδασκαλείο ιεροδικείο ιεροδουλία ιεροεξεταστής ιεροκήρυκας
ιεροκρατία ιερολογία ιερολοχίτης ιερομάντης ιερομάρτυρας ιερομαντεία
ιεροπρέπεια ιεροπραξία ιεροσκοπία ιεροσκόπος ιεροσπουδαστήριο ιεροσπουδαστής
ιεροσύλημα ιεροσύνη ιεροτελεστία ιερουργία ιερουργός ιεροφάντης ιεροφάντισσα
ιεροχλόη ιεροψάλτης ιερωμένος ιερό ιερόδουλη ιερόδουλος ιερότητα ιεχωβάδες
ιεχωβιστής ιζηματογένεση ιζηματολογία ιζηματολόγος ιησουίτης ιησουίτισσα
ιθαγένεια ιθαγενής ιθακήσιος ιθύφαλλος ικάριος ικέτης ικέτισσα ικανοποίηση
ικαριώτης ικαριώτισσα ικεμπάνα ικεσία ικμάδα ικμάς ικρίον ικρίωμα ικτίς
ιλαρά ιλαροτραγωδία ιλαρότητα ιλασμός ιλιάτσι ιλοκάνο ιλυόλιθος ιλυόλουτρον
ιμάμ μπαϊλντί ιμάμης ιμάντας ιμάς ιμάτιο ιμέιλ ιμίνη ιματιοθήκη ιματιοφυλάκιο
ιμβερτοσάκχαρο ιμιδαζόλια ιμπεριαλίστρια ιμπεριαλισμός ιμπεριαλιστής ιμπρέτι
ιμπρεσάριος ιμπρεσιονίστρια ιμπρεσιονισμός ιμπρεσιονιστής ινάτι ινίδιο ινίο
ινδή ινδιάνα ινδιάνος ινδιάνος ινδικά ινδική κάνναβις ινδικτιών ινδικτιώνα
ινδισμός ινδοευρωπαϊκά ινδοευρωπαϊκή ινδοκάλαμος ινδοκυανίνη ινδονήσιος
ινδουίστρια ινδουισμός ινδουιστής ινδός ινκόγκνιτο ινομύωμα ινοσανίδα
ινούκτιτουτ ινούπιακ ινσουλίνη ινστιτούτο ινστρούχτορας ιντελέξουαλ
ιντελιγκέντσια ιντερέσο ιντερβιού ιντερλίνγκουα ιντερλίνγκουε ιντερλούδιο
ιντερμέτζο ιντερνετάκιας ιντερνετισμός ιντερνούντσιος ιντετερμινισμός
ιντιμισμός ινφάντα ινφάντη ινφάντης ινφλουέντζα ινφλουέντσα ινωμάτωση
ιξόβεργα ιξός ιξώδες ιολογία ιονισμός ιονιστής ιονοθεραπεία ιοντισμός
ιοντόσφαιρα ιονόσφαιρα ιορδανός ιουδαίος ιουδαιο-ισπανικά ιουδαϊσμός ιουλιανά
ιούτη ιππάριο ιππέας ιππασία ιππεύτρια ιππηλάτης ιππηλασία ιππιατρική ιππικό
ιπποδρομία ιπποδρομιάκιας ιπποδρόμιο ιπποδρόμιον ιπποδύναμη ιπποκομία
ιππομαχία ιππονομή ιπποπέδη ιπποπόταμος ιπποσκευή ιπποστάσιο ιπποσύνη
ιπποτισμός ιπποτροφία ιπποτροφείο ιπποτρόφος ιπποφάγος ιπποφαές ιπποφαγία
ιππόδρομος ιππόκαμπος ιππότης ιρίδιο ιραδές ιρακινή ιρακινός ιρανή ιρανός
ιρασιοναλισμός ιρασιοναλιστής ιρεδεντισμός ιριδίτιδα ιριδεκτομή ιριδισμός
ιριδοσκόπιο ιριδοτομία ιρλανδέζα ιρλανδέζος ιρλανδή ιρλανδικά ιρλανδοτσιγγάνος
ιρρεδεντισμός ισάδα ισαπόστολος ισασμός ισηγορία ισημερία ισημερινός
ισθμός ισιάδα ισλάμ ισλαμισμός ισλαμιστής ισλαμολογία ισλαμολόγος ισλαμοφάγος
ισλανδέζος ισλανδή ισλανδικά ισλανδός ισνάφι ισοβίτης ισοβίτισσα ισοβαθμία
ισοδυναμία ισοζυγία ισοζυγισμός ισοζύγιο ισοθερμία ισοκατανέμω ισοκατανομή
ισολευκίνη ισολογισμός ισομέρεια ισομερισμός ισομετρία ισομοιρία ισομορφία
ισονομία ισοπέδωση ισοπαλία ισοπολιτεία ισοπρένιο ισορροπία ισορροπίστρια
ισορρόπηση ισοσκέλιση ισοστάθμιση ισοσταθμία ισοσταθμιστής ισοστασία
ισοτέλεια ισοτιμία ισοτονία ισοτροπία ισοφάριση ισοχρονισμός ισοψηφία ισοϋψής
ισπανική ισπανοεβραϊκά ισπανός ισραηλίτης ισραηλίτισσα ισραηλινός ισραηλιστής
ισταμίνη ιστιδίνη ιστιοδέτης ιστιοδρομία ιστιοπλοΐα ιστιοπλοϊκό ιστιοπλόος
ιστιοραφείο ιστιοσανίδα ιστιοφορία ιστιοφόρο ιστιούχος ιστιόπανο ιστιόραμμα
ιστογράφος ιστογραφία ιστοκαλλιέργεια ιστοκλαδόγραµµα ιστολογία
ιστολογόσφαιρα ιστολόγιο ιστολόγος ιστοπαθολογία ιστορία ιστορικό ιστορικός
ιστοριογράφος ιστοριογραφία ιστοριοδίφης ιστοριοδίφισσα ιστοριοδιφία
ιστοριοπλασία ιστοριοφοβία ιστορισμός ιστοσελίδα ιστοσελιδογραφία
ιστοτομία ιστοχάρτης ιστοχώρος ιστόγραμμα ιστόγραμμο ιστόλυση ιστόρημα
ιστός ιστότοπος ισχάδα ισχίο ισχαδόδεσμος ισχαιμία ισχιαλγία ισχνότητα
ισχυρισμός ισχυρογνωμοσύνη ισχυροποίηση ισχύς ισχύτητα ισόβια ισόγειο ισόγειος
ισόρρυθμος ισότητα ισότοπο ιταλίδα ιταλιάνα ιταλιάνος ιταλικά ιταλομανία
ιταμότητα ιτιά ιχθυάλευρο ιχθυέλαιο ιχθυαγορά ιχθυαπόθεμα ιχθυογεννητικός
ιχθυοδότηση ιχθυοκαλλιέργεια ιχθυοκαλλιεργήτρια ιχθυοκαλλιεργητής ιχθυολογία
ιχθυομαντεία ιχθυοπανίδα ιχθυοπαραγωγή ιχθυοπληθυσμός ιχθυοπωλείο ιχθυοπώλης
ιχθυοτροφείο ιχθυοτροφείον ιχθυοτρόφος ιχθυοφαγία ιχθυόκολλα ιχθυόλη
ιχθυόσκαλα ιχθύδιο ιχθύς ιχθύς ιχνευτής ιχνηθέτης ιχνηλάτης ιχνηλάτηση
ιχνηλασιμότητα ιχνογράφημα ιχνογράφηση ιχνογράφος ιχνογραφία ιχνολογία
ιχώρ ιωβηλαίο ιωδισμός ιωτακισμός ιόν ιόντωση ιός ιώδιο ιώτα κάβα κάβος
κάγκελο κάγκουρας κάδη κάδμιο κάδος κάδρο κάζο κάθαρμα κάθαρση κάθαρσις
κάθετος κάθισμα κάθοδος κάιζερ κάκαδο κάκητα κάκια κάκιωμα κάκτος κάκωση
κάλαθος κάλαμος κάλαντα κάλαϊς κάλεσμα κάλιο κάλλαιον κάλλος κάλμα κάλος κάλπη
κάλτσα κάλυκας κάλυμμα κάλυξ κάλυψη κάλυψις κάλφας κάλως κάμα σούτρα κάμαρα
κάματος κάμβιο κάμερα κάμηλος κάμινος κάμπαγος κάμπη κάμπια κάμπιγκ κάμπινγκ
κάμποτ κάμποτο κάμπους κάμφορα κάμψη κάμψις κάμωμα κάναβα κάναβος κάνθαρος
κάνναβη κάνναβος κάννη κάνονας κάνουλα κάντιο κάντρο κάπαρη κάπελας κάπηλος
κάπνισμα κάπνω κάπος κάππαρη κάππαρις κάπρος κάπταιν κάπτεν κάρα κάρα κάρβουνο
κάργας κάργια κάρδαμο κάρι κάρκανο κάρμα κάρο κάρπευμα κάρπισμα κάρπωση
κάρτα κάρτερ κάρτιγκ κάρυο κάρυον κάρφος κάρφωμα κάρωση κάσα κάσαρο κάσια
κάσσα κάσσια κάστα κάστανο κάστορας κάστρο κάσωμα κάταγμα κάτεργο κάτης
κάτοικος κάτοπτρο κάτουρο κάτοχος κάτοψη κάτοψις κάτσενα κάτσιασμα κάττυμα
κάφρος κάχρι κάψιμο κάψουλα κάψωμα κέγχρος κέδρο κέδρος κέικ κέλευση κέλευσις
κέλης κέλητας κέλλα κέλτης κέλυφος κένταυρος κέντημα κέντια κέντρισμα κέντρο
κένωση κένωσις κέραμος κέρας κέρασμα κέρασος κέρατο κέρβερος κέρδισμα κέρδος
κέρσορας κέρωμα κέσιο κέτσαπ κέτσουα κέφαλος κέφι κήδευση κήλη κήνσορας κήνσωρ
κήπευση κήπος κήρυγμα κήρυκας κήρυξ κήρυξη κήτος κίκι κίνα κίναιδος κίνδυνος
κίνηση κίνητρο κίνητρον κίντυνος κίονας κίπου κίρρωση κίσσα κίσσηρις κίστη
κίτρινο κίτρο κίτρος κίχλη κίων καΐκι καΐλα καΐσι καίσαρας καίσιο καβάκι
καβάλημα καβάλο καβάλος καβάτζα καβάφης καβίλια καβαλάρης καβαλάρισσα καβαλέτο
καβαλίνα καβαλαρία καβαλιέρος καβαλισμός καβαλιστής καβαλιώτης καβανάς
καβατζάρισμα καβγάδισμα καβγάς καβγαδάκι καβγατζής καβγατζού καβλί καβοδεσία
καβουράκι καβουρίνα καβουρδιστήρι καβουρμάς καβουρντιστήρι καβουρομάνα
καβουρόσουπα καβούνι καβούρδισμα καβούρι καβούρντισμα καβρός καβυλικά καγιάκ
καγκάβα καγκελάριος καγκελαρία καγκελόπορτα καγκουρό καγχασμός καδένα καδής
καδίσκος καδελέτο καδινάτσο καδράρισμα καδρίλια καδρόνι καερέτι καζάκα
καζάνι καζάντια καζάντισμα καζάρμα καζάς καζίκι καζίνο καζακικά καζακστανός
καζανάκι καζανάς καζανιά καζαντζής καζεΐνη καζμάς καζούρα καημός καθάρισμα
καθέδρα καθέκαστα καθέκλα καθέλκησις καθέλκυση καθήκον καθήλωση καθίδρυμα
καθίζηση καθίκης καθίκι καθαίρεση καθαγίαση καθαγιασμός καθαγνισμός καθαλάτωση
καθαρευουσιάνα καθαρευουσιάνος καθαρευουσιανισμός καθαρεύουσα καθαρισμός
καθαριστήριο καθαριστήριον καθαριστής καθαριότης καθαριότητα καθαρμός
καθαρογράφηση καθαρογράφησις καθαρογράφος καθαρολογία καθαρτήρ καθαρτήρας
καθαρτήριον καθαρτικά καθαρτικό καθαρό καθαρότητα καθεδρικός καθεκλοποιία
καθελκυσμός καθεστώς καθετή καθετήρας καθετηρίαση καθετηρίασις καθετηριασμός
καθηγήτρια καθηγεσία καθηγητάκος καθηγητής καθηκοντολογία καθηκοντολόγιο
καθημερινοποίηση καθημερινότητα καθησύχαση καθιέρωση καθιζητήρας καθικάκι
καθισιά καθισιό καθισματάκι καθιστικό καθοδήγηση καθοδηγητής καθοδοφωταύγεια
καθολικισμός καθολικό καθολικός καθολικότητα καθομιλουμένη καθομολογία
καθορισμός καθοσίωση καθρέπτης καθρέφτης καθρέφτισμα καθρεφτάδικο καθυπόταξη
καθυστέρηση καθυστέρησις καθυστερούμενα καθωσπρεπισμός καθύβριση καθύγρανση
καινοθήρας καινοθηρία καινοτομία καινοτομικότητα καινοτόμος καιροσκοπία
καιροσκόπος καιρός καισάρισσα καισαρισμός καισαροπαπισμός κακά κακάβι κακάδι
κακάρισμα κακάρωμα κακία κακίστρα κακαβολίθια κακανθρωπίσματα κακαράντζα
κακαόδεντρο κακεντρέχεια κακεργέτης κακκάβι κακκαβιά κακοήθεια κακοβουλία
κακογλωσσία κακογλωσσιά κακογνωμία κακογνωμιά κακογουστιά κακογραφία
κακοδαιμονία κακοδιαθεσία κακοδιαχείριση κακοδικία κακοδιοίκηση κακοδιοίκησις
κακοζηλία κακοζωία κακοθανασία κακοθανατιά κακοθελήτρα κακοθελητής κακοθυμία
κακοκαιριά κακοκεφαλιά κακοκεφιά κακοκλεψία κακολογία κακομεταχείριση
κακομνησία κακομοιριά κακονομία κακοπάθεια κακοπάθημα κακοπάθηση κακοπέραση
κακοπαντρειά κακοπιστία κακοπλασία κακοπληρωτής κακοπληρώτρια κακοποίηση
κακοποιία κακοποιός κακοπραγία κακοπρόσωπος κακοριζικιά κακοσημαδιά κακοσμία
κακοστομαχιά κακοσυνιά κακοσφυγμία κακοσύνη κακοτέχνημα κακοταίριασμα
κακοτεχνίτης κακοτοπιά κακοτροπία κακοτροπιά κακοτυχία κακοτυχιά κακουργία
κακουργιοδικείο κακουργιοδικείον κακουργοδικείο κακουχία κακοφέρσιμο κακοφαγία
κακοφημία κακοφωνία κακοφόρμισμα κακοχρονιά κακοχρόνισμα κακοχυμία κακοψύχι
κακούργος κακτάκι κακωνυμία κακό κακόνοια κακόπαιδο κακότης κακότητα κακώνυμο
καλάθι καλάθιον καλάι καλάισμα καλάμη καλάμι καλάμισμα καλάρισμα καλέμι
καλέσιμος καλή καλήμερα καλίγα καλίγωμα καλίκωση καλίμπρα καλααζάρ καλαβρέζικα
καλαθάκι καλαθάρα καλαθάς καλαθιά καλαθοπλεκτική καλαθοπλεχτική καλαθοποιία
καλαθοσφαίριση καλαθοσφαιρίστρια καλαθοσφαιριστής καλαθούνα καλαθόσφαιρα
καλαμάκι καλαμάρι καλαμάτης καλαμήθρα καλαμίδι καλαμίθρα καλαμίνη καλαμαράκι
καλαμαριά καλαματιανός καλαματιανός καλαμιά καλαμιώνας καλαμοκάνα καλαμοκάνης
καλαμοσάκχαρο καλαμοσάκχαρον καλαμοσίταρο καλαμπακιώτης καλαμπακιώτισσα
καλαμποκάλευρο καλαμποκιά καλαμποκόσουπα καλαμπουρτζής καλαμπούρι καλαμπόκι
καλαμόσπιτο καλαμόσχοινο καλαντάρι καλαντίστρια καλαντιστής καλαποδάς καλαπόδι
καλαφάτισμα καλαφατιστήρι καλαϊτζής καλβινίστρια καλβινισμός καλβινιστής
καλειδοσκόπιο καλειδοσκόπιον καλεμκερί καλενδάριον καλεντάρι καλεσμένος
καλημέντο καλημέρα καλημέρισμα καλημαύκι καλημαύχι καληνυχτάκιας καληνύχτα
καληνώρισμα καλησπέρα καλησπέρισμα καλιά καλιακούδα καλιαρντά καλιαρντή
καλικάντζαρος καλικαντζάρι καλικαντζαράκι καλικαντζαρίνα καλικαντζαρούδι
καλιμέντο καλιομαγνήσιο καλιτσούνι καλιφόρνιο καλκάνι καλλιέπεια καλλιέργεια
καλλιγράφος καλλιγραφία καλλιεργήτρια καλλιεργητής καλλιθεάτης καλλιλογία
καλλιστεία καλλιτέχνημα καλλιτέχνης καλλιτέχνιδα καλλιτέχνις καλλιτεχνία
καλλιφωνία καλλονή καλλουργιά καλλυντικό καλλυντικός καλλωπίστρια καλλωπισμός
καλλωπιστής καλλώπισμα καλμάρισμα καλντέρα καλντερίμι καλντεριμιτζού καλοήθεια
καλοβατικά καλοβολιά καλοβουλία καλογεράκι καλογερική καλογεροπαίδι
καλογιάννος καλογιαννοπούλα καλογνωμιά καλογρίτσα καλογραία καλογριά
καλοζωία καλοζωιστής καλοθανατιά καλοθελήτρα καλοθελητής καλοκάρδισμα
καλοκαίριασμα καλοκαγαθία καλοκαιράκι καλοκαιρία καλοκαιριά καλοκαρδισμός
καλολογία καλομεταχείριση καλομεταχείρισμα καλομοιριά καλονάρχημα καλονάρχος
καλοπέρασμα καλοπαντρειά καλοπερασάκιας καλοπισμός καλοπιστία καλοπληρωτής
καλορί καλορίζικα καλορίμετρο καλοριζικιά καλοριφέρ καλοσύνεμα καλοσύνη
καλοτυχιά καλοτύχισμα καλουπατζής καλουπιτζής καλοφάνερος καλοφαγάς καλοφαγία
καλοχειμωνιά καλοχρονιά καλοχρόνισμα καλοψυχία καλοψυχιά καλούδι καλούμα
καλούπι καλούπωμα καλπάκι καλπάκι καλπασμός καλπιά καλπονοθεία καλπονόθευση
καλπουζάνης καλπουζάνος καλπουζανιά καλσόν καλτσάκι καλτσοβελόνα καλτσοδέτα
καλτσόν καλυβάκι καλυκοποιείο καλυμμαύκι καλυμμαύχι καλυτέρευση καλυτέρευσις
καλφαλίκι καλφόπουλο καλωδίωση καλωδιάκι καλωσόρισμα καλωσύνη καλό καλόγερος
καλόγρια καλόν καλόπιασμα καλός καλότα καλύβα καλύβη καλύβι καλύκι καλύμνια
καλύπτρα καλώδιο καμάκι καμάκωμα καμάρα καμάρι καμέλια καμέραμαν καμήλα
καμίνευση καμίνευσις καμίνι καμαράκι καμαρίλα καμαρίλλα καμαρίνι καμαρίτσα
καμαριέρα καμαριέρης καμαροφρυδούσα καμαροφρύδα καμαροφρύδης καμαρούλα
καμαρότος καμασούτρα καματάρης καματάρισσα καματερό καμβάς καμελιέλαιο
καμηλαύκι καμηλαύχι καμηλιέρης καμηλιέρισσα καμηλοπάρδαλη καμηλωτή καμηλό
καμηλόμαλλο καμηλόσουπα καμηλότριχα καμιζόλα καμικάζι καμιλαύκι καμιλαύχι
καμινάρης καμινάς καμινέτο καμινεία καμινετάκι καμινευτήρας καμινευτήριο
καμινεύτρια καμινοβίγλι καμιτσίκι καμιόνι καμουτσί καμουτσίκι καμουτσικιά
καμουφλάρισμα καμπάγι καμπάνα καμπάνια καμπάνισμα καμπέρω καμπή καμπίλε
καμπαέτι καμπανάκι καμπανάρης καμπανίτης καμπαναριό καμπανιά καμπανοπιπεριά
καμπαρέ καμπαρετζού καμπαρντίνα καμπιαδόρος καμπινέ καμπινές καμποτάζ
καμποτζιανά καμποτινισμός καμπούκι καμπούλι καμπούνι καμπούρα καμπούρης
καμπτήρας καμπυλότης καμπυλότητα καμπύλη καμπύλωση καμτσίκι καμτσικιά καμφορά
καμφορόδεντρο καμωματού καμόρα κανάγιας κανάκεμα κανάκι κανάκια κανάλι κανάρα
κανάστα κανάτα κανάτας κανάτι κανέλα κανί κανίβαλος κανίς κανίσκι καναβάτσο
καναδέζα καναδέζος καναδή καναδός κανακάρης κανακάρισσα καναλάκι καναλάρα
καναλισμός καναντέρ καναπές καναπεδάκι καναρίνι καναρινάκι καναρινί κανατάκι
κανατίτσα κανατούλα κανδήλα κανδήλι κανδαυλισμός κανελί κανελόνι κανθαρίδα
κανθαριδίνη κανθός κανιβαλισμός κανκάν καννάβι κανναβάτσα κανναβάτσο
κανναβίς κανναβούρι κανναβόσκοινο κανναβόσπορος κανναβόσχοινο κανναβόχαρτο
κανοκιάλι κανονάκι κανονάρχημα κανονάρχης κανονάρχος κανονίδι κανονιά
κανονικοποίηση κανονικότης κανονικότητα κανονιοβολισμός κανονιοθυρίδα
κανονιοστοιχία κανονιοφόρος κανονισμός κανονιστής κανονιστική καντάδα καντάρι
καντέμης καντήλα καντήλι καντίνα καντίνι κανταΐφι κανταδίτσα κανταδόρικος
κανταρτζής κανταφισμός κανταφιστής καντεμιά καντζελλαρία καντηλέρι καντηλήθρα
καντηλανάφτης καντηλανάφτισσα καντηλιέρι καντιανισμός καντιλέτο καντούνι
καντρίλια καντρόνι καντσονέτα καντόν καντόνι κανό κανόνας κανόνι κανόνισμα
καολίνης καουμπόης καουμπόι καουτσουκόδεντρο καουτσούκ καούνι καούρα καπάκι
καπάρο καπάρος καπάρωμα καπάτσα καπάτσος καπέλλο καπέλο καπέλωμα καπήλευση
καπίστρι καπίστρωμα καπαμάς καπαμπάγκαν καπανταής καπαντατζού καπαρόκουμπο
καπατσοσύνη καπελάδικο καπελάκι καπελάρισμα καπελάς καπελίνα καπελίνο
καπελειό καπελιέρα καπελού καπετάν καπετάνιος καπετάνισσα καπεταν-ψωμάς
καπετανλίκι καπηλεία καπηλειό καπηλευτής καπινός καπιστράνα καπιτάλα καπιτάλας
καπιταλίστας καπιταλίστης καπιταλίστρια καπιταλισμός καπιταλιστής
καπιτονέ καπλάνι καπλάντισμα καπλαμάς καπλαματζής καπλαντοβελόνα καπλοσυκιά
καπνάς καπνέλαιο καπνέμπορας καπνέμπορος καπνίλα καπνίστρια καπναγωγός
καπνεμπορείο καπνεμπορικός καπνεμπόριο καπνεμπόρισσα καπνεργάτης καπνεργάτισσα
καπνεργατικά καπνεργοστάσιο καπνιά καπνικόν καπνιστήρι καπνιστήριο καπνιστής
καπνοβιομηχανία καπνοδοχοκαθαριστής καπνοδόχος καπνοθάλαμος καπνοθήκη
καπνοκαλλιεργητής καπνοκοπτήριο καπνομάγαζο καπνομίχλη καπνομαντεία
καπνοπωλείο καπνοπώλης καπνοπώλις καπνοπώλισσα καπνοσακούλα καπνοσυλλέκτης
καπνοσωλήνας καπνοσύριγγα καπνοσύριγξ καπνοτόπι καπνοφυτεία καπνούρα καπνός
καπνόφυλλο καποτάστο καπουδάν καπουτσίνο καπουτσίνος καπούλι καππαριά
καπρίτσο καπό καπόνι καπότα καράβι καράβλακας καράγιαλης καράμπα καράολος
καράς καράτε καράτι καράφα καράφλα καράφλας καρέ καρέγλα καρέκλα καρένα καρέτα
καρίνα καραβάκι καραβάν-σεράι καραβάνα καραβάνι καραβάρα καραβέλα καραβίδα
καραβιά καραβοκύρης καραβοκύρισσα καραβολίδα καραβομαραγκός καραβοστάσι
καραβοφάναρο καραβόπανο καραβόσκαρο καραβόσκοινο καραβόσκυλο καραβόσκυλος
καραγάτσι καραγκιοζιλίκι καραγκιοζλίκι καραγκιοζοπαίχτης καραγκιόζης
καραγκούνα καραγκούνης καραγκούνισσα καραγωγέας καρακάξα καρακαηδόνα
καρακόλι καραμέλα καραμέλωση καραμελόχρωμα καραμούζα καραμπίνα καραμπινιέρος
καραμπογιά καραμπουζουκλής καραμπόλα καραντί καραντίνα καραντουζένι καραούλι
καραπουτανάρα καραπουτσακλάρα καραπούτανος καρασεβντάς καρατέκα καρατερίστα
καρατζόβας καρατσάι μπαλκάρ καρατόμηση καραφάκι καρβέλι καρβελάκι καρβελούτσα
καρβουνάκι καρβουνέμπορος καρβουναποθήκη καρβουναριό καρβουνιάρης
καρβουνιέρα καρβουνόσκονη καρβούνιασμα καρβύνιο καργιόλα καρδάμωμα καρδάρα
καρδίτιδα καρδίτις καρδερίνα καρδιά καρδιαγγειογραφία καρδιακός καρδιαλγία
καρδιοαγγειογραφία καρδιογνώστης καρδιογνώστρα καρδιογνώστρια καρδιογράφημα
καρδιογραφία καρδιοδυναμική καρδιοκατακτητής καρδιοκλέφτης καρδιοκλέφτρα
καρδιολόγος καρδιομεγαλία καρδιοπάθεια καρδιοπαθής καρδιοσωμός καρδιοσωσμός
καρδιοτοκογράφος καρδιοτομία καρδιοφυσιολογία καρδιοχειρουργική
καρδιοχτύπι καρδιτσαίος καρδιτσιώτης καρδούλα καρεδάκι καρεκλάδικο καρεκλάκι
καρεκλί καρεκλίτσα καρεκλοκένταυρος καρεκλοκενταυρισμός καρεκλολαγνεία
καρενάγιο καρηβαρία καρθαμέλαιο καριέρα καριερίστας καριερισμός
καρικατούρα καριμπού καριοφίλι καριόλα καριόλης καριόφιλο καρκάδι καρκίνος
καρκίνωση καρκίνωσις καρκινοβασία καρκινογένεση καρκινολογία καρκινολόγος
καρκινοποίησις καρκινοφιλία καρκινοφοβία καρκινόλυση καρκόλα καρλίνο καρμίνι
καρμίρης καρμανιόλα καρμιριά καρμπαπενέμες καρμπιλατέρ καρμπιρατέρ
καρμπονάρα καρμπονάρος καρμπυρατέρ καρμπόν καρνάβαλος καρνάγιο καρνέ καρναβάλι
καρναβαλικά καρναβαλιστής καρναγιάρισμα καρντάσαινα καρντάσης καρντάσι
καροσερί καροτέλαιο καροτί καροτίλα καροτίνη καροτοπουρές καροτοσαλάτα
καροτσάκι καροτσέρης καροτσιέρης καροτόζουμο καροτόσουπα καρουζέλ καρούλα
καρούμπαλο καρούμπαλος καρπάζωμα καρπάτσιο καρπέτα καρπαζιά
καρπαθιώτης καρποκάψα καρπολογία καρπολόγημα καρπολόγος καρπουζιά καρποφαγία
καρπούζι καρπωτής καρπόδεση καρπός καρπόσωμα καρπώτρια καρσιλαμάς καρστ
καρτ καρτ ποστάλ καρτάλι καρτέλ καρτέλα καρτέρεμα καρτέρι καρταναγνώστης
καρτελοθήκη καρτερία καρτερικότης καρτερικότητα καρτεροψυχία καρτεσιανισμός
καρτούν καρτούτσο καρτούχος καρτσόνι καρτόνι καρτόφ καρυάτιδα καρυδάκι
καρυδιά καρυδόξυλο καρυδόπιτα καρυδότσουφλο καρυδόφλουδα καρυδόφυλλο
καρυδόψιχα καρυοθραύστης καρυοφύλλι καρυστινός καρυότυπος καρυόφυλλο
καρφάκι καρφί καρφίς καρφίτσα καρφίτσωμα καρφιτσοθήκη καρφοβελόνα καρφωτής
καρχηδόνιος καρωτίδα καρό καρότο καρότσα καρότσι καρύδα καρύδι καρύδωμα
καρύκευση καρώτο κασέ κασέλα κασέρι κασέτα κασίδα κασίδης κασαβέτι κασαμπάς
κασελάκι κασεράκι κασερόπιτα κασετάδικο κασετίνα κασετινούλα κασετοπειρατεία
κασετόφωνο κασιέρα κασιδιάρης κασιώτης κασκέτο κασκαβάλι κασκαντέρ κασκαρίκα
κασκορσές κασκορσεδάκι κασκόλ κασμάς κασμίρ κασμίρι κασμιρικά κασονάκι
κασουβιανά κασπό κασπώ κασσίτερος κασσιτέρωμα κασσιτέρωση κασσιτεροκόλληση
κασσιτερωτής καστάνια καστέλα καστέλι καστέλο καστανάς καστανιά καστανιέτα
καστανοπώλης καστανόμελο καστανόσουπα καστανόχρωμα καστανόχωμα καστελάνος
καστοριανός καστράκι καστρί καστροφύλακας καστρούπολη καστρόπορτα καστρόπυργος
καστόρ καστόρι κασόνα κασόνι κατάβαση κατάβασις κατάβρεγμα κατάβρεξη κατάδειξη
κατάδικος κατάδοση κατάδοσις κατάδυση κατάδυσις κατάθεση κατάθλιψη κατάθλιψις
κατάκλαση κατάκλασις κατάκλιση κατάκλισις κατάκριση κατάκρισις κατάκτηση
κατάληξη κατάληξις κατάληψη κατάληψις κατάλογος κατάλοιπο κατάλοιπον κατάλυμα
κατάλυσις κατάμπαρο κατάνα κατάνευση κατάνευσις κατάντη κατάντημα κατάντια
κατάνυξις κατάπαυση κατάπαυσις κατάπιομα κατάπλασμα κατάπληξη κατάπληξις
κατάπνιξη κατάποση κατάποσις κατάπτωση κατάπτωσις κατάρα κατάραχο κατάργηση
κατάρρευση κατάρρευσις κατάρριψη κατάρριψις κατάρρους κατάρτι κατάρτιση
κατάσβεση κατάσβεσις κατάσκοπος κατάσταση κατάστασις κατάστασις κατάστημα
κατάστιξις κατάστιχο κατάστρωμα κατάστρωμα αποπροσνήωσης κατάστρωση
κατάσχεση κατάταξη κατάταξις κατάτμηση κατάτμησις κατάφαση κατάφασις κατάφυση
κατάχτηση κατάχωση κατάψυξη κατέβασμα κατήγορος κατής κατήφεια κατήφορος
κατήχησις κατίκι κατίσχυση κατίσχυσις καταβαράθρωση καταβαράθρωσις καταβασία
καταβολή καταβολισμός καταβρεγμός καταβρεχτήρας καταβρεχτήρι καταβρόχθιση
καταβυθιστής καταβόδιο καταβόθρα καταβύθιση καταγγελία καταγοήτευση
καταγραφή καταγραφεύς καταγωγή καταγώγιο καταδίκη καταδίωξη καταδίωξις
καταδεχτικότητα καταδημαγώγηση καταδολίευση καταδολίευσις καταδρομέας
καταδρομεύς καταδρομικό καταδρομικόν καταδυνάστευση καταδυνάστευσις καταδότης
καταδότρια καταζήτηση καταζήτησις καταθέτης καταθέτρια καταιγίδα καταιγίς
καταιονίζομαι καταιονίζω καταιονητήρ καταιονητήρας καταιονισμός καταιονιστήρας
καταισχύνη καταιόνηση καταιόνησις κατακάθι κατακάθισμα κατακαλόκαιρο
κατακερματισμός κατακεφαλιά κατακλείδα κατακλείς κατακλυσμός κατακράτηση
κατακρήμνιση κατακρήμνισις κατακρήμνισμα κατακραυγή κατακρεούργηση
κατακτήτρια κατακτητής κατακυρίευση κατακόμβη κατακόρυφος κατακύρωση
καταλάγιασμα καταλήστευση καταλαλήτρα καταλαλητής καταλαλητό καταλαλιά
καταληπτικός καταληψία καταλληλότης καταλληλότητα καταλογή καταλογισιμότητα
καταλογιστό καταλογιστόν καταλογογράφηση καταλυτής καταλύτης καταλύτρα
καταμέρισις καταμέτρηση καταμέτρησις καταμήνυση καταμήνυσις καταμαράν
καταμερισμός καταμεσήμερο καταμετρητής καταμόσχευση καταμόσχευσις κατανάγκη
κατανάλωσις κατανίκηση κατανίκησις καταναγκασμός καταναλωτής καταναλωτισμός
καταναυμάχηση κατανεμητής κατανομή κατανόημα κατανόηση κατανόησις καταξίωση
καταξεριάς καταπάτηση καταπάτησις καταπάτι καταπέλτης καταπέτασμα καταπίεση
καταπίστευμα καταπίστευση καταπίστευσις καταπακτή καταπατητής καταπατώ
καταπιά καταπιεστής καταπιστευματοδόχος καταπιόνας καταπληξία καταπολέμηση
καταποτήρας καταπράυνση καταπτόηση καταπτόησις καταπόνηση καταπόνησις
καταπόντισις καταπόπλους καταπότης καταπότι καταράχι καταρίθμηση καταρίθμησις
καταρράκτης καταρράκωση καταρράκωσις καταρράχτης καταρρίχηση καταρροή
κατασάρκιο κατασήμανση κατασίγαση κατασβεστήρ κατασβεστήρας κατασκήνωση
κατασκευάστρια κατασκευή κατασκευαστής κατασκεύασμα κατασκηνωτής κατασκηνώτρια
κατασκοπεία κατασκόπευση κατασκόπευσις κατασπάραξη κατασπίλωση κατασπίλωσις
κατασπατάλησις καταστάλαγμα κατασταλαχτή καταστατικό καταστατό καταστηματάρχης
καταστιχογράφος καταστιχογραφία καταστολέας καταστολή καταστρατήγηση
καταστρεπτικότητα καταστροφέας καταστροφή καταστροφεύς καταστροφισμός
καταστροφολόγος κατασυκοφάντηση κατασυκοφάντησις κατασχέτης κατασχέτις
κατασώτευση κατασώτευσις κατατεμαχισμός κατατομή κατατονία κατατοπισμός
κατατριβή κατατρόπωση κατατρόπωσις κατατόπι κατατόπιση κατατόπισις καταυγασμός
καταυλισμός καταφερτζής καταφερτζού καταφορά καταφρονήτρα καταφρονήτρια
καταφρονητής καταφρόνεση καταφρόνηση καταφρόνια καταφυγή καταφύγιο καταχανάς
καταχεριά καταχθονιότητα καταχνιά καταχράστρια καταχραστής καταχτητής
καταχώρηση καταχώριση καταψήφιση καταψιά καταψύκτης καταϊφι καταύγαση
κατεβατό κατεδάφιση κατεδάφισις κατεξουσιασμός κατεπάνω κατεργάρης
κατεργαριά κατεργασία κατερινιώτης κατεστημένο κατευθυντικότητα κατευνασμός
κατευόδωση κατευόδωσις κατεχόμενα κατεύθυνση κατεύθυνσις κατζέλο κατζίο
κατηγορηματικότης κατηγορηματικότητα κατηγορητήριο κατηγοριοποίηση
κατηγορούμενη κατηγορούμενο κατηγορούμενος κατηγόρημα κατηγόρια κατηφοριά
κατηφόρισμα κατηχήτρια κατηχητής κατιδεασμός κατιμάς κατιμέρι κατινιά κατιούσα
κατιφές κατιόν κατιόντες κατμάς κατοίκηση κατοίκησις κατοίκιση κατοικία
κατολίσθηση κατολίσθησις κατονομασία κατονόμαση κατοπτρισμός κατοστάευρο
κατοστάρι κατοστάρικο κατουρλής κατουρλιά κατουρλιό κατουρλού κατοχή
κατοχρονίτισσα κατοχύρωση κατοχύρωσις κατούρημα κατράμι κατράμωμα κατρακύλα
κατρακύλι κατρακύλισμα κατραμόκολος κατραμόκωλος κατραμόπανο κατραμόχαρτο
κατρουλιάρης κατρουλιό κατς κατσάβραχο κατσάδα κατσάδιασμα κατσάρωμα κατσί
κατσίκα κατσίκι κατσαβίδι κατσαμάκι κατσαμπρόκος κατσαπλιάς κατσαρίδα
κατσαριδοκτόνο κατσαρολάκι κατσαρολικό κατσαρόλα κατσαρόλι κατσιαπλιάς
κατσιβελιά κατσικάκι κατσικάς κατσικοκλέφτης κατσικοκλέφτρα κατσικοπρόβατα
κατσικούλα κατσικόδρομος κατσιποδιά κατσιφάρα κατσουλιέρης κατσουφιά κατσούλα
κατσούνα κατσούφιασμα κατωμεριά κατωμυλόπετρα κατωσάγονο κατωσέντονο
κατωτερότης κατωτερότητα κατωφέρεια κατόπτευση κατόπτευσις κατόρθωμα κατόρθωση
κατώγι κατώι κατώρευμα κατώφλι καυκάσιος καυκί καυκαλήθρα καυκιά καυλί
καυλίτσα καυλιτζέκι καυλοκέρατο καυλομπεμπέκα καυλορόπανο καυλός καυλόφλασκο
καυσαέριο καυσαλγία καυστήρας καυστηρατζής καυστικοποίηση καυστικότητα
καυτήρας καυτηρίαση καυτηριασμός καυχηματίας καυχησιά καυχησιάρα καυχησιολογία
καυχησιολόγος καφάς καφάσι καφάσι καφέ καφέ-αμάν καφέα καφές καφασωτό καφεΐνη
καφεδάκος καφεδούμπα καφεζυθεστιατόριο καφεζυθοπώλης καφεκοπτείο καφεκούτι
καφεμαντεία καφενές καφενείο καφενεδάκι καφεοφυτεία καφεποσία καφεπότης
καφεσαντάν καφεστίαση καφετέρια καφετί καφετερία καφετζής καφετζού καφετιά
καφεϊνισμός καφεόδεντρο καφρίλα καφτάνι καφωδείο καχεκτικότητα καχεξία
καψάλα καψάλισμα καψακίωση καψικό καψικόν καψιμί καψιμιτζής καψουροτράγουδο
καψούλι καψούρα καψούρης καψόνι καψύλιο καψύλλιο καψώνι καϊκάκι καϊκοβάπορο
καϊμάκι καϊμακάμης καϊμακλής καϊμακλίκι καϊξής καϊσί καϊσιά καύαξ καύηξ
καύκος καύλα καύλωμα καύμα καύση καύσιμα καύσιμο καύσος καύσων καύσων καύσωνας
καύχημα καύχηση καύχος κβάζαρ κβάντα κβάντιση κβάντο κβάντωση κβαντανόπτηση
κβαντισμός κβαντοδυφίο κβαντοκοσμολογία κβαντοκυματική κβαντομηχανική
κβαντοποίηση κβαντοσήραγγα κβαντοχρωμοδυναμική κε κείμενο κείος κεδρόξυλο
κειμήλιο κειμήλιον κειμενάκι κειμενογράφος κειμενολογία κειμηλαρχείο κεκάκι
κεκράκτης κεκρύφαλος κελάδημα κελάηδημα κελάηδισμα κελάιδημα κελάιδισμα
κελάρι κελάρισσα κελάρυσμα κελέκι κελί κελαηδισμός κελαρυσμός κελαϊδισμός
κελεμπία κελεπούρι κελευστής κελιώτης κελλάρης κελλάρι κελλάρισσα κελλί
κεμέρι κεμαλισμός κεμαλιστής κεμεντζές κεμπάπ κενοδοξία κενοθάλαμος κενολογία
κενοσωμάτιο κενοτάφιο κενοτάφιον κενοφοβία κεντήστρα κεντήτρια κεντίδι
κεντελαπόνκο κεντητική κεντιά κεντράδι κεντράκι κεντράρισμα κεντρί κεντρικότης
κεντροθολίτης κεντρομερές κεντροσωμάτιο κενυάτης κενό κενότητα κεράκι κεράμωση
κεράσι κεράστρα κεράτιο κεράτσα κεράτωμα κερήθρα κερί κεραία κεραλοιφή
κεραμίδα κεραμίδι κεραμίδωμα κεραμίδωση κεραμίδωσις κεραμίς κεραμίστας
κεραμείο κεραμευτική κεραμεύς κεραμιδάδικο κεραμιδάς κεραμιδί κεραμιδαριό
κεραμιδόγατος κεραμιδόχωμα κεραμική κεραμικό κεραμιτζής κεραμιώτης
κεραμοποιία κεραμοποιείο κεραμοποιός κεραμοσκεπή κεραντζής κερασάκι κερασέα
κερασανθός κερασιά κερασοσυλλέκτης κεραστής κερασφόρος οχιά κερατάκι κερατάς
κερατέα κερατίαση κερατίασις κερατίνη κερατίτιδα κερατζής κερατιώτης
κερατσινιώτης κεραυνοβολία κεραυνοβόλημα κεραυνοβόληση κεραυνοβόλησις
κεραυνοπληξία κεραυνός κεραύνωση κεραύνωσις κερδομανία κερδοσκοπία κερδοσκόπος
κερετσές κερκίδα κερκίς κερκυραίος κερκόπορτα κερματισμός κερματοδέκτης
κεροδοσιά κεροπάνι κεροστάτης κερυνειώτης κερχανάς κερχανές κερχανατζής
κεσάτι κεσέμι κεσές κεσεδάκι κεσκέκι κεστός κετελαπόνγκο κετιμίνη κετσές
κετόνη κεφάλα κεφάλαιο κεφάλας κεφάλι κεφίρ κεφαλάκι κεφαλάρι κεφαλή κεφαλίδα
κεφαλαιαγορά κεφαλαιμάτωμα κεφαλαιοκράτης κεφαλαιοκράτις κεφαλαιοκράτισσα
κεφαλαιοκρατισμός κεφαλαιοποίηση κεφαλαιοποίησις κεφαλαιούχος κεφαλαλγία
κεφαλιάτικο κεφαλικός φόρος κεφαλλονίτης κεφαλογραβιέρα κεφαλοκλείδωμα
κεφαλοπάνι κεφαλοποίηση κεφαλοσπορίνες κεφαλοτύρι κεφαλοχώρι κεφαλόβρυση
κεφαλόδεσμος κεφαλόποδα κεφαλόπονος κεφαλόσκαλο κεφιροκαλλιέργεια κεφιροποιός
κεφιρόκοκκος κεφιρόκοκκους κεφιρόσπορος κεφιρόσπορους κεφτές κεφτεδάκι
κεχρί κεχριμπάρι κηδεία κηδεία κηδεμονία κηδεμόνας κηδεμόνευση κηδεστής
κηδευτής κηδοσύνη κηκίδα κηκίς κηλίδα κηλίδωση κηλεπίδεσμος κηπάκι κηπάκος
κηπαλάκι κηποκομία κηποτάφιο κηπουρική κηπουρός κηπούπολη κηπόγλυπτο κηρέλαιο
κηρίο κηραλοιφή κηρογραφία κηροειδή κηροζίνη κηρομαντεία κηρομπογιά κηροπήγιο
κηροπλαστείο κηροπλαστική κηροποιείο κηροποιός κηροσβέστης κηροστάτης
κηρός κηρύκειο κητέλαιο κητόσπερμα κηφήνας κηφηναριό κιάκια κιάλι κιάλια
κιαμέτι κιβδηλεία κιβδηλοποιία κιβδηλοποιός κιβούρι κιβωτός κιβώριο κιβώτιο
κιγκλίδωμα κιγκλίς κιθάρα κιθαρίστα κιθαρίστας κιθαρίστρια κιθαρισμός
κιθαρωδός κικεϊμηλιά κικινέλαιο κιλάτα κιλίμι κιλαηδισμός κιλαϊδισμός
κιλλίβαντας κιλοβάτ κιλοβατώρα κιλτ κιλό κιλότα κιλότο κιμάς κιμονό
κιμπάρης κιμπαριλίκι κιμπούτς κιμωλία κιμωλιάτης κιμωλιάτισσα κινάρα κινέζα
κινέζος κινίνη κινίνο κιναίδιον κιναιδισμός κιναισθησία κινδυνολογία
κινεζικά κινηματίας κινηματική κινηματικός κινηματιστής κινηματογράφηση
κινηματογραφία κινηματοθέατρο κινηματόγραφος κινησιοθεραπεία κινησιοθεραπευτής
κινησιομετρία κινησιοσκόπιο κινητήρας κινητικότης κινητικότητα κινητισμός
κινητοποίησις κινητό κινιαρουάντα κιννάβαρι κιννάμωμον κινναμαλδεΰδη κινολόνες
κιονίσκος κιονίτης κιονοστοιχία κιονόκρανο κιοπέκι κιοπρουλής κιοτής κιουρί
κιοφτές κιούγκι κιούπι κιούριο κιούρτος κιρ κιραντζής κιρατζής κιργίζιος
κιργιστανικά κιρικίτι κιρκάετος κιρκίρι κιρκασιανά κιρκινέζι κιρμάς κιρούντι
κιρσοκήλη κιρσορραγία κιρσός κιρχανάς κισμέτ κισμέτι κισσέλαιο κισσός κιτ
κιτρέλαιο κιτρίνισμα κιτριά κιτρινάδα κιτρινάδι κιτρινίλα κιτρινισμός
κιτρολέμονο κιτρολεμονιά κιτρόμηλο κιτς κιτσαριό κιχ κιόσα κιόσκι κλάδα
κλάδευση κλάδευσις κλάδος κλάδωμα κλάκα κλάμα κλάξον κλάπα κλάρα κλάσιμο
κλάψα κλάψας κλάψιμο κλέμα κλέος κλέπτης κλέφταρος κλέφτης κλέφτρα κλέψιμο
κλήμα κλήρα κλήριγκ κλήρινγκ κλήρος κλήρωση κλήρωσις κλήση κλήσις κλήτευση
κλίβανος κλίκα κλίμα κλίμακα κλίνη κλίνκερ κλίριγκ κλίρινγκ κλίση κλίτος
κλαβεσέν κλαβεσίνο κλαβιέ κλαβικόρντ κλαβικύμβαλο κλαγγή κλαδάκι κλαδί
κλαδευτήρα κλαδευτήρι κλαδευτής κλαδεύτρα κλαδεύτρια κλαδολόγιο κλαδόγραμμα
κλακάζ κλακέρ κλακαδόρος κλαμούρα κλαμπ κλαμπάκι κλανιά κλαούρα κλαπάτσα
κλαπατσίμπαλα κλαπατσίμπαλο κλαπατσίμπανο κλαράκι κλαρί κλαρίνο κλαρίτης
κλαρινετίστας κλαρινογαμπρός κλασέρ κλασαυχενισμός κλασικίστρια κλασικισμός
κλασικός κλασματοποίηση κλατς κλαυθμυρισμός κλαυθμός κλαυθμών κλαυσίγελος
κλαψοπούλι κλαψούρα κλαψούρισμα κλείδα κλείδωμα κλείδωση κλείθρο κλείσιμο
κλειδάκι κλειδάριθμος κλειδί κλειδί πίπας κλειδαράς κλειδαριά κλειδαρότρυπα
κλειδοκράτορας κλειδοκρατόρισσα κλειδοκύμβαλο κλειδομαντεία κλειδοπίνακο
κλειδωνιά κλειδόχορδο κλειθροποιός κλειομετρία κλεισιάδα κλεισούρα
κλειστοφοβία κλειστότητα κλεισώρεια κλειτορίδα κλειτοριδεκτομή κλειτοριδισμός
κλεπταποδόχος κλεπτοκρατία κλεπτομανία κλεφταποδόχος κλεφταράκι κλεφταράκος
κλεφταρματολός κλεφταρού κλεφτοκοτάς κλεφτοπόλεμος κλεφτοσυκάς κλεφτουριά
κλεφτρόνι κλεφτόπουλο κλεψίτυπο κλεψιά κλεψιγαμία κλεψιτυπία κλεψύδρα
κληματαριά κληματσίδα κληματόβεργα κληματόφυλλο κληρικαλισμός κληρικοκρατία
κληροδοσία κληροδοσιά κληροδότημα κληροδότης κληροδότηση κληροδότρια
κληροκρατία κληρονομησιμότητα κληρονομητήριο κληρονομιά κληρονομικότης
κληρονόμος κληρουχία κληρούχος κληρωτίδα κληρωτίς κληρωτός κλητήρ κλητήρας
κλιβανισμός κλικ κλικάρισμα κλιμάκιο κλιμάκωση κλιμακοστάσιο κλιμακτήριος
κλιματιστικό κλιματογραφία κλιματοθεραπεία κλιματολογία κλινάμαξα κλινάρι
κλινοζυγός κλινοσκέπασμα κλινοστρωμνή κλισέ κλισιοσκόπιο κλιτύς κλοάκη κλοιός
κλονισμός κλοπή κλοπιμαία κλοτσιά κλοτσοπατινάδα κλοτσοσκούφι κλου κλουβί
κλούβα κλούβιασμα κλυδωνισμός κλωβοστοιχία κλωβός κλωθογύρισμα κλωνάρι κλωνί
κλωνιά κλωνισμός κλωνοποίηση κλωνοστοιχείο κλωνωτής κλωσοπούλι κλωστάρα κλωστή
κλωστίτσα κλωστοποίηση κλωστοϋφαντήριο κλωστοϋφαντουργία κλωστοϋφαντουργείο
κλωστούλα κλωστρίδιο κλωσόπουλο κλωτσιά κλόουν κλότσος κλύδων κλύσμα κλώνος
κλώση κλώσημα κλώσιμο κλώσμα κλώστης κλώστρα κλώστρια κλῶνος κνήμη κνίδωση
κνησμός κνισάρι κνούτο κνώδακας κνώδαλο κοάλα κοίλον κοίλωμα κοίμηση κοίμησις
κοίτασμα κοίτη κοασμός κοβάλτιο κογιότ κογκλάβιο κογκολέζος κογκρέσο κογχύλη
κοζανίτης κοιλάδα κοιλάκανθος κοιλέντερα κοιλία κοιλαδογέφυρα κοιλαράς
κοιλεντερωτά κοιλιά κοιλιακοί κοιλιαλγία κοιλιογραφία κοιλιοκήλη
κοιλοδοκός κοιλοποδία κοιλό κοιλόπονος κοιλότης κοιλότητα κοιμήσης κοιμηθιά
κοιμητήριο κοιμητηριάρης κοινή κοινή λογική κοινοβίτης κοινοβίωση κοινοβιάτης
κοινοβούλιο κοινοβόρι κοινογαμία κοινοκτημοσύνη κοινολογία κοινολόγηση
κοινοποίηση κοινοποίησις κοινοπολιτεία κοινοπραξία κοινοτάρχης κοινοτάφιο
κοινοτισμός κοινοτοπία κοινοτυπία κοινωνία κοινωνικοποίηση κοινωνικοποίησις
κοινωνιοβιολογία κοινωνιογλωσσολογία κοινωνιοθεραπεία κοινωνιολογία
κοινωνιομετρία κοινωνιοπάθεια κοινωνιοψυχολογία κοινωνισμός κοινωνιόγραμμα
κοινωνιόλεκτο κοινωνιόλεκτος κοινωνός κοινωφέλεια κοινωφελία κοινό κοινόβιο
κοινότητα κοινόχρηστα κοιτίδα κοιτασματολογία κοιτώνας κοκ κοκάλα κοκίτης
κοκαλάκι κοκεταρία κοκκάρι κοκκίαση κοκκίνισμα κοκκίο κοκκίωμα κοκκίωση
κοκκινάδα κοκκινάδι κοκκινέλι κοκκινίλα κοκκινιώτης κοκκινογούλι κοκκινολαίμης
κοκκινοπίπερο κοκκινοφάσουλο κοκκινόχωμα κοκκιοκύτταρο κοκκιωμάτωση
κοκκομετρία κοκκοφοίνικας κοκκύτης κοκκώνα κοκομπλόκο κοκοράκι κοκορέτσι
κοκορόπουλο κοκοτίτσα κοκοτούλα κοκοφοίνικας κοκοφοινικόσχοινο κοκτέιλ κοκό
κοκότα κολάζ κολάι κολάν κολάρο κολάρος κολάστρα κολέγιο κολίβριο κολίγας
κολίτιδα κολακεία κολαούζο κολαούζος κολασμός κολαστήριο κολατσιό κολαφισμός
κολεγιόπαιδο κολεκτίβα κολεκτιβισμός κολεκτιβοποίηση κολεκτομή κολεχτίβα
κολεχτιβοποίηση κολεόπτερα κολεός κολεόσπασμος κολιέ κολιές κολιγιά
κολικός κολιμπρί κολιτηριτζής κολιτσίνα κολιός κολλάζ κολλάρισμα κολλέγιο
κολλέτα κολλαγόνο κολλαγόνωση κολλεγία κολλεκτέρ κολλεκτιβισμός κολλητήρι
κολλητσίδα κολλητός κολλιτσίδα κολλοσές κολλυβάς κολλυβισμός κολλυβιστής
κολλυβόγραμμα κολλύριο κολλώδες κολοβακτηρίδιο κολοκάσι κολοκασόσουπα
κολοκυθιά κολοκυθοκεφτές κολοκυθοκορφάδα κολοκυθοκορφάδες κολοκυθόπιτα
κολοκυθόσπορος κολοκύθα κολοκύθας κολοκύθι κολοκύνθη κολομβιανός κολομπίνα
κολομπαράς κολονάκι κολονοσκόπηση κολονοσκόπιο κολοσσός κολοτούμπα κολοφώνας
κολούμπρα κολπίσκος κολπίτιδα κολπίτις κολπατζής κολπατζού κολπεκτομή
κολποκήλη κολπορραγία κολπορραφή κολπορραφία κολποσκόπηση κολποσκόπιο
κολπόρροια κολτσίνα κολυμβήθρα κολυμβήτρια κολυμβητήριο κολυμβητής κολυμπήθρα
κολυμπίδια κολυμπηθρόξυλο κολυμπητής κολχόζ κολωνικά κολόβιο κολόβωμα κολόβωση
κολόνα κολόνια κολύβριον κολύμβηση κολύμπημα κολύμπι κολώνα κομάντος κομήτης
κομβίον κομβιοδόχη κομβολόγιον κομβόι κομεντί κομητεία κομισάριος κομισάριος
κομιτάτο κομιτατέρ κομιτατζής κομμάρα κομμάτι κομμάτιασμα κομμέρκιον κομμίωση
κομματάκι κομματάρα κομματάρχης κομματίδιο κομματικοποίηση κομματισμός
κομματονεολαία κομματοσκυλίαση κομματοσκύλιασμα κομματόσκυλο κομμεορρητίνη
κομμουνισμός κομμουνιστής κομμουνιστοσυμμορίτης κομμουνόσκυλο κομμούνα
κομμωτήριο κομμωτής κομμός κομμώτρια κομοδίνο κομοδινάκι κομορανός κομοτηναίος
κομουναλισμός κομουνισμός κομουνιστής κομούνα κομπάρσα κομπάρσος κομπάστρια
κομπίνα κομπανία κομπασμός κομπαστής κομπιαδόρος κομπινεζόν κομπιουτεράκι
κομπιουτεράς κομπιουτερόφλωρος κομπιούτερ κομπλέξ κομπλέρ κομπλιμάν
κομπογιαννίτης κομπογιαννίτισσα κομπογιαννιτισμός κομποδετική κομπολογάδικο
κομπολόγα κομπολόγι κομπολόι κομπορρήμονας κομπορρημοσύνη κομποσκοίνι
κομποσχοίνι κομπρέσα κομπρεσέρ κομπωτής κομπόδεμα κομπόδεση κομπόστ κομπόστα
κομφορμίστας κομφορμίστρια κομφορμισμός κομφορμιστής κομφουκιανισμός κομφόρ
κομψογράφος κομψογραφία κομψοτέχνημα κομψοτέχνης κομψοτεχνία κομψότης
κομό κονάκι κονέ κονία κονίαμα κονίασις κονίστρα κονακτζής κονβόι κονγκολέζος
κονδύλι κονδύλιο κονδύλωμα κονεομεταλλουργία κονεσέρ κονιάκ κονιακάκι
κονιδιάρης κονικλοτροφία κονικλοτροφείο κονικλοτρόφος κονιοποίηση κονιοποίησις
κονιορτοποίηση κονιορτοστρόβιλος κονιορτός κονιοσκόπιο κονιτσιώτης κονιόρδος
κονκλάβιο κονκορδάτο κοννοχαίτη κονσέρβα κονσέρτο κονσεπτουαλισμός
κονσερβοκούτι κονσερβολιά κονσερβοποίηση κονσερβοποίησις κονσερβοποιία
κονσερβοποιός κονσερτίνα κονσομέ κονσομασιόν κονσοματέρ κονσοματρίς
κονσουμασιόν κονστρουκτιβισμός κονσόλα κονσόρτσιουμ κοντάκι κοντάκιο κοντάκτ
κοντέινερ κοντέρ κοντέσα κοντίνουο κοντακιά κοντανάσασμα κονταριά κονταρομάχος
κονταροπίνελο κονταροχτύπημα κονταρόξυλο κονταυγή κοντεσίνα κοντοβράκα
κοντοβρακάς κοντογούνι κοντομερί κοντοπούτανο κοντοσούβλι κοντούλα κοντούρα
κοντράλτο κοντράστ κοντράτο κοντραμπάντο κοντραμπάσο κοντραμπασίστας
κοντραπάσο κοντραπλακέ κοντραπούντο κοντρόλ κοντσέρτο κοντσίνα κοντυλοφόρος
κοντόξυλο κοντός κοντόσταβλος κοντότα κοντύλι κονφερασιέ κονφετί κονόμα
κοπάδι κοπάνα κοπάνισμα κοπάτσι κοπάτσι κοπέλα κοπέλι κοπή κοπή κοπίδι κοπίς
κοπανατζής κοπανατζού κοπανιστή κοπεκιά κοπελάκι κοπελάρα κοπελίτσα κοπελιά
κοπελούδα κοπελούδι κοπετός κοπιράιτ κοπλιμέντο κοπρίτης κοπρίτισσα κοπριά
κοπρολαγνεία κοπρολαλία κοπρολογία κοπρολόγος κοπροφαγία κοπροφιλία κοπρόσκυλο
κοπρώνας κοπτάτσια κοπτήρας κοπτική κοπτοραπτού κοπυράιτ κορ ντε μπαλέ κοράκι
κοράλλι κοράνι κοράσι κορέος κορίγονος κορίνθιος κορίστας κορίτσαρος κορίτσι
κορασίδα κορασιά κορβέτα κορβανάς κορδέλα κορδέλιασμα κορδακισμός κορδελιάστρα
κορδόνι κορεάτης κορεάτισσα κορεατικά κορεσμός κοριτσάκι κοριτσάρα κοριτσομάνι
κοριός κορμάκι κορμάρα κορμί κορμοράνος κορμοστασιά κορμός κορμόχαρτο
κορνάρισμα κορνέ κορνέτα κορνέτο κορνίζα κορνίζωμα κορνιαχτός κορνιζάδικο
κορνιζάς κορνιζοποιείο κορνιζοποιός κορνουαλικά κορνφλάουρ κορνφλέικς
κοροναϊός κορονοϊός κοροπλάστης κοροπλαστική κοροϊδάκι κοροϊδάρα κοροϊδία
κοροϊδευτής κοροϊδεύτρα κοροϊδιά κοροϊδιλίκι κορούλα κορούνδιο κορπορατισμός
κορσές κορσικανικά κορτάκιας κορτιζόλη κορτιζόνη κορτικοειδές κορτικοειδή
κορτσάρα κορυβαντισμός κορυδαλλός κορυφή κορυφαίος κορυφογραμμή κορφάδα κορφή
κορφοβούνι κορφολόγημα κορφούλα κορωνίδα κορωνιδιάτης κορωνιδιάτισσα
κορόδιο κορόζο κορόιδεμα κορόιδο κορόμηλο κορόμπλο κορόνα κορύνα κορύνη
κορύφωση κορώνα κορώνη κοσή κοσιά κοσκίνιση κοσκίνισμα κοσκινάς κοσκινού
κοσμάρα κοσμήτορας κοσμήτρια κοσμετολόγος κοσμηματογράφος κοσμηματογραφία
κοσμηματοποιία κοσμηματοποιός κοσμηματοπωλείο κοσμηματοπώλης κοσμηματοπώλισσα
κοσμητεία κοσμητική κοσμικότητα κοσμιότης κοσμιότητα κοσμοβιολογία
κοσμογενεά κοσμογενετικός κοσμογεωδαισία κοσμογνωσία κοσμογονία κοσμογραφία
κοσμοδρόμιο κοσμοείδωλο κοσμοεικόνα κοσμοθεωρία κοσμοθεώρηση κοσμοκαλόγερος
κοσμοκράτορας κοσμοκράτωρ κοσμοκρατορία κοσμοκρατόρισσα κοσμολογία κοσμολόγος
κοσμοπεποίθηση κοσμοπληθωρισμός κοσμοπλημμύρα κοσμοπολίτης κοσμοπολίτισσα
κοσμοπολιτισμός κοσμοσυρροή κοσμοσύστημα κοσμοτοπογραφία κοσμοχαλασιά
κοσμοχαρτογραφία κοσμοχρονολόγιο κοσμόπολη κοσταρικανός κοστολόγηση κοστολόγιο
κοστουμαρισμένος κοστούμι κοτέτσι κοτζάμπασης κοτιγιόν κοτλέ κοτοκροκέτα
κοτοπουλάκι κοτούλα κοτρόνα κοτρόνι κοτρώνα κοτρώνι κοτσάνα κοτσάνι κοτσάρισμα
κοτσαδόρος κοτσανάκι κοτσανέλο κοτσύφι κοτυληδόνα κοτόπουλο κοτόσουπα κοτύλη
κουάκερ κουάνζα κουάρκ κουάφ κουίζ κουίντα κουαζισωματίδιο κουαρτέτο
κουβάλημα κουβάρα κουβάρι κουβάριασμα κουβάς κουβέλι κουβέντα κουβέρ κουβέρτα
κουβαλήτρα κουβαλητής κουβαλητός κουβανέζος κουβανός κουβαράκι κουβαρίστρα
κουβαρντάς κουβαρνταλίκι κουβαρντού κουβεντιάρης κουβεντολόι κουβεντούλα
κουβερνάντα κουβερτούρα κουβεϊτιανός κουβούκλιο κουδομηλιά κουδουνάκι
κουδουνίστρα κουδουνισμός κουδούνα κουδούνι κουδούνισμα κουζίνα κουζινάκι
κουζινομάχαιρο κουζουλάδα κουκέτα κουκί κουκιά κουκκίδα κουκκιδίτσα κουκλάκι
κουκλίτσα κουκλοενσαρκωτής κουκλοθέατρο κουκλοπαίχτης κουκλόπανο κουκλόσπιτο
κουκουές κουκουβάγια κουκουλοφόρος κουκουνάρα κουκουνάρι κουκουναριά
κουκούλα κουκούλι κουκούλιον κουκούλωμα κουκούνα κουκούτσι κουλάδι κουλάκος
κουλαμάρα κουλουάρ κουλουμούντρα κουλουμούντρης κουλουράκι κουλουράς
κουλουρατζής κουλουριώτης κουλουρομηχανή κουλουρού κουλουρτζής κουλούκι
κουλούρι κουλούριασμα κουλτούρα κουλό κουλός κουμάντο κουμάσι κουμανταδόρος
κουμαντοδόρος κουμαριά κουμαρτζής κουμκάν κουμκανατζής κουμκανατζού κουμκουάτ
κουμουνισμός κουμούλ κουμούνι κουμπάνια κουμπάρα κουμπάρος κουμπάσο κουμπέ
κουμπί κουμπαράς κουμπαριά κουμπαρούλα κουμπαρούλης κουμπουλιά κουμπουριά
κουμπούρας κουμπούρι κουμπότρυπα κουνάβι κουνάδι κουνέλα κουνέλι κουναβάκι
κουνελοπνίχτης κουνελοτροφείο κουνελοτρόφος κουνελοφωλιά κουνελόσυρμα
κουνελώνας κουνενές κουνιάδα κουνιάδια κουνιάδος κουνουπάκι κουνουπίδι
κουνουπιδοσαλάτα κουνουπιδόσουπα κουνούπι κουντεπιέ κουπάκι κουπέ κουπέπι
κουπαστή κουπεπέ κουπιά κουπλέ κουπολάτης κουπόνι κουρά κουράγιο κουράδα
κουράδι κουράντες κουράντης κουράρισμα κουρέας κουρέλα κουρέλι κουρέλιασμα
κουραδομηχανή κουραδούμπα κουραδόμαγκας κουραμάνα κουραμπιές κουραμπιεδάκι
κουραφέξαλα κουρδικά κουρδικά (σοράνι) κουρδιστήρι κουρδιστής κουρείο
κουρελαρία κουρελιάρης κουρελού κουρελόχαρτο κουρζέτο κουρκουμάς κουρκουμέλα
κουρκουτάς κουρκούδιαλος κουρκούλης κουρκούμη κουρκούμι κουρκούταβλος
κουρκούτι κουρμπάνι κουρμπάτσι κουρμπέτι κουρμπαδόρος κουρμπαν-μπαϊράμι
κουρνιαχτός κουρντιστήρι κουρο σίβο κουροπαλάτης κουρουμπλιά κουρουπάκι
κουρού κουρούμπελο κουρούνα κουρούπα κουρούπης κουρούπι κουρσάρα κουρσάρος
κουρσουνιά κουρσούμι κουρσούνι κουρτέλο κουρτίνα κουρτελάτσα κουρτζής
κουρτινόβεργα κουρτινόξυλο κουσέλι κουσελιάρης κουσκουσές κουσκουσουριά
κουσκουσούρης κουσκούς κουσκούσι κουσούρι κουστουμάτος κουστουμιά κουστούμι
κουτάβι κουτάκι κουτάλα κουτάλι κουτέλα κουτί κουταβάκι κουταλάκι κουταλήθρες
κουταλιανός κουταμάρα κουτεντές κουτομόγιας κουτοπονηρία κουτοπονηριά
κουτουκάκι κουτουλιά κουτουπιέ κουτουπιές κουτουράδα κουτούκι κουτούλιακας
κουτριά κουτρουβάλα κουτσαβάκης κουτσαβάκι κουτσαβάκισσα κουτσαμάρα
κουτσογράμματα κουτσοδαιμονάκι κουτσοδουλειά κουτσοδόντα κουτσοδόντης
κουτσομούρα κουτσομπολιό κουτσομπόλα κουτσομπόλης κουτσουκέλα κουτσουλιά
κουτσουράκι κουτσοφλέβαρος κουτσούβελο κουτσούνα κουτσούπι κουτσούρεμα κουτσό
κουτόλογo κουτόφραγκος κουτόχορτο κουφάλα κουφάλογο κουφάρι κουφέτο κουφή
κουφαλιάρης κουφαμάρα κουφετοποίηση κουφιοκεφαλάκης κουφιοκεφαλάκισσα
κουφοξυλιά κουφό κουφόβραση κουφόνοια κουφότητα κουϊμτζής κουϊντέτο κοφίνα
κοφίνιασμα κοφίσι κοφινάκι κοφινάς κοφινού κοφτήριο κοχελίνη κοχλάδι κοχλίας
κοχλασμός κοχλιάριο κοχλιός κοχύλα κοχύλι κοψίδι κοψαχείλα κοψαχείλης κοψιά
κοψομέσιασμα κοψοτιμή κοψοχέρα κοψοχείλα κοψοχείλης κοϊνοβόρι κούκλα κούκλος
κούκουδο κούκουρο κούλα κούλας κούλης κούλουμα κούμαρο κούμουλο κούμουλος
κούμπωμα κούνελος κούνημα κούνια κούνιες κούπα κούρα κούραση κούρβα κούρβα
κούρβουλο κούρδισμα κούρεμα κούριερ κούριερ κούρκα κούρκος κούρμπα κούρνια
κούρντισμα κούρος κούρσα κούρσεμα κούρσος κούρτη κούσαλο κούσιον κούσπος κούτα
κούτρα κούτρημα κούτσαβος κούτσαμα κούτσικο κούτσουρο κούφωμα κράκουρα κράκτης
κράμα κράμβη κράμπα κράνη κράνο κράνος κράξιμο κράση κράσος κράσπεδο κράταιγος
κράτηση κράτος κράχτης κρέας κρέμα κρέμαση κρέμασμα κρέντιτο κρέπα κρέπι
κρήμνισις κρήμνισμα κρήνη κρήτας κρίκετ κρίκος κρίμα κρίνο κρίνον κρίνος κρίση
κρίταμο κρίτρα κραγιόν κραγιόνι κραδασμός κραιπάλη κρακ κραμβάλευρο κραμβέλαιο
κρανίο κρανιά κρανιδιώτης κρανιολογία κρανιολόγος κρανιομετρία κρανιοσκοπία
κρανιός κραξιά κρασάκι κρασάς κρασί κρασίλα κρασαριό κρασοβάρελο κρασοκανάτα
κρασοκατάνυξη κρασοπατέρας κρασοπουλειό κρασοπότηρο κρασοπότι κρασοπώλης
κρασπέδωση κρασπεδορείθρο κρατέρωμα κρατήρ κρατήρας κρατίδιο κραταίωση
κρατημός κρατητήριο κρατικοεθνικισμός κρατικοποίηση κρατισμός κρατιστής
κρατούμενη κρατούμενο κρατούμενος κρατούνι κρατούντες κραυγή κραφτ κραχ
κρεατίλα κρεατίνη κρεαταγορά κρεατοελιά κρεατομηχανή κρεατοσφαιρίδιο
κρεατοχορτόσουπα κρεατόβεργα κρεατόμυγα κρεατόπιτα κρεατόσουπα κρεατότουρτα
κρεβάτωμα κρεβατάκι κρεβατίνα κρεβαταριά κρεβατοκάμαρα κρεβατομουρμούρα
κρεμ κρεμ ντε λα κρεμ κρεμάλα κρεμάστρα κρεμέζι κρεμαγιέρα κρεμανταλάδικος
κρεμανταλού κρεμαστάρι κρεματόριο κρεμεζί κρεμμυδάκι κρεμμυδοσαλάτα
κρεμμυδόσουπα κρεμμύδι κρεολή κρεολός κρεοπωλείο κρεοπωλείον κρεοπώλης
κρεοπώλισσα κρεοσφαιρίδιο κρεοφαγία κρεούργηση κρεούργησις κρεπ κρεπάρισμα
κρεπομηχανή κρεσέντο κρετίνα κρετίνος κρετινισμός κρετσέντο κρετόν κρημνισμός
κρηπίδα κρηπίδωμα κρηπιδότοιχος κρησάρα κρησάρισμα κρησφύγετο κρητίδα κρητίς
κρητιδογραφία κρητικιά κρητικός κρι κρι-κρι κριάρι κριάς κριθάλευρο
κριθάρι κριθάρισμα κριθή κριθαράκι κριθαροκουλούρα κριθαρόσουπα κριθαρόψωμο
κρικέλι κρικητός κριμπιλάκι κρινάκι κρινοδάχτυλο κρινολίνο κρινολούλουδο
κρισιμότητα κριτήριο κριτήριον κριτής κριτικάρισμα κριτική κριτικισμός
κριτς κριτσίνι κριτσινομηχανή κριός κροάτης κροάτισσα κροατικά κροκ-γκοφρ
κροκέ κροκέτα κροκί κροκίδα κροκίδι κροκίδωση κροκοδειλάκι κροκοσυλλέκτης
κροκόδειλος κροκός κροκύδωση κρομμυδάκι κρομμύδι κρομός κροντήρι κρονόληρος
κροσσός κροτάλισμα κροτίδα κροτίς κροταλίας κροταλισμός κρουαζιέρα
κρουασάν κρουασανάκι κρουασανομηχανή κρουθεραπεία κρουνιά κρουνός κρουπιέρης
κρουστάλλι κρουστάλλιασμα κρουστό κρουτόν κρούπι κρούση κρούσις κρούσμα
κρούσταλλο κρυάδα κρυγιόρεμα κρυιαρχία κρυμοπαγία κρυογονική κρυοθεραπεία
κρυομαγνητισμός κρυομετρία κρυονική κρυοπάγημα κρυοπηξία κρυοπληξία κρυοσκοπία
κρυοστάτης κρυοσυντήρηση κρυουλιάρης κρυοφθορισμός κρυοχειρουργική κρυοχημεία
κρυπταναλυτής κρυπτεία κρυπτογράφημα κρυπτογράφηση κρυπτογράφος κρυπτογραφία
κρυπτορχιδία κρυπτό κρυπτόγαμα κρυπτόν κρυστάλλι κρυστάλλωμα κρυστάλλωση
κρυσταλλίτης κρυσταλλιδρωσία κρυσταλλικότητα κρυσταλλογραφία κρυσταλλολυχνία
κρυσταλλοτεχνία κρυσταλλοτρίοδος κρυσταλλοχημεία κρυφάκουσμα κρυφές μεταβλητές
κρυφοκοίταγμα κρυφομίλημα κρυφοπαγανίστρια κρυφοπαγανισμός κρυφοπαγανιστής
κρυφτό κρυψίνοια κρυψιβουλία κρυψιγαμία κρυψορχιδία κρυψόρχης κρυψώνα κρυψώνας
κρυόλιθος κρυόμετρο κρυόμετρον κρυόμπλαστρο κρωγμός κρόκη κρόκος κρόμμυον
κρόταλο κρόταλον κρόταφος κρότημα κρότος κρότωνας κρύο κρύπτη κρύσταλλο
κρύσταλλος κρύψιμο κρύψορχις κρύωμα κρώξιμο κτένα κτένιον κτένισμα κτέρισμα
κτήνος κτήριο κτήριον κτήση κτήσις κτήτορας κτίριο κτίριον κτίση κτίσιμο
κτίσις κτίσμα κτίστης κτίτορας κτηματίας κτηματαγορά κτηματογράφηση
κτηματομεσίτης κτηνάνθρωπος κτηνίατρος κτηνιατρική κτηνοβάτης κτηνοβάτισσα
κτηνοβασία κτηνολογία κτηνολόγος κτηνοτροφή κτηνοτροφία κτηνοτρόφος κτηνωδία
κτητικότητα κτιστικά κτυπητήρι κτυπογενής ήχος κτύπημα κτύπος κυάθιο κυάθιον
κυάμωση κυάνιο κυάνωση κυάνωσις κυαθίσκος κυαμισμός κυαμοφαγία κυανίνη
κυανόφυτο κυβάκι κυβέρνηση κυβέρνησις κυβέρνια κυβίστημα κυβίστηση κυβίστησις
κυβερνήτης κυβερνήτρια κυβερνείο κυβερνησιμότητα κυβερνητική κυβερνητισμός
κυβερνοέγκλημα κυβερνοαπάτη κυβερνοασφάλεια κυβερνοεπίθεση κυβερνοπαιχνίδι
κυβευτής κυβεύτρια κυβισμός κυβιστής κυβόλεξο κυβόλιθος κυβόφιδο κυδωνάτο
κυδωνιά κυδωνόπαστο κυδώνι κυθηροδίκης κυθνιώτης κυθνιώτισσα κυκεών κυκεώνας
κυκλαδίτης κυκλαδίτισσα κυκλικότητα κυκλοθυμία κυκλοποιητής κυκλοτρόνιο
κυκλοφορητής κυκλόραμα κυκλώνας κυλίνδησις κυλίνδρισμα κυλίνδρωση κυλίνδρωσις
κυλικείο κυλικείον κυλινδρισμός κυλινδρόμυλος κυλισιοτριβέας κυλόττα κυμάτιο
κυμάτισμα κυμαίος κυματάκι κυματαγωγή κυματική κυματισμός κυματογεννήτρια
κυματοδηγός κυματοδρομία κυματοθραύστης κυματομήκος κυματομηχανική κυματομορφή
κυματοσυνάρτηση κυμβαλισμός κυμβαλιστής κυμογράφος κυνάγχη κυνέρως κυνέρωτας
κυνήγι κυναίλουρος κυνηγάρικο κυνηγητό κυνηγιάρης κυνηγοτόπι κυνηγός
κυνηγότοπος κυνικοί κυνικός κυνικότης κυνικότητα κυνισμός κυνογομφίος
κυνοκέφαλος κυνοκομείο κυνοκτονία κυνομαχία κυνόδοντας κυνόδους κυνόμυς
κυοφορούμαι κυοφόρηση κυπάρισσος κυπέλλωση κυπαρίσσι κυπαρισσάκι κυπαρισσέλαιο
κυπαρισσόξυλο κυπαρισσών κυπαρισσώνας κυπατζής κυπελλοφόρα κυπελλούχα
κυπρί κυπρίνος κυπριακό κυπρινολάβαρο κυπροκούδουνο κυρ κυρά κυράτσα κυρία
κυρίευση κυρίευσις κυραντζής κυρατζής κυριάρχηση κυριάρχησις κυριακάτικα
κυριακό κυριακός κυριαρχία κυριλίκι κυριολεξία κυριούλα κυριούλης κυριωνύμιο
κυριότητα κυριώνυμο κυρούλα κυρτότης κυρτότητα κυρός κυστίδιο κυστίνη
κυστεΐνη κυστεκτομή κυστεογραφία κυστεοκήλη κυστεολιθοτριψία κυστεοορθοκήλη
κυστεοσκόπηση κυστεοσκόπιο κυστεοσκόπιον κυστεοτομία κυτίο κυτιοποιία
κυτοκινίνη κυτοσίνη κυτοφυσιολογία κυτταρίνη κυτταρίτιδα κυτταρίτις
κυτταρογένεση κυτταρογένεσις κυτταρογενετική κυτταρολογία κυτταρολυσία
κυτταρομετρία κυτταροπροστατευτικά κυτταροσκελετός κυτταροταξινόμηση
κυτταρόλυμα κυτταρόλυση κυτταρόπλασμα κυτταρόστομα κυττοκίνη κυτόπλασμα
κυφοπλαστική κυψέλη κυψελίδα κωδίκελλος κωδίκελος κωδίκευση κωδεΐνη
κωδικοποίηση κωδικοποίησις κωδικόνιο κωδωνισμός κωδωνοκρουσία κωδωνοκρούστης
κωδωνοστάσιο κωδωνοστάσιον κωδόνιο κωθώνι κωκ κωκυτός κωλάδικο κωλάκι
κωλάρα κωλαράκι κωλαράκος κωλαράς κωλαρού κωλικόπονος κωλικός κωλοβάρεμα
κωλογλείφτης κωλοδάχτυλο κωλοκλείδωμα κωλομέρι κωλομέρος κωλομπαράς κωλονούρι
κωλοσκάμπιλο κωλοσούσα κωλοσφούγγι κωλοτούμπα κωλοτούμπας κωλοτριβιδόνια
κωλοφάση κωλοφίλημα κωλοφαρδία κωλοφυλλάδα κωλοφωτιά κωλοχανείο κωλού
κωλόκαιρος κωλόμπαρο κωλόμυγα κωλόπαιδο κωλόπανο κωλόπονο κωλόπραμα κωλότριχα
κωλότσεπη κωλόφατσα κωλόχαρτο κωλόχορτο κωμειδύλλιο κωμειδύλλιον κωμιακίτης
κωμικοτραγωδία κωμικός κωμικότης κωμικότητα κωμωδία κωμωδιογράφος κωμωδοποιός
κωμόπολη κωμόπολις κωνάριο κωνικότης κωνικότητα κωνοτομή κωνοφόρο
κωνσταντινουπολίτικος κωνσταντινουπολίτισσα κωπηλάτης κωπηλάτισσα κωπηλασία
κωσταντινάτο κωφάλαλος κωφαλαλία κωφότης κωφότητα κόασμα κόγχη κόζι κόθορνος
κόκκαλο κόκκινη κάρτα κόκκινο κόκκος κόκκυγας κόκκυξ κόκορας κόκπιτ κόλα
κόλαξ κόλαση κόλαφος κόλεϊ κόλιαντρο κόλιαντρος κόλλα κόλλημα κόλληση κόλλυβα
κόλλυβος κόλον κόλπο κόλπος κόλπος κόλπωμα κόλπωση κόμαρον κόμαρος κόμβος κόμη
κόμησσα κόμητας κόμι κόμικ κόμικς κόμισσα κόμιστρο κόμμα κόμματος κόμμι
κόμμωσις κόμπιασμα κόμπλεξ κόμπος κόμποστ κόμπρα κόνδυλος κόνδωρ κόνιδα
κόνξα κόνσολος κόντα κόντεμα κόντες κόντης κόντρα κόντρα πλακέ κόπανο κόπανος
κόπιτσα κόπος κόππα κόπρανα κόπρανο κόπρισμα κόπτανος κόπτης κόπτης κόπτρια
κόρα κόρακας κόραξ κόρδα κόρδωμα κόρη κόρι κόριζα κόρκωμα κόρνα κόρνερ κόρνο
κόρο κόρος κόρτε κόρυζα κόρυμβος κόρφος κόρωμα κόσκινο κόσμημα κόσμηση κόσμος
κόστα κόστος κότα κότερο κότινος κότο κότσι κότσια κότσιρος κότσος κότσυφας
κόφινος κόφτης κόφτρα κόχη κόχλασμα κόψη κόψιμο κύαθος κύαμος κύανος κύβιση
κύημα κύηση κύησις κύκας κύκλος κύκλοτρο κύκλωμα κύκλωση κύκνος κύλικα κύλικας
κύλιξ κύλιση κύλισις κύλισμα κύμα κύμανση κύμανσις κύμβαλο κύμινο κύπειρος
κύπερη κύπρια κύπριος κύπρος κύρης κύριος κύρος κύρτος κύρτωμα κύρτωση
κύρωση κύρωσις κύστη κύστις κύτος κύτταρο κύτταρον κύφωση κύφωσις κύψελος κύων
κώδιξ κώδων κώδωνας κώθων κώλο κώλον κώλος κώλυμα κώλωμα κώμα κώμη κώμος
κώνος κώνωπας κώνωψ κώος κώπη κώτης κώφωση κώφωσις κώχη κῆυξ λάβα λάβαρο
λάβντανο λάβρα λάβωμα λάγγεμα λάγιαση λάδι λάδωμα λάζος λάθεμα λάθος λάθυρος
λάιτ μοτίβ λάκα λάκης λάκκα λάκκος λάκκωμα λάκτισμα λάκωνας λάλημα λάλλαρος
λάμια λάμνισσα λάμντα λάμπα λάμπος λάμψη λάντζα λάντσα λάξευμα λάξευση
λάπαθο λάπατο λάπις λάζουλι λάπτοπ λάρνακα λάρναξ λάρος λάρυγγας λάρυγξ λάσο
λάσπωμα λάστιχο λάτα λάτεξ λάτρα λάτρης λάτρις λάτρισσα λάφι λάφυρο λάχανο
λέαινα λέβα λέβητας λέι λέιζερ λέκιασμα λέκιθος λέκτης λέκτορας λέλεκας
λέμβος λέμφος λέμφωμα λέξη λέξημα λέξις λέοντας λέπι λέπρα λέπρωση λέπτυνση
λέπυρον λέρα λέρας λέριος λέρωμα λέσι λέσκα λέσχη λέτσος λέχος λήγουσα λήζινγκ
λήθη λήκυθος λήμη λήμμα λήμνος λήξη λήπτης λήπτρια λήρος λήσταρχος λήστευση
λίβανος λίβας λίβελος λίβρα λίβυα λίβυος λίγδα λίγκα λίγνεμα λίγωμα λίζινγκ
λίθος λίκνισμα λίκνο λίμασμα λίμνασμα λίμνη λίμπα λίμπιντο λίμπο λίμπρα
λίπανσις λίπασμα λίπος λίπωμα λίρα λίστα λίστρονο λίστρος λίτρα λίτρο λίφτινγκ
λα λαΐνα λαήνα λαήνι λαίδη λαίλαπα λαίλαψ λαβή λαβίδα λαβαμπό λαβαρολογία
λαβομάνο λαβούτο λαβράκι λαβυρινθίτιδα λαβυρινθίτις λαβωματιά λαβύρινθος
λαγάνια λαγάρα λαγάρισμα λαγάς λαγήνα λαγήνι λαγιαρνί λαγκάδα λαγκάδι λαγκί
λαγνεία λαγοθήρας λαγοθηρία λαγοκυνήγι λαγοκυνηγός λαγονοψοΐτης λαγοπροβιά
λαγοτόμαρο λαγουδάκι λαγουδέρα λαγουδίνα λαγουμιστής λαγουμιτζής λαγουμτζής
λαγούτο λαγωνίκα λαγωνικό λαγωχειλία λαγόνα λαγός λαγύνι λαγών λαγώχειλο
λαδάδικο λαδάκι λαδάς λαδέμπορας λαδέμπορος λαδίλα λαδεμπόριο λαδερό λαδιά
λαδικό λαδινικά λαδοβάρελο λαδοελιά λαδολέμονο λαδολιά λαδομηλιά λαδομπογιά
λαδοτύρι λαδωτήρι λαδόκολλα λαδόξιδο λαδόπανο λαδόχαρτο λαδόψωμο λαζάνια
λαζάρηδες λαζαράκι λαζαρέτο λαζαρέττο λαζαρίνα λαζαρίτσα λαζαρικά λαζαρικό
λαζαρούδι λαζουρίτης λαθάκι λαθούρι λαθράκιασμα λαθρέμπορας λαθρέμπορος
λαθραναγνώστης λαθραναγνώστρια λαθρανασκαφή λαθραπόβαση λαθρεμπορία
λαθρεμπόριο λαθρεμπόριον λαθρεπιβάτης λαθρεπιβάτις λαθρεπιβάτισσα λαθροβίωση
λαθρογαμία λαθροθήρας λαθροθηρία λαθρομετανάστης λαθρομετανάστρια
λαθροφαγία λαθροχειρία λαθροϋλοτομία λαθροϋλοτόμος λαθυρισμός λαιβουλόζη λαιμά
λαιμαριά λαιμητόμος λαιμοδέτης λαιμουδιά λαιμόκοψη λαιμόλειρο λαιμός λακ
λακέρδα λακές λακεδαιμόνιος λακιρντί λακκάκι λακκούβα λακουβίτσα λακριντί
λακωνικότης λακωνικότητα λακωνισμός λαλάκια λαλές λαλαγγίδα λαλαγγίτα
λαλητής λαλητό λαλιά λαλοπάθεια λαλούμενα λαμέ λαμαρίνα λαμαρινατζής
λαμαρινόβιδα λαμαρκισμός λαμαϊσμός λαμβδακισμός λαμδακισμός λαμινάρισμα
λαμνοκόπι λαμνοκόπος λαμογιά λαμπάδα λαμπάδιασμα λαμπάκι λαμπάντα λαμπάς
λαμπαδηδρομία λαμπαδηδρόμος λαμπαδηφορία λαμπαδηφόρος λαμπατέρ λαμπεράδα
λαμπικάρισμα λαμπιόνι λαμποκοπή λαμποκόπημα λαμποκόπι λαμπράδα λαμπραντόρ
λαμπρότητα λαμπτήρ λαμπτήρας λαμπυρίδα λαμπυρίς λαμπόγυαλο λαμπύρισμα λαμψάνη
λανάρα λανάρι λανάρισμα λαναράς λανθάνιο λανολίνη λανσάρισμα λαντίνο λαντζιέρα
λαντό λαξευτής λαογράφος λαογραφία λαοθάλασσα λαοκράτης λαοκράτισσα λαοκρατία
λαοκρισία λαολειχία λαοπλάνος λαοσύναξη λαοτινά λαουτέρης λαουτζίκος
λαούτο λαπάρα λαπάς λαπαροσκόπηση λαπαροσκόπιο λαπαροτομία λαπωνικά λαρδί
λαρισινός λαρυγγίτιδα λαρυγγίτις λαρυγγισμός λαρυγγολογία λαρυγγολόγος
λαρυγγοσκόπησις λαρυγγοσκόπιο λαρυγγοσκόπιον λαρυγγοτομία λαρύγγι λασιθιώτης
λασπολογία λασπολόγος λασπομάχος λασπομαχία λασπονέρι λασποτόπι λασπουριά
λασπόλουτρο λασπόνερο λασπότοπος λασπόχεντρα λαστέξ λαστιχάκι λατάκι λατάνια
λατέρνα λατίνι λατίνος λατερίτης λατερνατζής λατικόν λατινικά λατινισμός
λατινοκρατία λατιφούντιο λατομία λατομείο λατομείον λατρεία λατρευτικότητα
λατόμευση λατόμημα λατόμηση λατόμησις λατόμι λατόμος λατύπη λαυριώτης λαφίνα
λαφαζανιά λαφιάτης λαφυραγωγία λαφυραγωγός λαφυραγώγηση λαφυραγώγησις
λαχάνιασμα λαχανάκι λαχανάς λαχανί λαχανίδα λαχαναγορά λαχανικό λαχανοκομία
λαχανοντολμάς λαχανοπωλείο λαχανοπωλείον λαχανοπώλης λαχανοπώλις λαχανοπώλισσα
λαχανοσαρμάς λαχανοφαγία λαχανοφυλλάδα λαχανόζουμο λαχανόκηπος λαχανόπιτα
λαχανόφυλλο λαχείο λαχείον λαχειοπώλης λαχειοπώλισσα λαχματζούν λαχνός λαχούρι
λαχτάρισμα λαψάνα λαψάνη λαϊκή λαϊκίστρια λαϊκισμός λαϊκιστής λαϊκούρα λαϊκός
λαϊκότητα λαός λαύρα λεία λείανση λείανσις λείριον λείψανο λείψανον λεβάντα
λεβάρισμα λεβέντης λεβέντισσα λεβέτι λεβίθες λεβαντέλαιο λεβαντίνα λεβαντίνος
λεβεντιά λεβεντογέννα λεβεντογενιά λεβεντογυναίκα λεβεντομάνα λεβεντονιά
λεβεντοπνίχτρα λεβεντόπαιδο λεβητοποιΐα λεβητοποιείο λεβητοποιός λεβητοστάσιο
λεβιέ λεβιές λεβουλόζη λεγάτος λεγένι λεγεωνάριος λεγεώνα λεγόμενο λεζάντα
λεηλασία λεημοσύνη λειβάδα λειβάδι λειμωνάριο λειμωνίτης λειμώνας λειρί
λειτουργία λειτουργιά λειτουργικοποίηση λειτουργικότης λειτουργικότητα
λειτουργιστής λειτουργοποίηση λειτουργός λειτούργημα λειχήν λειχήνα λειχήνωση
λειχηνιάρης λειχούδης λειψανδρία λειψανοθήκη λειψιώτης λειψοφεγγαριά λειψυδρία
λειότης λειότητα λεκάνη λεκές λεκανάκι λεκανίτσα λεκανοπέδιο λεκιθίνες
λελέκι λελές λελούδι λεμές λεμβοδρομία λεμβούχος λεμβωδία λεμεσιανός λεμονάδα
λεμονί λεμονίτα λεμονανθός λεμονιά λεμονοδάσος λεμονοστίφτης λεμονοστείφτης
λεμονόκουπα λεμονόφλουδα λεμπλεμπίδια λεμπλεμπιά λεμφαγγείο λεμφαγγείον
λεμφαγγειίτιδα λεμφαγγειίτις λεμφαδένας λεμφαδενίτιδα λεμφαδενίτις
λεμφατισμός λεμφοίδημα λεμφογραφία λεμφοκήλη λεμφοκοκκίωμα λεμφοκοκκιωμάτωση
λεμφοκυτταροπενία λεμφοκύτταρο λεμφοκύτταρον λεμφολογία λεμφοπάθεια λεμφοπενία
λενινίστρια λενινισμός λενινιστής λεξίδιο λεξίδιον λεξαρίθμηση λεξαριθμολόγος
λεξιθήρας λεξιθηρία λεξικογράφηση λεξικογράφος λεξικογραφία λεξικολαλιά
λεξικομιλία λεξικό λεξικόν λεξιλάγνος λεξιλόγιο λεξιλόγιον λεξιπενία
λεξότυπο λεοντάρι λεοντή λεονταρισμός λεοντιδεύς λεοντοκεφαλή λεοπάρ
λεπίδα λεπίδι λεπίδιο λεπίς λεπιδωτά λεπιδόπτερα λεπροκομείο λεπροκομείον
λεπτεξέταση λεπτογεύστης λεπτοδείκτης λεπτοδείχτης λεπτοδουλειά λεπτοκάρυον
λεπτοκαρύα λεπτολογία λεπτολόγημα λεπτολόγηση λεπτομέρεια λεπτομέτρηση
λεπτοταινία λεπτοτεχνία λεπτουργική λεπτουργός λεπτούλι λεπτούργημα λεπτό
λεπτόν λεπτόνιο λεπτόπτιλος λεπτότης λεπτότητα λεσβία λεσβία λεσβιασμός
λετρίνα λετρίνο λετρασέτ λετσαρία λετσούμπι λεττονή λεττονικά λεττονός λευίτης
λευκάντρια λευκάργα λευκίνη λευκίτης λευκαδίτης λευκαντής λευκαντικό λευκαστής
λευκοκυτογένεση λευκοκυττάρωση λευκοκυτόλυση λευκοκύτταρο λευκοκύτταρον
λευκοπίνακας λευκοπελαργός λευκοπενία λευκοπλάστ λευκοπλάστης λευκορωσικά
λευκοσιδηρουργία λευκοσιδηρουργείο λευκοσιδηρουργός λευκωματουρία λευκωσιάτης
λευκόθριξ λευκόλυση λευκόρροια λευκότητα λευκόχρυσος λευτέρωμα λευτεριά
λευϊτικό λεφούσι λεφτά λεφτάς λεφτοκάρι λεφτοκάρυ λεφτοκαρυά λεφτουδάκια λεφτό
λεχούδι λεχούσα λεχρίτης λεχωίδα λεχωνιά λεχώνα λεωνιδιώτης λεωφορείο
λεωφορειατζής λεωφορειολωρίδα λεωφορειούχος λεωφορειόδρομος λεωφόρος λεϊμονιά
λεϊσμάνια λεϊσμανίαση λεϊσμανίασις λεόπαρδος λεύγα λεύκα λεύκανση λεύκανσις
λεύκη λεύκωμα ληγαδούρα ληκτότητα λημέρι λημματογράφηση λημματολόγιο ληνοβάτης
ληνός ληξίαρχος ληξιάριο ληξιαρχείο ληξουριώτης λησμονήτρα λησμονησιά
λησμονιά λησμονοβότανο λησμοσύνη ληστής λησταντάρτης λησταποδοχή λησταποδόχος
λησταρχίνα λησταρχείο λησταρχείον ληστεία ληστοκρατία ληστοπραξία
ληστοσυμμορίτης ληστοσυμμορίτισσα ληστοτρόφος ληστοφυγόδικος ληψοδοσία λιά
λιάνισμα λιάσιμο λιάστρα λιακάδα λιακωτό λιακό λιανά λιανέμπορος λιανεμπόριο
λιανοντουφεκιά λιανοντούφεκο λιανοπουλητής λιανοπούλημα λιανοπωλητής
λιανοτούφεκο λιανοτράγουδο λιβάδι λιβάνι λιβάνισμα λιβαδάκι λιβαδόπευκο
λιβανέζος λιβανιστήρι λιβανιστής λιβανομαντεία λιβανωτό λιβελλούλα
λιβελογράφος λιβελογραφία λιβελούλα λιβελούλη λιβρέα λιγάση λιγδιά λιγκατούρα
λιγνίνη λιγνίτης λιγνιτογένεση λιγνιτοπαραγωγή λιγνιτοπαραγωγός λιγνιτωρυχείο
λιγνιτωρύχος λιγνιτόπλινθος λιγνιτόσημο λιγοθυμιά λιγοσύνη λιγουλάκι
λιγοφαγία λιγοψυχία λιγοψυχιά λιγούρα λιγούρι λιγούστρο λιγωμάρα λιγόθυμος
λιθάγρα λιθάνθραξ λιθάργυρος λιθάρι λιθίαση λιθίασις λιθανάγλυφο
λιθαράκι λιθοβολία λιθοβολισμός λιθοβόλημα λιθογλυφία λιθογλύφος λιθογράφημα
λιθογράφησις λιθογράφος λιθογραφία λιθογραφείο λιθογόμωση λιθοδομή λιθοδομία
λιθοθρυψία λιθοκονία λιθοκοπία λιθοκόλληση λιθοκόλλησις λιθοκόπος λιθολόγημα
λιθοξόος λιθοπαγίδα λιθορριπή λιθοτομία λιθοτριψία λιθουανή λιθουανικά
λιθρίνι λιθωνόλοφος λιθόκολλα λιθόπλινθος λιθόστρωση λιθόστρωσις λιθόσφαιρα
λιθώνας λικέρ λιλά λιλί λιλιά λιμάνι λιμάρισμα λιμένας λιμήν λιμαδόρα
λιμανάκι λιμβουργιανά λιμενάρχης λιμενίσκος λιμεναρχείο λιμεναρχείον
λιμενεργασία λιμενικός λιμενοβραχίονας λιμενοβραχίων λιμενολεκάνη
λιμενοφύλακας λιμενοφύλαξ λιμνιώτης λιμνογράφος λιμνοδεξαμενή λιμνοθάλασσα
λιμνούλα λιμνόμετρο λιμνόφιδο λιμοκοντόρος λιμοκτονία λιμουζίνα λιμπεραλισμός
λιμπρετίστας λιμός λινάρι λινάτσα λινέλαιο λινέλαιον λινίνη λιναρόσπορος
λινγκάλα λινγκουίνι λινκοζαμίδες λινογραφία λινοστολή λινοτυπία λινοτύπης
λιντσάρισμα λινό λινόλεουμ λινόνημα λιοκούκουτσο λιοκόκκαλο λιοκόκκι λιοκόρνο
λιομάζωμα λιομαζώχτρα λιοντάρι λιονταράκι λιονταρής λιονταρίνα λιοπύρι
λιοτρίβι λιοτριβειό λιοτριβιάρης λιοτρόπι λιπίδιο λιπαντέλαιο λιπαντής
λιπαρότης λιπαρότητα λιπασματοβιομηχανία λιπασμός λιποαναρρόφηση λιπογλυπτική
λιποθυμιά λιποκιβώτιο λιπομάρτυρας λιπομάρτυς λιπομέτρηση λιπομαρτυρία
λιποπεριεκτικότητα λιποτάκτης λιποτάχτης λιποταξία λιποψυχία λιρέτα λιρέττα
λισάνς λισγάρι λιτάνευση λιτάνευσις λιτέρα λιτή λιτανεία λιταρχισμός
λιτρουβιό λιτότητα λιχανός λιχναράκι λιχνιστήρι λιχνιστής λιχουδιά λιχούδης
λιόγερμα λιόδεντρο λιόκλαδο λιόκλαρο λιόλαδο λιόντας λιόντισσα λιόπανο λιόπιτα
λιόφωτο λιόχεντρα λιόψωμο λιώμα λιώσιμο λοάτ λοίμωξη λοβίο λοβεκτομή
λοβιτούρα λοβοτομή λοβός λογάκι λογάρι λογάριθμος λογάς λογής λογίστρια
λογαριθμομαντεία λογγοβάρδοι λογική λογικισμός λογικοκρατία λογικό λογικόν
λογικότητα λογιοσύνη λογιοτατισμός λογισμικό λογισμικό ως υπηρεσία λογισμός
λογιστής λογιστική λογιστικοποίηση λογιότητα λογιών λογογράφημα λογογράφος
λογοδιάρροια λογοδοσία λογοθέτης λογοκλοπή λογοκλόπος λογοκοία λογοκρισία
λογοκόπος λογομαχία λογοπαίγνιο λογοπλασία λογοποιός λογοτέχνημα λογοτέχνης
λογοτεχνία λογοτριβή λογού λογχισμός λογχομαχία λογόγραμμα λογόρροια λογότυπο
λογύδριο λοιδορία λοιδοριά λοιμική λοιμικό λοιμοκαθαρτήριο λοιμωξιολόγος
λοκ άουτ λοκάντα λοκαντιέρα λοκαντιέρης λοκατζής λοκμάς λοκοκλοπία λολίτα
λομβαρδικά λομβαρδοί λομπίστας λονδρέζα λονδρέζος λοξίας λοξοδρομία
λοξοδρόμηση λοξοτομή λοξός λοξότης λοξότητα λοπάς λοσιόν λοστάρι λοστρόμος
λοταρία λοτζμπάν λοτόμος λουίζα λουβάδα λουβί λουθηρανισμός λουκάνικο
λουκέτο λουκανικοπιτάκι λουκανικόσουπα λουκουμάκι λουκουμάς λουκουματζής
λουκούμι λουλάκι λουλάς λουλακί λουλουδάδικο λουλουδάκι λουλουδάς λουλουδικό
λουλούδι λουλούδιασμα λουλούδισμα λουμίνι λουμακιά λουμπάγκο λουμπάρδα
λουμπινιά λουξεμβουργιανά λουράκι λουρί λουρίδα λουρίτης λουσάρισμα λουσέρνα
λουστικά λουστράρισμα λουστρίνι λουστραδόρος λουτήρας λουτήτιο λουτρ λουτράρης
λουτρακιώτης λουτροθεραπεία λουτροκαμπινές λουτροπετσέτα λουτρό λουτρόπολη
λουτρώνας λουφές λουφαδόρος λουφατζής λοφάκι λοφίο λοφίσκος λοφοπλαγιά λοχίας
λοχεία λούγαρο λούγκρα λούκι λούκουμος λούλα λούλουδο λούμπα λούμπινο
λούπα λούπης λούπινο λούρα λούσιμο λούσις λούσο λούστρο λούστρος λούτσα
λούφα λυγαριά λυγεράδα λυγισμός λυγμός λυγξ λυγουριώτης λυδή λυδός λυθρίνι
λυκάνθρωπος λυκίσκος λυκανθρωπία λυκαυγές λυκειάρχης λυκειάρχισσα λυκιδεύς
λυκοφιλία λυκοφωλιά λυκόζη λυκόπουλο λυκόσκυλο λυκόφως λυμεώνας λυοφιλοποίηση
λυπησιάρης λυπητερή λυπομανία λυράρης λυρικότητα λυρισμός λυριτζής λυσίνη
λυσσιαστρείον λυσσιατρείο λυτάρι λυτρισμικό λυτρωμός λυτρωτής λυτρωτικότητα
λυχνία λυχνίτης λυχνοστάτης λυόμενο λωλάδα λωλαμάρα λωποδυσία λωποδύταρος
λωποδύτισσα λωποδύτρια λωρένσιο λωρίδα λωρίον λωτός λόβιον λόγγος λόγια λόγιο
λόγκος λόγος λόγχη λόγχισμα λόμπι λόξα λόξεμα λόξευμα λόξιγκας λόξυγγας
λόπια λόρδα λόρδος λόρδωση λότος λόφος λόχια λόχμη λόχος λύγισμα λύγκας λύγος
λύκειο λύκειον λύκος λύμα λύμη λύμφη λύπη λύπηση λύρα λύση λύσιμο λύσις λύσσα
λύσσιασμα λύτης λύτρα λύτρια λύτρωση λύτρωσις λύχνος λύχνος λώβα λώλαμα λώρος
μάγγανον μάγειρας μάγειρος μάγεμα μάγευμα μάγια του γιουκατάν μάγισσα
μάγκανο μάγκανος μάγκας μάγκιπος μάγκωμα μάγμα μάγνητρο μάγος μάγουλο μάδημα
μάζα μάζεμα μάζωμα μάζωξη μάης μάθημα μάθηση μάθησις μάθος μάκενα μάκια μάκινα
μάκρος μάκτρα μάκτρον μάλαγμα μάλαμα μάλαξη μάλαξις μάλε βράσε μάλη μάλωμα
μάμος μάμπο μάνα μάνατζερ μάνατζμεντ μάνγκο μάνδρα μάνητα μάνικα μάνιωμα μάννα
μάνταλο μάνταλος μάντεμα μάντης μάντις μάντισσα μάντρα μάντρα μάντρισμα
μάξιμουμ μάξις μάπα μάπας μάππα μάππα μάππουρος μάρα μάραθο μάραθον μάραθος
μάρανση μάργα μάργαρο μάργαρος μάργωμα μάρκα μάρκετινγκ μάρκο μάρμαρο μάρσιπος
μάρτης μάρτυρας μάρτυρας του ιεχωβά μάρτυς μάσα μάσημα μάσηση μάσησις μάσκα
μάστερ μάστευση μάστιγα μάστιξ μάστορας μάστορης μάταιο μάτι μάτιασμα μάτιση
μάτσα μάτσο μάτωμα μάχαιρα μάχη μάχιππος μέγαιρα μέγαρο μέγγενη μέγεθος
μέγκλα μέδιμνος μέδουσα μέθεξη μέθη μέθοδος μέθυσος μέικ απ μέλαθρο μέλαθρον
μέλημα μέλι μέλισσα μέλλον μέλλοντας μέλλων μέλος μέλωμα μέμψις μένος μέντα
μέντορας μέρα μέραρχος μέριμνα μέρισμα μέρμηγκας μέρος μέρωμα μέσα
μέση μέσο μέσον μέσος μέσοφρυς μέσπιλο μέσπιλον μέστωμα μέταλλο μέταλλον
μέτοικος μέτοχος μέτρημα μέτρηση μέτρησις μέτριος μέτρο μέτρον μέτωπο μέτωπον
μήκυνση μήκυνσις μήκων μήλα μήλη μήλιος μήλο μηλιά μήνας μήνη μήνιγγα μήνιγξ μήνις
μήνυση μήνυσις μήρινθος μήτηρ μήτρα μί μίανση μίασμα μίγμα μίζα μίκι-μάους
μίκτης μίλημα μίλι μίλιον μίλτος μίλφωσις μίμηση μίμησις μίμος μίνα μίνθη μίνι
μίνιο μίξερ μίξη μίρλα μίσθωμα μίσθωση μίσθωσις μίσος μίσχος μίτζα μίτος μίτρα
μαΐστορας μαΐστρα μαΐστρος μαέστρος μαία μαίανδρος μαίευσις μαγάρα μαγάρισμα
μαγαζάτορας μαγαζί μαγαρισά μαγαρισιά μαγατζές μαγγάνειο μαγγάνιο μαγγάνιον
μαγγανεία μαγγανευτής μαγγανεύτρια μαγδαλένιο μαγδαλήνιο μαγεία μαγείρεμα
μαγειρίτσα μαγειρείο μαγειρείον μαγειρειό μαγειριά μαγειρική μαγερειό μαγεριά
μαγιά μαγιάτικο μαγικά μαγική σκέψη μαγιοβότανο μαγιονέζα μαγιό μαγιόξυλο
μαγκάλι μαγκάνι μαγκίπιο μαγκίπιον μαγκίτης μαγκίτισσα μαγκαζίνο μαγκαλάκι
μαγκιά μαγκιλίκι μαγκιπείο μαγκιπειό μαγκιόρα μαγκιόρος μαγκλάρας μαγκλαράς
μαγκουριά μαγκουροφόρος μαγκουφανιώτης μαγκουφιά μαγκούρα μαγκούστα μαγνάδι
μαγνήσιον μαγνήτης μαγνήτης μαγνησία μαγνητίτης μαγνητισμός μαγνητογεννήτρια
μαγνητοσκόπηση μαγνητοσκόπησις μαγνητοσκόπιο μαγνητοστατική μαγνητοταινία
μαγνητοχημεία μαγνητόμετρο μαγνητόφωνο μαγνητόφωνον μαγουλάδες μαγουλάκι
μαγουλού μαδάρα μαδέρι μαδιάμ μαερειό μαεριό μαεστρία μαζανταρανί μαζδαϊσμός
μαζοχίστρια μαζοχισμός μαζοχιστής μαζούλι μαζούρκα μαζούτ μαζωχτός μαζόχα
μαζώχτρα μαθήτρια μαθηματάριο μαθηματικά μαθηματική μαθηματικοποίηση
μαθητάκος μαθητής μαθητεία μαθητολόγιο μαθητούδι μαθητριούλα μαθουσάλας μαθός
μαιευτήριο μαιευτική μαιζονέτα μαικήνας μαικηνισμός μαινάδα μαινάς μαιτρ
μακάζι μακάκος μακάτι μακέλεμα μακέτα μακί μακαντάσης μακαράς μακαρίτις
μακαρθισμός μακαριά μακαρισμοί μακαρισμός μακαριότης μακαριότητα μακαρονάδα
μακαρονισμός μακαρονοσαλάτα μακαρονοφαγία μακαρονού μακαρόν μακαρόνι μακαρόνια
μακεδονίτης μακεδονίτισσα μακεδόνας μακεδών μακεδών μακελάρης μακελάρισσα
μακετίστας μακιάτο μακιαβελισμός μακιγιάζ μακιγιάρισμα μακιγιέζ μακιγιέρ
μακρηγορήτρια μακρηγορία μακρηγορητής μακρινάρι μακροβένθος μακροβιοτική
μακροβιότητα μακροβούτι μακρογραφία μακροεξέλιξη μακροζωία μακροημέρευση
μακροθυμία μακροκατάσταση μακροκλιματολογία μακρολέλεκας μακρολίδια μακρολογία
μακρομόριο μακρομύτα μακρομύτης μακροοικονομία μακροπροσωπία μακροσεισμική
μακροσυγγενής μακροτοπωνύμιο μακροϊστορία μακρυνάρι μακρυψώλης μακρόκλιμα
μακρόνι μακρότης μακρότητα μακρύφαλλος μακό μαλάγρα μαλάκα μαλάκας μαλάκιο
μαλάκυνσις μαλάκω μαλάκωμα μαλάρια μαλέας μαλίνκε μαλαγάνα μαλαγάνας μαλαγανιά
μαλαγιάλαμ μαλακάκος μαλακία μαλακοκαύλης μαλακοπίτουρας μαλακτικό
μαλακτικότητα μαλακωσιά μαλακόστρακα μαλακότης μαλακότητα μαλαματικά
μαλαμματικά μαλαμοκάπνισμα μαλαπέρδα μαλαφράντζα μαλαχίτης μαλαχτικότητα
μαλγασικά μαλεβράσι μαλθακότης μαλθακότητα μαλθουσιανισμός μαλιανός μαλιοβράσι
μαλλιά μαλλιαρή μαλλιαρισμός μαλλιαροκομμουνισμός μαλλιοκέφαλα μαλλιοτράβηγμα
μαλτέζικα μαλτέζος μαλωματάκι μαμά μαμάκα μαμάκιας μαμή μαμαζέλ μαμακούλα
μαμζέλ μαμμωνάς μαμουκαλιά μαμούδι μαμούθ μαμούνι μανάβης μανάβικο μανάβισσα
μανάτος μανέλα μανές μανέστρα μανέτα μανία μανίκι μανίτσα μαναβάκι μαναβική
μαναφούκι μανγκρόβιο μανδάλωμα μανδάμ μανδήλιον μανδαλοδέτης μανδαρίνος
μανδαρινέα μανδαρινισμός μανδραγόρας μανδύας μανεκέν μανιά μανιάτικο μανιέρα
μανιαμούνιας μανιατό μανιβέλα μανιερισμός μανιεριστής μανικέτι μανικετόκουμπο
μανικιουρίστα μανικιουρίστας μανικιούρ μανιλόσχοινο μανιοκατάθλιψη
μανιπουλάρισμα μανιτάρι μανιταρόσουπα μανιφέστο μανιφατούρα μανιχαϊσμός μανιώ
μανουάλι μανουβράρισμα μανουβραδόρος μανουλίτσα μανουσάκι μανούβρα μανούλα
μανούρα μανούρι μανσέτα μανσούπι μαντάλωμα μαντάμ μαντάνι μαντάρι μαντάρισμα
μαντάτορας μαντέκα μαντέλλο μαντέμι μαντήλι μαντίλα μαντίλι μαντίλια μανταλάκι
μανταμίτσα μανταρίνι μανταρίστρα μανταρίστρια μανταρινάδα μανταρινάκι
μανταρινιά μαντατευτής μαντατεύτρα μαντατοφόρα μαντατοφόρος μαντατούρης
μαντείο μαντεμτζής μαντευτής μαντεψιά μαντεύτρα μαντζαφλάρι μαντζουράνα
μαντική μαντιλάκι μαντινάδα μαντολάτο μαντολίνο μαντολινάτα μαντολοτσέλο
μαντού μαντράχαλος μαντρί μαντραχαλάς μαντρόσκυλο μαντρότοιχος μαντό μαντύας
μαντᾶτον μαντᾶτον μανό μανόγαλο μανόλια μανόμετρο μανός μαξιλάρα μαξιλάρι
μαξιλαράκι μαξιλαροθήκη μαξιλαρομάνα μαξιλαροπόλεμος μαξιλλάριον μαξιλλαροθήκη
μαξιμαλισμός μαξιμαλιστής μαξούλι μαοΐστρια μαορί μαορί μαουνιέρης μαουνιέρικα
μαοϊστής μαούνα μαράγκιασμα μαράζι μαράζωμα μαράθι μαράκας μαρέγκα μαρέγκες
μαρίδα μαρίμπα μαρίνα μαραγκοσύνη μαραγκούδικο μαραγκός μαραθοπιτάκι
μαραθωνομάχος μαραθόπιτα μαραθόσπορος μαραμπουμηλιά μαραμπού μαρασκίνο
μαραφέτι μαργέλι μαργαρίνη μαργαρίτα μαργαρίτης μαργαριτάρι μαργαριτάριον
μαριδάκι μαριδίτσα μαριδούλα μαρινάδα μαρινάρισμα μαρινάτα μαριονέτα
μαριχουάνα μαρκάλισμα μαρκάρισμα μαρκέτα μαρκήσιος μαρκίζα μαρκαδοράκι
μαρκασίτης μαρκεϊκομηλιά μαρκησία μαρκούτσι μαρμάγκα μαρμάρα μαρμάρωμα
μαρμάρωσις μαρμίτα μαρμαράδικο μαρμαράς μαρμαροβιομηχανία μαρμαρογλυπτική
μαρμαρογλύπτης μαρμαρογλύφος μαρμαροθέτημα μαρμαροκολόνα μαρμαροκονία
μαρμαρυγή μαρμαρυγίας μαρμαρόκολλα μαρμελάδα μαρμότα μαρνέρος μαρξίστρια
μαρξιστής μαροκέν μαροκινή μαροκινό μαροκινός μαρουβάς μαρουλάκι μαρουλοσαλάτα
μαρουλόσπορος μαρουλόφυλλο μαρούλι μαρρούβιο μαρς μαρσάρισμα μαρσιποφόρο
μαρσπιέ μαρσπιές μαρτάπριλα μαρτίνι μαρτζαφλάρι μαρτινικανή μαρτινικανός
μαρτυρίκι μαρτυριά μαρτυριάτικο μαρτυρικά μαρτυρικό μαρτυρολόγιο μαρτύριο
μασάζ μασάτι μασέζ μασέλα μασέρ μασίνι μασίστας μασίφ μασαζάκι μασητήρας μασιά
μασκάρεμα μασκαράς μασκαράτα μασκαραλίκι μασκαρατζίκος μασκαριλίκι μασκαρού
μασκοφόρος μασκότ μασλάτι μασονία μασονισμός μασούλημα μασούλισμα μασούρι
μασπιές μασσαλιώτιδα μασσαλιώτις μαστάρι μαστέλο μαστίγιο μαστίγωμα μαστίγωση
μαστίτιδα μαστίχα μαστεκτομή μαστιχέλαιο μαστιχιά μαστιχοπαραγωγός
μαστιχόμελο μαστογράφος μαστογραφία μαστοειδίτιδα μαστοειδίτις μαστοειδεκτομή
μαστοπηξία μαστοπλαστική μαστοράντζα μαστορεία μαστοριά μαστορικά μαστορόπουλο
μαστοφόρα μαστούρα μαστούρας μαστούρι μαστραπάς μαστροπεία μαστροπός
μαστωδυνία μαστόδοντας μαστόρεμα μαστόρισσα μαστός μασχάλη μασόνος ματ ματάκι
ματάρα ματαίωση ματαιοδοξία ματαιολογία ματαιοπονία ματαιοφροσύνη ματαιόσχολος
ματαιότητα ματαράς ματατζής ματεριαλίστρια ματεριαλισμός ματεριαλιστής
ματζαφλάρι ματζουράνα ματιά ματικάπι ματμαζέλ ματογυάλια ματοκλάδι ματοκύλισμα
ματοτσίνουρο ματρακάς ματρόνα ματς ματς μουτς ματσάκι ματσέτα ματσακονιστής
ματσαράγκα ματσαράγκας ματσαραγκιά ματσουκιά ματσούκα ματσούκι ματσόλα
ματόπονος ματόφρυδο ματόφυλλο ματόχαντρο μαυλίστρα μαυλίστρια μαυλιστής
μαυράδι μαυράκι μαυρίλα μαυραγάνι μαυραγορίτης μαυραγορίτισσα μαυρογή
μαυροδάφνη μαυροζούμι μαυροθαλασσίτης μαυροθαλασσίτισσα μαυροκούκι μαυρομάτικα
μαυροπίνακας μαυροπίναξ μαυροπελαργός μαυροπούλι μαυροσκούφης μαυροτσιρώνι
μαυροφρύδα μαυροφρύδης μαυρόγυπας μαυρόφιδο της γυάρου μαυρόχωμα μαυσωλείο
μαφία μαφιόζος μαχήτρια μαχαίρα μαχαίρι μαχαίρωμα μαχαιράκι μαχαιράς
μαχαιριά μαχαιροβγάλτης μαχαιρολαβή μαχαιροπίρουνο μαχαιροποιός μαχαιρόσπαθο
μαχαλεπί μαχαλόμαγκας μαχαραγιάς μαχαρανή μαχητής μαχητικότητα μαχλέπι
μαχμουρλίδισσα μαχμουρλίκι μαχμουρλού μαϊδανός μαϊμουδάκι μαϊμουδίτσα
μαϊμουδιάρης μαϊμουδισμός μαϊμουδοπαράδεισος μαϊμού μαϊμούδισμα μαϊνάρισμα
μαϊντανόσουπα μαϊούλιον μαϊστράλι μαϊστροτραμουντάνα μαϊτάπι μαϊτνέριο μαόνι
μαύρη μαύρισμα μαύρο μαύρος μείγμα μείκτης μείξη μείξις μείον μείραξ μείωση
μεατοτομή μεγάγραμμα μεγάκυκλος μεγάλος μεγάλυνσις μεγάλωμα μεγάτονος μεγάφωνο
μεγίστη μεγαβάτ μεγαβατώρα μεγαηλεκτρονιοβόλτ μεγαθήριο μεγαθυμία μεγακεφαλία
μεγαλέμπορος μεγαλακρία μεγαλαυχία μεγαλείο μεγαλειότατος μεγαλειότης
μεγαληγορία μεγαλοαπατεώνας μεγαλοαστή μεγαλοαστισμός μεγαλοαστοί μεγαλοαστός
μεγαλοβδόμαδο μεγαλοβιομήχανος μεγαλογιατρός μεγαλοδικηγόρος μεγαλοδωρία
μεγαλοεισοδηματίας μεγαλοεπιχειρηματίας μεγαλοεργοδοσία μεγαλοθυμία
μεγαλοκαταπατητής μεγαλοκεφαλία μεγαλοκοπέλα μεγαλοκτηματίας μεγαλομάρτυρας
μεγαλομανία μεγαλομαστία μεγαλομπεμπέκα μεγαλοοφειλέτης μεγαλοπαράγοντας
μεγαλοποίηση μεγαλοποίησις μεγαλοπρέπεια μεγαλοπραγμοσύνη μεγαλορρημοσύνη
μεγαλοστέλεχος μεγαλοστομία μεγαλοσύνη μεγαλοτσιφλικάς μεγαλουργία
μεγαλουσιάνος μεγαλουχία μεγαλοφροσύνη μεγαλοφυΐα μεγαλοψυχία μεγαλοϊδεάτης
μεγαλοϊδεατισμός μεγαλοϊδιοκτήτης μεγαλοϊχθύς μεγαλούπολη μεγαλούργημα
μεγαλόδοντας μεγαλόκερος μεγαλόνησος μεγαλόπιασμα μεγαλόσταυρος μεγαλόσφηκα
μεγαμπάιτ μεγανόμος μεγαοικοσύστημα μεγαουρητήρας μεγαπανίδα μεγαρίτης
μεγασύμπαν μεγεθολόγιο μεγεθυντής μεγεθυντικό μεγιστάνας μεγιστοποίηση μεδούλι
μεζές μεζεδάδικο μεζεδάκι μεζεδοπωλείο μεζεκλής μεζεκλίκι μεζεκλού μεζελίκι
μεζονέτα μεζούρα μεθάνιο μεθαμφεταμίνη μεθανίτης μεθανόλη μεθαύριον μεθειονίνη
μεθευρετική μεθεόρτια μεθοδικότητα μεθοδισμός μεθοδιστής μεθοδολογία
μεθοκόπι μεθοκόπος μεθυλένιο μεθυλένιον μεθόδευση μεθόριος μεθόρμιση
μεθύλιο μεθύσι μεθύστακας μεθύστρα μειδίαμα μειλιχιότης μειλιχιότητα
μειοδοσία μειοδότης μειοδότρια μειονέκτημα μειονεκτικότης μειονεκτικότητα
μειονοψηφία μειονότης μειονότητα μειορρύθμιση μειοψηφία μειράκιον μειωτέος
μελάνη μελάνι μελάνιασμα μελάνουρος μελάνωμα μελάνωση μελάνωσις μελάς μελάσα
μελάσωση μελέ μελέτη μελέτημα μελία μελίγγι μελίγκρα μελίμηλον μελίπηκτον
μελίσσια μελίτακας μελίτωμα μελαγχολία μελαμίνη μελανάδα μελανία μελανίας
μελανίασις μελανίνη μελανίτης μελανίτισσα μελανείο μελανείον μελανισμός
μελανοδοχείο μελανοδοχείον μελανοκύτταρο μελανοταινία μελανοχίτωνας μελανούρι
μελανότης μελανότητα μελατονίνη μελεαγρίδα μελετήτρια μελετητήριο μελετητής
μελικοκιά μελικουκιά μελισσάκι μελισσοβότανο μελισσοκέρι μελισσοκομία
μελισσοκόμος μελισσοκόφινο μελισσολόι μελισσοτροφία μελισσοτροφείο
μελισσοτρόφος μελισσουργία μελισσουργείο μελισσουργείον μελισσουργός
μελισσόκηπος μελισσόπουλο μελισσόχορτο μελισσώνας μελιτίνη μελιτακιά μελιτζάνα
μελιτζανί μελιτζανιά μελιτζανοπουρές μελιτζανοσαλάτα μελιτζανόπιτα
μελιτοεξαγωγέας μελιτοεξαγωγή μελιχρότης μελιχρότητα μελιψίττακος μελλοντισμός
μελλοντολογία μελλοντολογικός μελλοντολόγος μελλούμενα μελλόνυμφη μελλόνυμφος
μελοδραματισμός μελοδραματοποιός μελομακάρονο μελοποίηση μελοποιία μελοποιός
μελτέμι μελτεμάκι μελωδία μελωδικότητα μελωδός μελό μελόδραμα μελόνερο
μελόπιτα μεμέ μεμέτης μεμβράνα μεμβράνη μεμβρανίδιο μεμψιμοιρία μενίρ
μενεξές μενεξεδί μενουέτο μενού μενσεβίκος μενσεβικισμός μενταγιόν
μεντεσές μεντρεσές μεξικανός μεράδι μεράκι μεράκλωμα μερί μερίδα μερίδιο
μερίκευση μερίκευσις μερακλήδισσα μερακλής μερακλού μεραρχία μερδικό μερεμέτι
μερεολογία μεριά μερικότης μερικότητα μερινό μερινόν μερισματαπόδειξη
μερισματόγραφο μερισμός μερκαντιλισμός μερκελισμός μερκελιστής μερλούκιος
μερμήγκιασμα μερμηγκάκι μεροδουλευτής μεροδούλι μεροκάματο μεροκαματιάρης
μεροληψία μερολογία μερομήνια μεροφάι μερούλα μερσίνα μερσίνη μερσερισμός
μερτικό μερωνυμία μερόνυχτο μερώνυμο μες μεσάζοντας μεσάζουσα μεσάζων μεσάλα
μεσάντρα μεσάνυχτα μεσέγχυμα μεσήλικας μεσίτευση μεσίτευσις μεσίτης μεσίτις
μεσίτρια μεσαγγλικά μεσαιωνισμός μεσαιωνοδίφης μεσανατολικό μεσαριά μεσαύλι
μεσεγγυήτρια μεσεγγυητής μεσεγγυούχος μεσεγγύημα μεσεγγύηση μεσεγγύησις
μεσημβρία μεσημβρινός μεσημεριανό μεσιακάρης μεσιτεία μεσκίνης μεσοαστός
μεσοβδόμαδο μεσοβορράς μεσοβραδύπορα μεσογονάτιο μεσογονάτιον μεσοδιάστημα
μεσοθάλασσα μεσοθωράκιο μεσοθωρακίτιδα μεσοκάθετος μεσοκάρπιο μεσοκάρπιον
μεσοκαλόκαιρο μεσοκλιματολογία μεσοκνήμιο μεσοκνήμιον μεσολάβηση μεσολάβησις
μεσολαβήτρια μεσολαβητής μεσολιθική μεσολογγίτης μεσολόβιο μεσομήριον
μεσονύχτι μεσοπάτωμα μεσοπόλεμος μεσοσαράκοστο μεσοστύλιο μεσοστύλιον
μεσουράνημα μεσουράνηση μεσουράνησις μεσοφυλική μεσοφυλικός μεσοφωνία μεσοφόρι
μεσοχώρι μεσούρανα μεσπιλέα μεσσίας μεσσιανισμός μεστότης μεστότητα μεσόδμη
μεσόθυρον μεσόκλιμα μεσόνιο μεσόνιον μεσόπατος μεσόπορτα μεσόστεγο μεσότητα
μεσότοιχος μεσόφρυδο μεσόφρυο μεσόφωνος μεσώροφος μετάβαση μετάγγιση μετάδοση
μετάζωα μετάθεση μετάκληση μετάληψη μετάληψις μετάλλαξη μετάλλαξις μετάλλευμα
μετάλλευσις μετάλλιο μετάλλιον μετάλλωση μετάνθρωπος μετάνιωμα μετάνοια μετάξι
μετάπλασμα μετάπτωση μετάσταση μετάταξη μετάφαση μετάφραγμα μετάφραση
μετάφρενον μετέπειτα μετέωρο μετέωρον μετα-αθεϊσμός μεταΐντερνετ μεταίχμιο
μεταανάλυση μεταβάπτισις μεταβάπτισμα μεταβίβαση μεταβιολογία μεταβλητή
μεταβολή μεταβολισμός μεταγλωττίστρια μεταγλωττιστής μεταγλώσσα μεταγλώττιση
μεταγραμματισμός μεταγραφή μεταγραφοφύλακας μεταγωγέας μεταγωγή μεταγωγός
μεταδεδομένο μεταδημοκρατία μεταδημότευση μεταδιδάκτορας μεταδοτικότητα
μεταηθική μετακάρπιο μετακάρπιον μετακένωση μετακίνηση μετακίνησις μετακανόνας
μετακομιδή μετακόμιση μετακόμισις μετακύλιση μεταλίκι μεταλαμπάδευση
μεταλλάκτης μεταλλάς μεταλλίκι μεταλλίτης μεταλλίτις μεταλλαγή μεταλλαγμένα
μεταλλακτήρας μεταλλαξιογόνο μεταλλεία μεταλλείο μεταλλειοκτήτης
μεταλλειολόγος μεταλλευτής μεταλλικότης μεταλλικότητα μεταλλισμός
μεταλλοβολή μεταλλογένεια μεταλλογνωσία μεταλλογραφία μεταλλοδίφης
μεταλλοκέφαλη μεταλλοκέφαλος μεταλλοποίηση μεταλλοποίησις μεταλλοτεχνία
μεταλλουργία μεταλλουργείο μεταλλουργική μεταλλουργός μεταλλοφορία
μεταλλοχρωμία μεταλλού μεταλλούδα μεταλλωρυχείο μεταλλωρυχείον μεταλλωρύχος
μεταλλόφωνο μεταλογική μεταλοκολλητής μεταμάγος μεταμέλεια μεταμίσθωση
μεταμαθηματικά μεταμελέτη μεταμεσονύχτιο μεταμοντερνίστρια μεταμοντερνισμός
μεταμορφισμός μεταμορφοψία μεταμορφωτής μεταμφίεσις μεταμόρφωση μεταμόρφωσις
μεταμόσχευσις μετανάστευση μετανάστευσις μετανάστης μετανάστρια μεταναλαμπή
μετανιωμός μετανοητής μεταξάδικο μεταξοβιομηχανία μεταξοκλωστική
μεταξοσκούληκας μεταξοσκωληκοτροφία μεταξοσκώληκας μεταξουργία μεταξουργείο
μεταξουργός μεταξοϋφαντουργία μεταξοϋφαντουργός μεταξού μεταξωτό μεταξόνιο
μεταξόσπορος μεταξότριχα μεταπήδηση μεταπλασία μεταποίηση μεταπολίτευση
μεταπουλητής μεταπούλημα μεταπράτης μεταπράτηση μεταπτυχιούχος μεταπωλητής
μεταπώληση μεταρρυθμισμός μεταρρυθμιστής μεταρρύθμιση μεταρρύθμιση μεταρσίωση
μετασκευή μεταστάθμευση μεταστάς μεταστάσα μεταστέγαση μεταστοιχείωση
μεταστροφή μετασυγχρονισμός μετασυνόψιση μετασχηματισμός μετασχηματιστής
μετατάρσιο μεταταρσαλγία μετατρεψιμότητα μετατροπέας μετατροπή μετατροπία
μετατρόχιο μετατόπιση μετατόπισμα μετατύπωση μεταφασισμός μεταφιλοσοφία
μεταφορέας μεταφορικά μεταφράστης μεταφράστρια μεταφραστής μεταφραστικά
μεταφυσική μεταφυσικό μεταφυσικότητα μεταφόρτωση μεταφύτευμα μεταφύτευση
μεταχρονισμός μεταχρωμάτιση μεταχρωματισμός μεταψυχιατρική μεταψυχική
μεταϊστορία μεταϊστορικός μεταϊστός μεταϋλισμός μετείκασμα μετεγγραφή
μετεγκατάσταση μετεγχειρητικός μετεκπαίδευση μετεμψύχωση μετενέργεια
μετενσωμάτωση μετεξέλιξη μετεξέταση μετεξέτασις μετεπίλογος μετεπιβίβαση
μετεστεροποίηση μετευρετική μετεωρίτης μετεωρίτης μετεωρίτισσα μετεωρισμός
μετεωρολογία μετεωρολόγος μετεωρομαντεία μετεωροσκοπία μετεωροσκοπείο
μετεωροσκόπηση μετεωροσκόπησις μετεωροσκόπιο μετεωροσκόπιον μετεωροσκόπος
μετεώριση μετεώρισις μετζίτι μετζοσοπράνο μετοίκηση μετοίκησις μετοίκιση
μετοικεσία μετονομασία μετουσίωση μετουσίωσις μετοχάρης μετοχάρισσα
μετοχέτευσις μετοχή μετοχιάριος μετοχολόγιο μετοχοποίηση μετοχοπρατήριο μετρ
μετρέσα μετρίαση μετρίασις μετρημός μετρητά μετρητής μετριασμός μετρική
μετριοφροσύνη μετριότης μετριότητα μετρογραφία μετρολογία μετρολόγιο
μετρονομία μετρονόμος μετροπόντικας μετροσέξουαλ μετροταινία μετροφωτογραφία
μετσοβόνε μετωνυμία μετωπικότης μετωπικότητα μετωπομαντεία μετόπη μετόπισθεν
μετώπιο μετώπιον μεφίτιδα μεφίτις μεφιτισμός μεϊντάνι μη δυϊσμός
μηδένιση μηδένισις μηδαμινότης μηδαμινότητα μηδενίστρια μηδενικούρα μηδενικό
μηδενισμός μηδενιστής μηδική μηδισμός μηκυνσιόμετρο μηκωνέλαιο μηκώνιο μηλέα
μηλέμπορος μηλίγγι μηλίνη μηλίτης μηλίτσα μηλαδέρφι μηλαράκι μηλαφάνα μηλεώνας
μηλιόρα μηλιόρι μηλιώνας μηλοέλατο μηλοβολία μηλογενής μηλογρανίτα
μηλοδιαλογή μηλοζελές μηλοκάρπουζο μηλοκέικ μηλοκαθαριστής μηλοκαλλιέργεια
μηλοκαρπουζιά μηλοκαρπούζι μηλοκολοκύθα μηλοκολόκυθο μηλοκομπόστα μηλοκρινίδες
μηλοκόπτης μηλοκύδωνο μηλολουχούλι μηλολόνθη μηλομάγουλο μηλομάχος
μηλομαχία μηλομαχητής μηλοναμίδιο μηλονυλοχλωρίδιο μηλονύλιο μηλοπέπονο
μηλοπαραγωγός μηλοπαστάκι μηλοπεπονιά μηλοπεπόνι μηλοπηπονιά μηλοπιτάκι
μηλοπουρές μηλοπούρναρο μηλοπράτης μηλοπόλεμος μηλοριζίκι μηλοροδάκινο
μηλοροδόνερο μηλοσαλάτα μηλοσφακιά μηλοταρτάκι μηλοτηγανίτα μηλοφάγος
μηλοχυμός μηλωτή μηλόγαμο μηλόδενδρο μηλόκακτος μηλόκεδρος μηλόκλαδο μηλόκρασο
μηλόκρινος μηλόξιδο μηλόξυδο μηλόξυλο μηλόπαστα μηλόπευκο μηλόπιτα μηλόσουπα
μηλότουρτα μηλόχορτο μηλώνας μημουάπτου μημουαπτισμός μηνάρας μηνάρισμα
μηνίσκος μηνιάτικο μηνιγγίτιδα μηνιγγίτις μηνιγγιτισμός μηνολόγιο μηνολόγιον
μηνυτής μηνύτρια μηνύτωρ μηρί μηραλγία μηροκήλη μηρυκασμός μηρυκαστικά μηρός
μητέρα μητράδελφος μητρίτιδα μητρίτις μητραδέλφη μητραλγία μητραλοίας μητριά
μητριός μητροκήλη μητροκτησία μητροκτονία μητροκτόνος μητρομανής μητρομανία
μητροπάρθενος μητροπολίτης μητρορραγία μητροσκόπηση μητροσκόπησις μητροσκόπιο
μητρυιά μητρυιός μητρωνυμία μητρόπολη μητρόπολις μητρόπονος μητρότης μητρότητα
μητρώο μητρώον μηχάνευμα μηχάνημα μηχάνι μηχανάκι μηχανάκιας μηχανάμαξα
μηχανή μηχανηματάκι μηχανική μηχανικισμός μηχανικό μηχανικός μηχανισμός
μηχανογράφηση μηχανογράφος μηχανογραφία μηχανογραφικό μηχανοδηγός
μηχανοκάικο μηχανοκαλλιέργεια μηχανοκρατία μηχανολογία μηχανολογιστική
μηχανοπέδη μηχανοποίηση μηχανοργάνωση μηχανορράφος μηχανορραφία μηχανοστάσιο
μηχανοτεχνίτης μηχανοτρονική μηχανουργία μηχανουργείο μηχανουργός μηχανόβια
μηχανότρατα μιαρό μιαρότης μιαρότητα μιασματικότης μιασματικότητα μιγάδα
μιγάς μιγαδικός μιζέρια μιζανπλί μιζανσέν μιζοδόρα μιζοδόρος μιθριδατισμός
μικιμάους μικκύλιο μικρά μικράγγουρο μικράνθρωπος μικράτα μικρέμπορας
μικρή είσοδος μικρή κουκουβάγια μικρανεψιά μικρανεψιός μικρανιψιά μικρανιψιός
μικρασιάτισσα μικροέκφραση μικροέξοδο μικροαγορά μικροαδίκημα μικροαμπέρ
μικροαπατεώνας μικροαποταμιευτής μικροαπόκλιση μικροαστή μικροαστισμός
μικροατύχημα μικροβένθος μικροβιαιμία μικροβιολογία μικροβιολόγος
μικροβιομετρία μικροβιομηχανία μικροβιοφαγία μικροβισμός μικροβιόμετρο
μικροβόλτ μικρογεύμα μικρογλωσσία μικρογράφος μικρογραμμάριο μικρογραμμάριον
μικροδάνειο μικροδίκτυο μικροδακτυλία μικροδευτερόλεπτο μικροδιακινητής
μικροδιαφοροποίηση μικροδορυφόρος μικροδουλειά μικροεγκληματίας μικροεκδορά
μικροεξαγωγή μικροεξυπηρέτηση μικροεπέμβαση μικροεπίπεδο μικροεπαγγελματίας
μικροεπιληψία μικροεπιχειρηματίας μικροζημιά μικροζυθοποιία μικροζυθοποιός
μικροθέλημα μικροθεμελίωση μικροθυμία μικροκαταθέτης μικροκατασκευή
μικροκαυλία μικροκεφαλία μικροκλέφτης μικροκλέφτρα μικροκλεψιά μικροκλοπή
μικροκομματισμός μικροκτηματίας μικροκυστίδιο μικροκυτταραιμία μικροκύκλωμα
μικροκύτταρο μικρολεπτομέρεια μικρολεπτομέρειες μικρολογία μικρολωποδύτης
μικρομάγαζο μικρομέλεια μικρομαστία μικρομελία μικρομεμβράνη μικρομεμβρανίδιο
μικρομετρία μικρομύκητας μικρονέκρωση μικρονανοηλεκτρονική
μικρονιζέ μικροοικοδόμηση μικροοικονομία μικροοινοποίηση μικροομολογιούχος
μικροοφειλέτης μικροπίστωση μικροπαλαιοντολογία μικροπαραβατικότητα
μικροπεριμετρία μικροπλανήτης μικροπολεμική μικροπολιτική μικροπονηριά
μικροπουτανιά μικροπράγματα μικροπράματα μικροπρέπεια μικροπωλητής μικρορρινία
μικρορχιδία μικροσεισμογράφος μικροσεισμός μικροσεκόντ μικροσκοπία
μικροσκόπιο μικροσυμπλοκή μικροσυμφέροντα μικροσυναλλαγή μικροσυστοιχία
μικροσύμβαση μικροσύμπαν μικροσύνη μικροτέχνημα μικροταινία μικροτεχνία
μικροτεχνίτρα μικροτοπωνύμιο μικροτραυματισμός μικροτσουτσουνιά
μικροφάγα μικροφίλμ μικροφαλλία μικροφθαλμία μικροφιλοδοξία μικροφιλοτιμία
μικροχαρά μικροχειρουργική μικροχημεία μικροχρηματοδότηση μικροχρονόμετρο
μικροψυχία μικροϊδιοκτήτης μικροϊδιοκτήτρια μικροϋπολογιστής μικροϋπόλοιπο
μικρόβιο μικρόδεμα μικρόζωο μικρόκαρφο μικρόκλιμα μικρόκοκκος μικρόκοσμος
μικρόν μικρόνοια μικρός μικρός μπούφος μικρός τελικός μικρόταξη μικρότητα
μικρόφωνον μικτονόμηση μιλέδη μιλένιουμ μιλέτ μιλιά μιλιγκράμ μιλιούνι
μιλιταρίστρια μιλιταρισμός μιλιταριστής μιλιόχημα μιλλέτ-μπασί μιλτογραφία
μιλόρδος μιμήτρια μιμί μιμίδιο μιμηματολογία μιμητής μιμητικότης μιμητικότητα
μιμογράφος μιμόγλωσσα μιμόδραμα μιμόζα μιμόρχημα μινάν μινάρας μιναδόρος
μινιατούρα μινιμαλίστρια μινιμαλισμός μινιμαλιστής μινοράκι μινουέτο μινούτο
μινυρισμός μινόρε μινύρισμα μιξάζ μιούζικαλ μιρ μιρίν μιραμπό μιραντέζ μις
μισάωρο μισέλλην μισέλληνας μισίρι μισαδάκι μισαλλοδοξία μισανδρία μισανθρωπία
μισεμός μισθάριο μισθάριον μισθοδικείο μισθοδοσία μισθολόγιο μισθολόγιον
μισθωτήριο μισθωτήριον μισθωτής μισθός μισθώτρια μισινέζα μισιρλής μισιρλού
μισογυνισμός μισογύνης μισονεϊσμός μισονεϊστής μισοφέγγαρο μισοφόρι μιστός
μιτάρωμα μιτάτος μιτογόνο μιτοξανδρόνη μνήμα μνήμη μνήμη τυχαίας προσπέλασης
μνήστευση μνήστευσις μνήστρα μνα μνεία μνημείο μνημείον μνημολογία
μνημονική μνημονικό μνημοσυναισθηματικός μνημοσύνη μνημοταξινόμηση
μνημούρι μνημόνευση μνημόνευσις μνημόνιο μνημόνιον μνημόσυνο μνημόσυνον
μνηστή μνηστήρ μνηστήρας μνηστεία μνᾶ μοίρα μοίραρχος μοίρασμα μοβ μογγολικά
μοδίστρα μοδιστράδικο μοδιστράκι μοδιστρική μοδιστρούλα μοιάσιμο μοιασίδι
μοιράδιον μοιράρης μοιράστρα μοιραρχία μοιρασιά μοιραστής μοιρογνωμόνιο
μοιροκρατία μοιρολάτρης μοιρολάτρις μοιρολάτρισσα μοιρολατρία μοιρολογήτρα
μοιρολόγι μοιρολόι μοιχαλίδα μοιχαλίς μοιχεία μοιχός μοκέτα μολάρισμα μολάσα
μολδαβικά μολοσσός μολπή μολυβάκι μολυβήθρα μολυβδένιο μολυβδίαση μολυβδαίνιο
μολυβδοκόνδυλο μολυβδοσωλήν μολυβδοσωλήνας μολυβδόβουλο μολυβδύαλος μολυβιά
μολυβοκόντυλο μολυντήρι μολότοφ μολόχα μολύβδωση μολύβδωσις μολύβι μολώχ
μομία μομιοποίηση μομιοποίησις μομφή μονάδα μονάρχης μονάρχιδος μονάς
μονέδα μονή μονήρη μοναδικότης μοναδικότητα μοναδισμός μοναδολογία μοναζίτης
μοναρχία μοναρχισμός μονασμός μοναστήρι μοναστήριον μοναστής μοναστηράκι
μοναχισμός μοναχογιός μοναχοθυγατέρα μοναχοκόρη μοναχολόγιο μοναχοπαίδι
μοναχοφαγία μοναχός μονεγάσκος μονεμβασίτης μονεμβασιώτης μονεταρισμός μονιά
μονιάτης μονιάτισσα μονιμάς μονιμοποίηση μονιμοποίησις μονιμότης μονιμότητα
μονιστής μονοαμίνη μονοβόλο μονογένεση μονογένεσις μονογαμία μονογονία
μονογράφησις μονογραμμικό μονογραφή μονογραφία μονοδραστηριότητα μονοδρόμηση
μονοερωτικότητα μονοθεΐα μονοθεσία μονοθεσίτης μονοθεσίτισσα μονοθεϊσμός
μονοκαλλιέργεια μονοκατοικία μονοκιάλι μονοκομματισμός μονοκονδυλιά
μονοκούκι μονοκράτορας μονοκράτωρ μονοκρατορία μονολιθικότητα μονολογία
μονομέρεια μονομανία μονομαχία μονομεταλλισμός μονομπακτάμες μονοξείδιο
μονοπάτι μονοπατάκι μονοπλάνο μονοπλάνον μονοπολιτισμός μονοπυρήνωση
μονοπόρτι μονοπώληση μονοπώλησις μονοπώλιο μονοπώλιον μονορχιδία μονοσάκχαρο
μονοσεξουαλικότητα μονοσημία μονοσημειακότητα μονοσταυρία μονοσυμπάντωση
μονοσυσσωμάτωση μονοτοκία μονοτονία μονοτονικό μονοτυπία μονοτύπης μονοφαγία
μονοφυσιτισμός μονοφωνία μονοχρωμία μονοψώνιο μονστέρα μοντάζ μοντάρισμα
μοντέρ μονταδόρος μονταζιέρα μοντελάκι μοντελίστ μοντελίστα μοντελίστας
μοντεράτο μοντερνίστρια μοντερνισμός μοντερνιστής μοντρεαλίτης μοντρεαλίτισσα
μονωδός μονωτήρ μονωτήρας μονωτής μονόγραμμα μονόδρομος μονόζυγο μονόκαννο
μονόκερως μονόκιαλο μονόκλ μονόκλινο μονόλιθος μονόλοβο μονόλογος μονόξυλο
μονόπετρο μονόστηλο μονότερμα μονόφυλλο μονόφυλλον μονόχειρ μονόχειρας
μονύδριο μονύελο μονύελος μονώνυμο μονώνυμον μονώροφο μορέα μορίδιο μοραστής
μορεών μοριακότητα μοριοσανίδα μορμολύκειο μορμολύκη μορμονισμός μορμυρισμός
μορμόνος μορς μορτάκι μορτή μορτίτης μορταδέλα μορταντέλα μορταρία μορφέα
μορφίνη μορφασμός μορφιά μορφινισμός μορφινομανία μορφογένεση μορφογονία
μορφοείδος μορφοκλαδόγραμμα μορφολογία μορφονιά μορφονιός μορφοποίηση
μορφοτροπέας μορφοτροπή μορφοτύπηση μορφοχημεία μορφόκλασμα μορφότυπο μορόζα
μοσκιά μοσκοβολιά μοσκοβόλημα μοσκοβόλια μοσκοκάρυδο μοσκοκάρφι μοσκοκαρυδιά
μοσκομάγκας μοσκομπίζελο μοσκοσάπουνο μοσκοστάφυλο μοσχάρι μοσχάτος μοσχίδα
μοσχαροκεφαλή μοσχοβολήθρα μοσχοβολιά μοσχοβόλημα μοσχογαλή μοσχοκάρυδο
μοσχοκαρυδιά μοσχολέμονο μοσχολίβανο μοσχομάγκας μοσχομπίζελο μοσχοσάπουνο
μοσχόμαγκας μοτέλ μοτέρ μοτέτο μοτίβο μοτίφ μοτοποδήλατο μοτοπορεία μοτοσακό
μοτοσικλετιστής μοτοσκικλετίστρια μοτοσυκλέτα μοτόρα μουαρέ μουβιόλα
μουγκαμάρα μουγκανητό μουγκρητό μουεζίνης μουζίκος μουζεβίρης μουζικάντης
μουζουδιά μουζούρι μουλάρα μουλάρι μουλάς μουλαράκι μουλαράς μουμιοποίηση
μουνάκιας μουνάρα μουνής μουνί μουνίτσα μουνιτσιόνε μουνοθύελλα μουνοπαγίδα
μουνοπλημμύρα μουνοχύσιμο μουνούχι μουνούχισμα μουνούχος μουντάδα μουντάρισμα
μουντζάλωμα μουντζαλιά μουντζουριά μουντζούρα μουντζούρης μουντζούρωμα
μουντούρα μουνόδουλος μουνόπανο μουνόπλυμα μουνόσκυλο μουνότριχα μουνότρυπα
μουνόψειρα μουράγιο μουράκλα μουράτος μουρέλο μουραύγια μουργέλα μουργέλας
μουριά μουρλέγκω μουρλαίγκω μουρλοκομείο μουρλοπαντιέρα μουρμουρητό μουρμούρα
μουρμούρω μουρντάρεμα μουρνταριά μουρουνέλαιο μουρουνόλαδο μουρούνα μουρτάτης
μουρτζούφλης μουσίτσα μουσακάς μουσαμάς μουσαμαδιά μουσαφίρης μουσαφιρλίκι
μουσειολογία μουσειολόγος μουσειοπαιδαγωγική μουσειοπαιδαγωγός μουσειοσκευή
μουσική μουσικοδιδάσκαλος μουσικοδιδασκάλισσα μουσικοθεραπεία μουσικολογία
μουσικομανία μουσικοσυνθέτης μουσικοσυνθέτρια μουσικός μουσικότητα μουσκέτο
μουσκότζιν μουσλούκι μουσμουλιά μουσμούλι μουσουλμάνα μουσουλμάνος
μουσουργός μουσούδα μουσούδι μουσούνισμα μουσσώνας μουστάκα μουστάκι
μουστάκιον μουστάρδα μουστέλα μουστακάκι μουστακαλής μουστακᾶτος μουσταλευριά
μουσταρδόπικλα μουσταρδόσουπα μουσταφάς μουστερής μουστιά μουστοβάρελο
μουστοπάτι μουστόγρια μουστόπιτα μουσώνας μουτάφης μουτεσαριφλίκι μουτζαλιά
μουτζουριά μουτζουρογραφία μουτζούρα μουτράκι μουτσουνάρα μουτσούνα
μουφλούζεμα μουφλόν μουφτής μουχαπέτι μουχρίτσα μουχταρλίκι μοχθηρία
μοχλοβραχίονας μοχλός μούγγα μούγκα μούγκρισμα μούδιασμα μούλα μούλιασμα
μούλκι μούλτιπλεξ μούμια μούναρος μούντζα μούντζωμα μούργα μούργος μούρη
μούρλια μούρο μούσα μούσι μούσκαρι μούσκεμα μούσκιο μούσκλι μούσκλο μούσλι
μούστακος μούστος μούτζα μούτρα μούτρο μούτρωμα μούτσος μούφα μούχλα
μούχρωμα μπoυρνούζι μπάγκα μπάγκος μπάζα μπάζο μπάζωμα μπάι πας μπάκα μπάκακας
μπάλος μπάλσαμο μπάλωμα μπάμια μπάμιας μπάμπαλο μπάμπουρας μπάμπω μπάνιο
μπάνκα μπάντα μπάντζο μπάντμιντον μπάρ μπάρα μπάριζα μπάρκο μπάρμαν μπάρμπας
μπάσιμο μπάσκετ μπάσκετ-μπολ μπάσκετμπολ μπάσο μπάστακας μπάσταρδη μπάσταρδος
μπάτζετ μπάτζος μπάτης μπάτλερ μπάτσα μπάτσισμα μπάτσος μπάφιασμα μπάφος
μπέζα μπέης μπέιζμπολ μπέικον μπέισσα μπέκρος μπέκρω μπέμπα μπέμπελη μπέμπης
μπέρδεμα μπέρι μπέρι μπέρτα μπέσα μπέτης μπήξιμο μπήχτης μπίβα μπίζνα μπίζνες
μπίθηκας μπίλι μπίλια μπίντα μπίπα μπίρα μπίχλα μπίχλας μπαΐλντισμα μπαΐρι
μπαγάζια μπαγάσας μπαγαμποντάκος μπαγαμποντιά μπαγαμπόντης μπαγαμπόντισσα
μπαγαποντιά μπαγασάκος μπαγασιά μπαγδαντί μπαγδατί μπαγιατίλα μπαγιονέτα
μπαγκάζια μπαγκάκι μπαγκέρης μπαγκέτα μπαγκαδόρος μπαγκανότα μπαγκατέλα
μπαγλάρωμα μπαγλαμάς μπαγλαμαδάκι μπαζoμετάλλευμα μπακ μπακάλαινα μπακάλης
μπακάλισσα μπακίρι μπακίρωμα μπακαλιάρος μπακαλιαράκι μπακαλική μπακαλόγατος
μπακαλόπουλο μπακαλόχαρτο μπακαράς μπακιρικό μπακιρτζής μπακλαβάς μπακούρι
μπαλ μασκέ μπαλάκι μπαλάντα μπαλάντζα μπαλάντσο μπαλάσκα μπαλένα μπαλέτο
μπαλαδόρος μπαλαλάικα μπαλαμή μπαλαμούτι μπαλαμούτιασμα μπαλαμός μπαλαντέρ
μπαλαούρο μπαλαούρος μπαλαρίνα μπαλαφουμάς μπαλιά μπαλκονάκι μπαλκονόπορτα
μπαλντάς μπαλοθιά μπαλονάκι μπαλσάμωμα μπαλτάς μπαλτίμι μπαλταδάκι μπαλταδιά
μπαλωθιά μπαλωματάκι μπαλωματής μπαλόνι μπαμ μπαμ τερλελέ μπαμπάκας μπαμπάκι
μπαμπάς μπαμπέσα μπαμπέσης μπαμπαδάκι μπαμπακοσυλλέκτης μπαμπακόσπορος
μπαμπεσιά μπαμπουίνος μπαμπού μπαμπούλας μπαμπούλης μπαμπόγερος μπαμπόγρια
μπανάνα μπανέλα μπαναλιτέ μπανανία μπανανιά μπανανόφλουδα μπανγκαλόου
μπανιάρισμα μπανιέρα μπανιερό μπανιστήρι μπανιστής μπανιστηρτζής μπανκέρης
μπανκανότα μπαντάνα μπαντάρισμα μπαντανάς μπαντανία μπαντιέρα μπαντονεόν
μπαξές μπαξίσι μπαξεβάνης μπαξεδάκι μπαουλάκι μπαουλοντίβανο μπαούλο μπαράζ
μπαράκιας μπαρέτα μπαρίστας μπαργούμαν μπαρδάκω μπαρκομπέστια μπαρμακλίκι
μπαρμπέρης μπαρμπέρικο μπαρμπακάνα μπαρμπακάς μπαρμπαρέσα μπαρμπεριάτικα
μπαρμπουνάρα μπαρμπουνοφάσουλο μπαρμπουτιέρα μπαρμπούλης μπαρμπούνι μπαρμπούτι
μπαρουτάδικο μπαρουτίλα μπαρουταποθήκη μπαρουτόβολο μπαρούμα μπαρούτη μπαρούτι
μπαρόβια μπαρόβιος μπαρόκ μπαρόμουτρο μπασίνα μπασίστας μπασαβιόλα μπασιά
μπασκέτα μπασκίνας μπασκίρ μπασκετμπολίστας μπασκλασαρία μπασμάς μπασμάτι
μπαστάρδεμα μπασταρδάκι μπασταρδάκος μπασταρδαίλουρος μπαστναζίτης μπαστουνάκι
μπαστουνιά μπαστουνόβλαχος μπαστούνα μπαστούνι μπαστούρα μπαστούρωμα μπατάκι
μπατίκ μπατίρης μπατίρισσα μπατίστα μπατακτσού μπατανία μπατανόβουρτσα
μπαταρία μπαταριά μπαταχτσής μπαταχτσού μπατζάκι μπατζανάκαινα μπατζανάκης
μπατιράκι μπατονέτα μπατουτόβολα μπατουτόσκαγα μπατσιά μπατσικό μπατσόπροκα
μπαχάρι μπαχαλάκι μπαχαλάκιας μπαχαράδικο μπαχαράς μπαχαρικό μπαχατέλα
μπαχτσές μπαϊράκι μπαϊράμι μπαϊρακτάρης μπαϊραχτάρης μπεΐνα μπεγίρι μπεγκάλι
μπεζ μπεζέρισμα μπεζές μπεζαχτάς μπεζεβέγκης μπεζεστένι μπεηλέρμπεης μπεηλίκι
μπεκάτσα μπεκατσίνι μπεκατσόνι μπεκερέλ μπεκιάρης μπεκιάρισσα μπεκιαριλίκι
μπεκριλίκι μπεκροκανάτα μπεκροκανάτας μπεκρολόγημα μπεκρολόι μπεκρού
μπεκρούλιασμα μπεκρόμουτρο μπελάς μπελαλής μπελαλίδισσα μπελαλού μπελαντόνα
μπεμπέ μπεμπέκα μπεμπές μπεμπούλα μπεμπούλης μπεμόλ μπεν μαρί μπενίνια
μπενετάδα μπενζίνα μπενινέζος μπεντέλι μπεντένι μπεντονίτης μπερέ μπερές
μπεργαντί μπεργαντίνο μπερδεμός μπερδεψιά μπερδεψοδουλειά μπερεδάκι μπερεκέτι
μπερκέλιο μπερκέτι μπερλίνα μπερμπάντεμα μπερμπάντης μπερμπάντισσα
μπερμπαντιά μπερντάκι μπερντάχι μπερντές μπερξονίστρια μπερξονισμός
μπερτάχι μπερτοδουλισμός μπερτόδουλος μπερτόλδος μπεσίκι μπεσαλής μπεσαλού
μπεστ σέλερ μπετατζής μπετονιέρα μπετοσίδερο μπετούγια μπετό μπετόβεργα
μπετόν μπετόνι μπετόχρωμα μπεχλιβάνης μπεϊλίκι μπεϋζιανισμός μπηχεϋβιορισμός
μπιέλα μπιαντές μπιγιέτα μπιγκουντί μπιγκόνια μπιγόνια μπιενάλε μπιζ μπιζέ
μπιζάρισμα μπιζέλι μπιζελιά μπιζελόσουπα μπιζουδάκι μπιζουτερί μπιζουτιέρα
μπικίνι μπικεριά μπικικίνια μπικουτί μπιλάκι μπιλιάρδο μπιλιέτο μπιλιετάκι
μπιμπίλα μπιμπίλωμα μπιμπελό μπιμπερό μπιμπιλίτσα μπιμπλουδάκι μπιμπλό μπινές
μπινελίκι μπινελίκια μπινιά μπιντές μπιντόνι μπιρίμπα μπιρίτσα μπιραρία
μπιραριέρης μπιρμπίλα μπιρμπίλι μπιρμπίλω μπιρμπιλίτσα μπιρμπιλομάτα
μπιρούλα μπιρόνι μπισκοτάκι μπισκοτοποιία μπισκότο μπισλάμα μπισμπίκης
μπιστιριά μπιστολιά μπιστοσύνη μπιστόλι μπιτ μπιτζάμα μπιτκόιν μπιτόνι
μπιχάρι μπιχεβιορισμός μπιχλιμπίδι μπλάζω μπλάνκο μπλάστρι μπλάστρωμα μπλέιζαρ
μπλέξιμο μπλακ εντ ντέκερ μπλακάουτ μπλαμπλά μπλε μπλιγούρι μπλιτζ μπλογκ
μπλοκ μπλοκάζ μπλοκάκι μπλοκάρισμα μπλοκέρ μπλονζόν μπλου τζιν μπλουζ
μπλουζίτσα μπλουζόν μπλουτζίν μπλουτσούνι μπλοφάρισμα μπλοφαδόρος μπλοφατζής
μπλούζα μπλόγκερ μπλόγκι μπλόκι μπλόκο μπλόκος μπλόφα μποά μποέμ μποβαρισμός
μπογαλάκι μπογαντέλα μπογιά μπογιάντισμα μπογιάρος μπογιατζής μπογιατζίδικο
μποζόνιο μπολ μπολάκι μπολερό μπολσεβίκα μπολσεβίκος μπολσεβικισμός μπομπάκι
μπομπίνα μπομπινοταινία μπομπονιέρα μπομποτάλευρο μπομποτσιλιά μπομπόνι
μπομπότσιλο μπον βιβέρ μπον φιλέ μπονάτσα μποναμάς μπονζάι μπονσάι
μποξ μποξάς μποξέρ μπορ μποραγκέλαιο μπορδέλο μπορμποτσιλιά μπορμπότσιλο
μπορντουροψάλιδο μπορντούρα μπορς μποσικάδα μποστάνι μποστανάκι μποσταντζής
μποτάκι μποτέ μποτίλια μποτίνι μποτιλιάρισμα μποτσάρισμα μποτσέλο μποτσόνι
μπουάτ μπουγάδα μπουγάδιασμα μπουγάζι μπουγάς μπουγάτσα μπουγέλο μπουγέλωμα
μπουγαδοκόφινο μπουγαρίνι μπουγαρινιά μπουγατσάκι μπουγατσατζίδικο
μπουγιαμπέσα μπουγιουρντί μπουγιότα μπουζί μπουζοκαλώδια μπουζουκάκι
μπουζουκλερί μπουζουκοκέφαλος μπουζουκοτράγουδο μπουζουκτσής μπουζουνάρα
μπουζουξίδικο μπουζού μπουζούκι μπουζόκλειδο μπουκάλα μπουκάλι μπουκάρισμα
μπουκίτσα μπουκίτσες μπουκαδούρα μπουκαδόρος μπουκαλάκι μπουκαμβίλια
μπουκετάρισμα μπουκιά μπουκλάκι μπουκλίτσα μπουκλωτός μπουκουνιά μπουλ
μπουλμές μπουλντοζιέρης μπουλντόγκ μπουλντόζα μπουλονόκλειδο μπουλουξής
μπουλούκος μπουλόνι μπουμ μπουμπάρι μπουμπάς μπουμπίνγκα μπουμπουνητό
μπουμπού μπουμπούκα μπουμπούκι μπουμπούκιασμα μπουμπούκισμα μπουμπούκος
μπουμπούνισμα μπουνάτσα μπουναμάς μπουνιά μπουνταλάς μπουνταλού μπουντουάρ
μπουράτζα μπουρέκι μπουρί μπουρίκι μπουρίνι μπουρανόσουπα μπουρδέλο
μπουρδελότσαρκα μπουρδολογία μπουρδούκλωμα μπουρζουάς μπουρζουαζία μπουρκίνι
μπουρλέσκο μπουρλοτιέρης μπουρμπουλήθρα μπουρμπουρέλια μπουρμπούτσαλο
μπουρού μπουρούχα μπουρτζόβλαχος μπουσούλημα μπουστάκι μπουτάκι μπουτίκ
μπουτόν μπουφάν μπουφές μπουφεδάκι μπουφετζής μπουφετζού μπουχάρα μπουχέσας
μποφόρ μποφόρια μποϊκοτάζ μποϊκοτάρισμα μποϊλής μποϋκοτάζ μπούγιο μπούζι
μπούκλα μπούκοβο μπούκωμα μπούλβερη μπούλης μπούλιγκ μπούλινγκ μπούλμπερη
μπούμαν μπούμερανγκ μπούμερανκ μπούνια μπούργκα μπούρδα μπούρκα μπούρμπερη
μπούσι μπούσουλας μπούστο μπούστος μπούτι μπούφος μπούχτισμα μπράβος μπράντα
μπράτιμος μπράτσο μπρέξιτ μπρίζα μπρίκι μπρίκι μπρίο μπρα ντε φερ μπρα-ντε-φέρ
μπραντεφέρ μπρασελέ μπρασερί μπρατσάκι μπρατσέρα μπρατσαράς μπρατσαρού
μπρατσόνι μπρελόκ μπρεντ μπρετέλα μπριάμι μπριγιάν μπριγιάντι μπριγιανίνη
μπριγιόλ μπριγκέτα μπριζολάδικο μπριζολάκι μπριζολίτσα μπριζόλα μπρικ μπρικέτα
μπριλάντι μπριλλάντι μπριντγκμανίτης μπρισίμι μπριτζ μπριτζόλα μπροκάρ
μπροσούρα μπροστάντζα μπροστάρης μπροστέλα μπροστιάρης μπροστινέλα μπρουσκέτα
μπρούντζα μπρούντζοι μπρούντζος μπρούσκο μπρούτζος μπρούτο μπρόκολο μπυραρία
μπόγιας μπόγκος μπόγος μπόδεμα μπόδιο μπόδισμα μπόι μπόλι μπόλια μπόλιασμα
μπόμπιρας μπόξερ μπόξι μπόρα μπόρεση μπόσης μπόσικα μπότα μπότζι μπότοξ μπότσα
μπύρα μυΐτιδα μυάγρα μυία μυαλγία μυαλουδάκι μυαλό μυασθένεια μυατονία
μυγάκι μυγίτσα μυγαλή μυγαράκι μυγδαλιά μυγδαλόψιχα μυγοπαγίδα μυγοσκοτώστρα
μυγοχάφτισσα μυγούλα μυγόχεσμα μυδογαριδόσουπα μυδοκαλλιέργεια
μυδοπίλαφο μυδοσαλάτα μυδράλιο μυδράλλιον μυδρίαση μυδρίασις μυδραλιοβόλο
μυδόσουπα μυελίτιδα μυελασθένεια μυελατέλεια μυελεγκέφαλος μυελογραφία
μυελοκυψέλη μυελοκύτταρο μυελοκύτταρον μυελομηνιγγίτιδα μυελομηνιγγίτις
μυελοσκλήρυνση μυελός μυζήθρα μυζηθροπιτάκι μυζηθρόπιτα μυζητήρ μυζητήρας
μυθιστοριογράφος μυθιστοριογραφία μυθιστόρημα μυθογράφος μυθογραφία μυθολογία
μυθολόγος μυθομανία μυθοπλάστης μυθοπλάστρια μυθοπλασία μυθοπλαστία μυθοποίηση
μυθοποιός μυκήτωση μυκήτωσις μυκηθμός μυκητίαση μυκητολογία μυκητολόγος
μυκονιάτης μυκονιάτισσα μυκοπρωτεΐνη μυκοτοξίνη μυκτήρ μυκτηρισμός μυκτηριστής
μυλαύλακας μυλαύλακο μυλοκόπι μυλοστέρνα μυλοτόπι μυλωθρός μυλωνάς μυλωνού
μυλόπετρα μυλόρδος μυλότοπος μυξαδένας μυξαδήν μυξοίδημα μυξομάντιλο
μυογράφημα μυογράφος μυοκάρδιο μυοκαρδίτιδα μυοκαρδίτις μυοκαρδιοπάθεια
μυομήτριο μυοπάθεια μυοπάρων μυοπαγίς μυοσωτίδα μυοσωτίς μυοτομία μυρέψημα
μυρεψείον μυρεψός μυριάδα μυριάμετρο μυριάποδο μυριάς μυριοστημόριο μυρμήγκι
μυρμηγκάκι μυρμηγκιά μυρμηγκοφάγος μυρμηγκοφωλιά μυρμηγκότρυπα μυρμηκίαση
μυροβλύτης μυροδοχείο μυροποιία μυροποιείο μυροποιός μυροπωλείο μυροπώλης
μυρσίνη μυρσινέλαιο μυρσινέλαιον μυρσινόκοκκος μυρτιά μυρτόλη μυρτώνας μυρτώο
μυρωδικό μυς μυσαρότης μυσαρότητα μυστήριο μυστήριον μυσταγωγία μυσταγωγός
μυστηριανιστής μυστηριολογία μυστικίστρια μυστικισμός μυστικιστής
μυστικοσυμβούλιο μυστικοσυμβούλιον μυστικοσύμβουλος μυστικό μυστικόν
μυστικότητα μυστρί μυστρίον μυτάκι μυτάρα μυτίλος μυτίτσα μυταράς μυταρού
μυτιά μυτιληνιά μυτιληνιός μυτιλοτροφία μυτιλοτροφείο μυτιλοτροφείον
μυτούλα μυχός μυωπία μυώνας μωαμεθανή μωαμεθανισμός μωαμεθανός μωβ μωλωπισμός
μωρία μωρολογία μωρολόγημα μωρολόγος μωρομάντηλο μωροπιστία μωροσοφία
μωρουδέλι μωρουδίσματα μωρουδιακά μωροφιλοδοξία μωρούδι μωρό μωρόπουλο
μωσαϊκό μωσαϊσμός μόα μόγλης μόδα μόδι μόδιο μόδιστρος μόκα μόκρα μόκσα μόλεμα
μόλυβδος μόλυνση μόλυνσις μόλυσμα μόμπιλο μόνιππο μόνιππον μόνιτορ μόνοιασμα
μόνωση μόνωσις μόρα μόριο μόρον μόρσο μόρτης μόρτικα μόρτισσα μόρφημα μόρφωμα
μόσκος μόστρα μόσχευμα μόσχευση μότα μότο μότορσιπ μόχθος μόχλευση μόχτος μύαξ
μύγδαλο μύδι μύδρος μύζηση μύηση μύησις μύθευμα μύθος μύκητας μύλη μύλλα μύλος
μύξωμα μύραινα μύρισμα μύρμηγκας μύρμηξ μύρο μύρτιλλο μύρτιλο μύρτο μύρτος
μύρωση μύσις μύστακας μύσταξ μύστρισμα μύτη μύτιλος μύωμα μύωπας μύωση μύωψ
μώλυ μώλωπας μώμος μώρα νάβα νάγια νάζι νάιλον νάιρα νάιτ κλαμπ νάκα νάκαρα
νάμα νάμι νάνι νάνος νάουατλ νάπη νάρδος νάρθηκας νάρκη νάρκισσος νάρκωση
νάτρο νάφθα νέα νέαση νέγρα νέγρος νέηλυς νέι νέκρα νέκρωμα νέκρωση νέκταρ
νέμεσις νένα νέο νέον νέοπας νέραϊδος νέρωμα νέφαλο νέφος νέφτι νέφωση νήδυμος
νήπιο νήπιον νήριον νήσοι φώκλαντ νήσος νήσσα νήστεια νήστις νίκελ νίκη νίλα
νίτρο νίτρωση νίψιμο νίψις ναΐδιο ναΐσκος ναΰδριο ναβάχο ναβέτα ναγέτα ναδίρ
ναζισμός ναζιστής ναι ναμάζι ναματερό νανάκια νανισμός νανοαπολίθωμα
νανοβιοτεχνολογία νανοβιταμίνη νανοδευτερόλεπτο νανοδιάταξη νανοηλεκτρονική
νανοκεφαλία νανοκλίμακα νανοκλωστή νανοκορμία νανοκράμα νανομελία
νανονήμα νανοπροϊόν νανορομπότ νανοσεκόντ νανοσκόπιο νανοσωλήνας νανοσωμία
νανοτεχνολογία νανοφυλή νανοϋλικό νανούρισμα νανόμετρο νανόμπουφος νανόφιδο
νανόχεντρα ναξιώτης ναξιώτισσα ναοδομία ναουρού ναπάλμ ναπολεόνι ναπολιτάνικα
ναργιλές ναρκαλιεία ναρκαλιευτής ναρκαλιευτικό ναρκισσισμός ναρκοδηλητηρίαση
ναρκοθέτις ναρκοθεραπεία ναρκοληψία ναρκομανία ναρκοπέδιο ναρκοσυλλέκτης
ναρκωτής ναρκωτικά ναρκωτικό ναρκόφυτο νασερισμός νασεριστής ναστόδερμα
ναστόχαρτο νατιβισμός νατουραλισμός νατουραλιστής νατράσβεστος νατριαιμία
ναυαγιαίρεση ναυαγιαιρέτης ναυαγιαιρεσία ναυαγοσωστικό ναυαγοσώστης ναυαρχία
ναυαρχείο ναυκληρία ναυλάριθμος ναυλαγορά ναυλολόγιο ναυλομεσίτης
ναυλομεσιτεία ναυλοσυμφωνητικό ναυλοσύμφωνο ναυλοτιμάριθμος
ναυλωτήριο ναυλωτής ναυλωτικό ναυλώτρια ναυμάχος ναυμαχία ναυπήγημα ναυπήγηση
ναυπηγείο ναυπηγοεπισκευή ναυπηγοεπισκευαστική ναυπηγοξυλουργός ναυπηγός ναυς
ναυσιπλοΐα ναυτάθλημα ναυτάκι ναυτία ναυτίαση ναυτίλος ναυταθλητής
ναυταπάτη ναυταποστολή ναυτασφάλεια ναυτασφάλιση ναυτασφαλιστής ναυτεργάτης
ναυτικό ναυτικός ναυτιλία ναυτοδάνειο ναυτοδίκης ναυτοδικείο ναυτολογία
ναυτολόγιο ναυτολόγος ναυτομεσίτης ναυτομοντελισμός ναυτομοντελιστής ναυτοσύνη
ναυτόπαιδο ναυτόπουλο ναυτώνας ναφθαλίνη ναφθαλίνιο ναωνύμιο ναϊάδα
ναός ναύαρχος ναύδετο ναύκληρος ναύλα ναύλερος ναύλος ναύλωμα ναύλωση
ναύτης νγκόνι νεάνις νεάργυρος νεανίας νεανίσκος νεανικότητα νεαρός νεαρότητα
νεβρίδα νεβρός νεγκλιζέ νεκράνθεμο νεκρανάσταση νεκρεγερσία νεκροβίωση
νεκροθάφτης νεκροθήκη νεκροκέρι νεκροκεφαλή νεκροκρέβατο νεκρολάτρης
νεκρολογία νεκρολούλουδο νεκρομάντης νεκρομαντεία νεκρομαντείο νεκροπομπή
νεκροπούλι νεκροσέντουκο νεκροστόλισμα νεκροσυλία νεκροταφείο νεκροτομή
νεκροτομείο νεκροφάνεια νεκροφιλία νεκροφοβία νεκροφυλακείο νεκροφόρα
νεκροψία νεκρόδειπνο νεκρόδειπνος νεκρός νεκρότητα νεκρόφιλος νεκρόφοβος
νεκρώσιμον νεκταρίνι νενέ νενέκος νεοέλληνας νεοαθεϊσμός νεοανθρωπισμός
νεοαποικισμός νεοαπομονωτισμός νεοβιταλισμός νεογιλοί νεογνολογία νεογνολόγος
νεοδαρβινισμός νεοδημοκράτης νεοδογματικός νεοδύμιο νεοεβραίος νεοελληνίστρια
νεοελληνιστής νεοεμπρεσιονίστρια νεοεμπρεσιονισμός νεοεμπρεσιονιστής
νεοθετικισμός νεοκαντιανισμός νεοκαπιταλισμός νεοκαρτεσιανισμός
νεοκλασικισμός νεοκλασικιστής νεοκορπορατισμός νεοκύστη νεολαία νεολαίος
νεολογισμός νεομάρτυρας νεομαρξισμός νεομπαρόκ νεομυκίνη νεοναζί νεοναζίστρια
νεοναζιστής νεονορβηγικά νεοουμανισμός νεοπαγανίστρια νεοπαγανισμός
νεοπλασία νεοπλαστία νεοπλατωνισμός νεοπλουτισμός νεορεαλισμός νεορομαντισμός
νεοσατανιστής νεοσκητιώτης νεοσμυρνιώτης νεοσσός νεοσύλλεκτος νεοσύλλεχτος
νεοτουρκισμός νεοφασίστας νεοφασίστρια νεοφασισμός νεοφιλελευθερισμός
νεοφλοιός νεοφοβία νεοφροϊδίστρια νεοφροϊδισμός νεοφροϊδιστής νεπάλι νεπαλέζος
νερά νεράγγουρο νεράγκαθο νεράιδα νεράιδος νεράκι νεράντζι νεραγκούλα
νεραντζάνθι νεραντζιά νεραντζούλα νεραϊδάρης νεραϊδόξυλο νεραϊδόπαιδο
νεραϊδόπουλο νεραϊδόχορτο νεροβάρελο νερογυρισιά νεροδεσιά νεροζούμι νεροζύγι
νεροκάνατο νεροκάρδαμο νεροκανάτα νεροκολοκυθιά νεροκολοκύθα νεροκολόκυθο
νεροκουβαλητής νεροκράτης νερολάπαθο νερολαδιά νερολούλουδο νερομάζωμα
νερομολόχα νερομπογιά νερομπούλι νεροποντή νεροποταμίδα νεροπουλάδα νεροπούλι
νεροπότηρο νεροστρόβιλος νεροσυρμή νεροσωλήνας νεροτριβή νερουλάς νεροφάγωμα
νεροφόρημα νεροχελίδονο νεροχελώνα νεροχύτης νερούλιασμα νερό νερόβρασμα
νερόκρασο νερόκρινο νερόλακκος νερόμπομπα νερόμυλος νερόπιασμα νερόπλυμα
νες νεσκαφέ νετ νετάρισμα νετρίνο νετρόνιο νευρά νευράξονας νευρίασμα
νευραέριο νευραλγία νευρασθένεια νευρείλημα νευρεκτόνωση νευρεπιστήμη
νευρικός άξονας νευρικότητα νευρο-ουρολόγος νευροανάδραση νευροανάπτυξη
νευροαρθριτισμός νευροβιολογία νευροβλάστη νευρογένεση νευρογλοία
νευρογνωσία νευροδίκτυο νευροδερματίτιδα νευροδιέγερση νευροδιαβιβαστής
νευροδικτυολογία νευροδικτυολόγος νευροδικτυολόγος νευροδικτύωση
νευροεπιστήμες νευροεπιστήμη νευροεπιστήμονας νευροηθολογία νευροκαβαλίκεμα
νευροληπτικά νευρολογία νευρολόγος νευρομυελίτιδα νευρομυελίτις νευροουρολογία
νευροπάθεια νευροπαθολογία νευροπαρακολούθηση νευροπεπτιδίο υ
νευροπληξία νευροπλοηγός νευρορραφή νευρορραφία νευροτομή νευροτομία
νευροτροπισμός νευροφυσιολογία νευροχειρουργική νευροχειρουργός νευροχημεία
νευροψυχολογία νευροψυχολόγος νευροωτολογία νευροωτολόγος νευρωνικά δίκτυα
νευρωτικότητα νευρωτισμός νευρόσπασμα νευρόσπαστη νευρόσπαστο νευρόσπαστος
νευρώνας νεφέλη νεφέλιον νεφέλωμα νεφεληγερέτης νεφελοβάτης νεφελομαντεία
νεφολογία νεφομετρία νεφοσκόπιο νεφοϋπολογιστική νεφρί νεφρίδιο νεφρίδιον
νεφρίτης νεφρίτιδα νεφρίτις νεφραλγία νεφραμιά νεφρεκτομή νεφρεκτομία
νεφρολιθίαση νεφρολιθίασις νεφρολογία νεφρολόγος νεφροουρητηρεκτομή
νεφροπάθεια νεφροπτωσία νεφροσκόπιο νεφροτομή νεφροτομία νεφρό νεφρόλιθος
νεφρός νεφόκαμα νεωδόχος νεωκορία νεωκόρισσα νεωκόρος νεωλκείο νεωλκείον
νεωτερίστρια νεωτερικότητα νεωτερισμός νεωτεριστής νεόπλασμα νεότητα νεύμα
νεύρο νεύρωμα νεύρωση νεύσις νεώλκησις νεώλκιο νεώριο νεώριο νεώσοικος νη
νημάτιον νημάτωμα νηματίαση νηματίασις νηματομύκητες νηματοποίηση νηματουργία
νηματουργός νηματόζωο νηματόσταυρος νηνεμία νηογνώμονας νηογνώμων νηοδόκη
νηολόγηση νηολόγιο νηολόγιον νηοπομπή νηοψία νηπενθές νηπιαγωγείο νηπιαγωγός
νηπιοβαπτιστής νηπιοκτονία νηπιοκόμος νηπιολόγος νηρηίδα νησάκι νησί νησίδα
νησιωτικότητα νησιωτοπούλα νησιωτόπουλο νησιώτης νησιώτις νησιώτισσα
νησσοτροφείο νησσοτροφείον νηστίσιμα νηστεία νηστευτής νηστεύτρια νηστικάδα
νηφαλιότητα νι νιάμα νιάμερα νιάνιαρο νιάου νιάουρο νιάσιμο νιάτα νιάτο νια
νιανιά νιαούρισμα νιασίνη νιζάμης νιζάμι νιζατιδίνη νικάμπ νικέλιο νικέλωμα
νικήτρια νικελίνης νικελιοχάλυβας νικελοβιομηχανία νικητήρια νικητής νικοτίνη
νικοτινίασις νικοτινισμός νινί νινίδα νιογάμπρια νιονιό νιππονισμός νιπτήρ
νιρβάνα νιρβάνα νισάφι νισαντήρι νισεστές νισυριώτης νιτερέσο νιτροβάμβακας
νιτρογλυκερίνη νιτρογόνο νιτροποίηση νιτρορύπανση νιτσεΐστρια νιτσεράδα
νιτσεϊστής νιφάδα νιφετός νιφτήρας νιχιλίστρια νιχιλισμός νιχιλιστής νιόβιο
νιόγαμπρος νιόνυφη νιότη νιώσμα νιώτης νοίκι νοίκιασμα νοβοκαΐνη νοδάρος
νοημοσύνη νοησιαρχία νοησιοκρατία νοητικό πείραμα νοητικότητα νοθεία
νοθογονία νοθός νοικάρης νοικάρισσα νοικοκερά νοικοκεριό νοικοκυρά νοικοκυριό
νοικοκυροσύνη νοικοκυρόπαιδο νοικοκυρόσπιτο νοικοκύρης νοκ άουτ νομάρχις
νομάς νομάτισμα νομάτοι νομέας νομή νομίατρος νομαρχείο νοματαίοι
νομεύς νομικά νομική νομικισμός νομικός νομιμοποίηση νομιμοφάνεια
νομιμότητα νομιναλισμός νομιναλιστής νομισματική νομισματοδέκτης νομισματοθήκη
νομισματοκοπείο νομισματολογία νομισματολόγος νομισματοπώλης
νομισματοσυλλέκτρια νομογράφημα νομογραφία νομοδιδάσκαλος νομοθέτημα νομοθέτης
νομοθεσία νομοκάνονας νομοκρατία νομολογία νομομάθεια νομομαθής νομοσχέδιο
νομπέλ νομπέλιο νομπέτης νομπελίστας νομπελίστρια νομός νον πέιπερ νονά νονός
νοομαντεία νοοτροπία νοούμενο νορβηγέζος νορβηγίδα νορβηγικά νορβηγός
νοσήλια νοσήλιο νοσηλεία νοσηλευτήριο νοσηλευτής νοσηλεύτρια νοσηρότης
νοσογραφία νοσοκομείο νοσοκομείον νοσοκομειακό νοσοκομεῖον νοσοκόμα νοσοκόμος
νοσομανία νοσοφοβία νοσταλγία νοσταλγός νοστιμάδα νοστιμιά νοσφισμός νοτάρι
νοτιά νοτιάς νοτιοαφρικανή νοτιοαφρικανός νοτισμός νουά νουβέλα νουθέτηση
νουκλεΐνη νουκλεοσύνθεση νουκλεοτίδιο νουμερολογία νουμηνία νουνά νουνέχεια
νους νούλα νούμερο νούννα νούντσιος νούφαρο ντάβα ντάλια ντάμα ντάμπιγκ
ντάνα ντάνιασμα ντάνσιγκ ντάνσινγκ ντάντεμα ντάπια ντάρα ντέντεκτιβ ντέρμπι
ντέτεκτιβ ντέφι ντίβα ντίζα ντίζελ ντίλερ ντίρλι ντίρλι ντίσκο ντα κάπο νταής
νταβέτι νταβαντούρι νταβατζής νταβατζιλίκι νταβατούρι νταβούλι νταγκλαράς
νταηλίκι ντακότα νταλάκι νταλίκα νταλαβέρι νταλαβερτζής νταλγκάς νταλιάνι
νταλικιέρης νταλκάς νταλκαδιάρης νταμάρι νταμαζλούκι νταμαρτζής νταμιάνα
νταμλάς νταμουζλούκι νταμπλ νταμπλάς νταντά νταντέλα ντανταϊσμός νταουλιέρης
νταρί νταραβέρι νταραβερτζής νταρμστάντιο νταρντάνα ντατούρα νταϊλίκι νταϊφάς
ντεβανάγκαρι ντεγκιστασιόν ντεγκραντέ ντεζά βυ ντεζαμπιγιέ ντεκαπάζ ντεκοβίλ
ντεκολτέ ντεκορασιόν ντεκορατέρ ντεκουπάζ ντεκουπάρισμα ντεκρεσέντο
ντεκόρ ντελάλης ντελής ντελίβερι ντελίριο ντελαπόνγκο ντελαπόνκο ντελβές
ντελιβεράς ντεμέλα ντεμί-σεζόν ντεμακιγιάζ ντεμαράζ ντεμπουτάρισμα ντεμπούτο
ντενεκές ντενεκεδάκι ντεντέκτιβ ντεπό ντεπόζιτο ντεπώ ντερέκι ντερβέναγας
ντερβίσης ντερλίκωμα ντερμπεντέρης ντερμπεντέρικος ντερμπεντέρισσα ντερτιλής
ντεσιμπέλ ντεσού ντετέκτιβ ντετερμινισμός ντεφετισμός ντεφετιστής ντεφιλέ
ντεϊστής ντζόνγκα ντιβάνι ντιβανάκι ντιβανοκασέλα ντιβανομπάουλο ντιβεχί
ντιζάιν ντιζάινερ ντιζέζ ντιζέρ ντιζελοκίνηση ντικταφόν ντιλετάντης
ντιμινουέντο ντιμπέιτ ντιπ ντιρέκτ ντιρεκτίβα ντιρμπάζα ντιρχάμ ντισιλίδικο
ντισκοτέκ ντισλίδικο ντιστριμπιτέρ ντο ντοβλέτι ντογάνα ντογκ ντογκόν ντοκ
ντοκουμέντο ντοκουμεντάρισμα ντοκτορά ντοκυμαντέρ ντολμάς ντολμαδάκι ντομάτα
ντοματίνι ντοματιά ντοματοπελτές ντοματοπολτός ντοματοσάλτσα ντοματοσαλάτα
ντοματοχυμός ντοματόζουμο ντοματόσουπα ντομπροσύνη ντοπάρισμα ντοπαμίνη
ντοπιολαλιά ντορής ντορβάς ντορός ντοσιέ ντοτόρος ντου ντουάλα ντουέτο ντουί
ντουβαρτζής ντουζ ντουζένι ντουζίνα ντουζιέρα ντουκιάνι ντουλάπα ντουλάπι
ντουλαπάκι ντουμάνι ντουμπλάρισμα ντουμπλέ ντουμπλές ντουνιάς ντουντούκα
ντουρβάς ντους ντουσουρμές ντουφέκι ντουχιουμάνης ντούκος ντούμπλεξ ντούπλεξ
ντράβαλα ντράμερ ντρέσινγκ ντρίλι ντρίμπλα ντρίπλα ντραμίστας ντραμαμίνη
ντραμς ντρεσάζ ντρεσάρισμα ντριμπλέρ ντριν ντριστέλα ντροβάς ντρομπροσύνη
ντροπαλοσύνη ντροπαλότητα ντρουβιό ντρούβι ντρόγκα ντρόπιασμα ντσάτι ντόκος
ντόμινο ντόμπερμαν ντόμπρα ντόνατ ντόπα ντόπινγκ ντόπιος ντόρος ντόρτι ντόρτια
ντότζο ντύμα ντύσιμο νυγμός νυκταλωπία νυκτεγερσία νυκτερίδα νυκτοπορία
νυκτοφύλακας νυκτοφύλαξ νυκτωδία νυμφίδιο νυμφίοι νυμφίος νυμφαία νυμφαίο
νυμφομανής νυμφομανία νυμφώνας νυξ νυστέρι νυσταγμογραφία νυσταγμός νυστεριά
νυφικό νυφοπάζαρο νυφούλα νυχάκι νυχιά νυχοκόπτης νυχτέρεμα νυχτέρι νυχταλωπία
νυχτιά νυχτικιά νυχτικό νυχτοκάματο νυχτοκόπημα νυχτοκόπος νυχτολουλουδέλαιο
νυχτοπαρωρίτης νυχτοπαρωρίτρα νυχτοπερπάτημα νυχτοπεταλούδα νυχτοπούλι
νυχτοφύλακας νυχτωδία νωθρότης νωθρότητα νωμίτης νωματάρχης νωπογραφία
νωτοχορδή νωχέλεια νωχελικότητα νόβιαλ νόημα νόηση νόθευση νόμισμα νόμος
νόνα νόρμα νόσημα νόσος νόστος νότα νότα νότια σότο νότισμα νότος νύγμα
νύμφευσις νύμφη νύξη νύξις νύστα νύφη νύχι νύχτα νύχτωμα νώμος νώτα νᾶπυ ξάγι
ξάδελφος ξάδερφος ξάδικο ξάθροι ξάι ξάκρισμα ξάλη ξάμπελο ξάναμμα ξάνθισμα
ξάνιον ξάνοιγμα ξάνσις ξάντης ξάντρια ξάπλα ξάπλωμα ξάργητα ξάρτι ξάρτια
ξάσμα ξάσπρισμα ξάφνιασμα ξάφνισμα ξάφρα ξάφρισμα ξέβαμμα ξέβγα ξέβγαλμα
ξέβρασμα ξέγδαρμα ξέγνοιασμα ξέδομα ξέζεμα ξέζωσμα ξέθαμμα ξέκαμα ξέκλωνο
ξένα ξένη ξένο ξένοιασμα ξένον ξένος ξέντυμα ξέπεσμα ξέπλεγμα ξέπλυμα ξέρα
ξέρασμα ξέρη ξέσιμο ξέσις ξέσκασμα ξέσκισμα ξέσπασμα ξέστρα ξέστρο ξέστρον
ξέφραγμα ξέφτι ξέφτισμα ξέφωτο ξέχεσμα ξέχωμα ξέχωσμα ξήλωμα ξήρανση ξίγκι
ξίνισμα ξίπασμα ξίφος ξαίθρα ξαβεριώτης ξαγκίστρωμα ξαγνάντεμα ξαγναντευτής
ξαγοράρης ξαγορευτής ξαγρύπνημα ξαγρύπνια ξαγρύπνισμα ξαγόρεμα ξαδέλφη ξαδέρφη
ξαδερφοσύνη ξαδερφούλα ξαδερφούλης ξαδιάντροπος ξαερό ξακρίδι ξαλάφρωμα
ξαμπελώνω ξανάνιωμα ξανάσασμα ξανάστροφη ξαναβράσιμο ξαναγύρισμα ξαναζωντάνεμα
ξανακύλισμα ξαναμοίρασμα ξαναρχίνισμα ξανασμίξιμο ξανασπρώξιμο ξανατύπωμα
ξανθιά ξανθιώτης ξανθογένης ξανθοκυανωπία ξανθοκύτταρο ξανθομαλλού
ξανθομπούμπουρας ξανθοπώγων ξανθοφύλλη ξανθοψία ξανθούλα ξανθούλης ξανθόθριξ
ξαντήριο ξαντίμεμα ξαντικά ξαντιμεμός ξαντό ξαντόν ξαπλωσιά ξαπλωτήρα
ξαπλωταριό ξαπλώστρα ξαπόδεμα ξαπόσταμα ξαράχνιασμα ξαρμάτωμα ξαρμύρισμα
ξαστεριά ξαστοχιά ξαστόχημα ξαφίρι ξαφνικό ξαφνισμός ξεΐδρωμα ξεβάσκαμα
ξεβιράρισμα ξεβλάσταρο ξεβλαστάρωμα ξεβοτάνισμα ξεβούλωμα ξεβράκωμα ξεβράκωτη
ξεγάλομα ξεγάλωμα ξεγάντζωμα ξεγέλασμα ξεγέννημα ξεγελάστρα ξεγελαστής
ξεγνοιασιά ξεγοφιάρα ξεγοφιάρης ξεγόφιασμα ξεγύμνωμα ξεγύρισμα ξεδίπλωμα
ξεδιάλεγμα ξεδιάλυμα ξεδιαντροπιά ξεδικιωμός ξεδικιωτής ξεδόντιασμα ξεζούμισμα
ξεθάρρεμα ξεθάψιμο ξεθέωμα ξεθεμέλιωμα ξεθεμελιωτής ξεθόλωμα ξεθύμασμα
ξεκάκιωμα ξεκάλτσωμα ξεκάμπισμα ξεκάμωμα ξεκάπνισμα ξεκάρφωμα ξεκίνημα
ξεκαθάρισμα ξεκαλοκαίριασμα ξεκαλούπωμα ξεκαπάκωμα ξεκαπέλωμα ξεκαπίστρωμα
ξεκινητής ξεκλήρισμα ξεκλείδωμα ξεκλώσημα ξεκοίλιασμα ξεκοκάλισμα ξεκολλημός
ξεκούμπισμα ξεκούραση ξεκούρασμα ξεκούτιασμα ξεκρέμασμα ξεκόλλημα ξεκώλωμα
ξελάσπωμα ξελάφρωμα ξελέπισμα ξελίγωμα ξελαίμιασμα ξελαρύγγιασμα ξελαρύγγισμα
ξελευθερία ξελογιάστρα ξελογιαστής ξελόγιασμα ξεμάλλιασμα ξεμάτιασμα
ξεμαντάλωμα ξεμασκάλισμα ξεμασκαλίδι ξεματιάστρα ξεμαυλίστρα ξεμαυλιστής
ξεμονάχιασμα ξεμούδιασμα ξεμούχλιασμα ξεμπάχαλο ξεμπέρδεμα ξεμπαρκάρισμα
ξεμπλοκάρισμα ξεμποτσάρισμα ξεμπουκάρισμα ξεμπράτσωμα ξεμπρόστιασμα ξεμυάλισμα
ξεμυαλιστής ξεμώραμα ξενάγηση ξενέρα ξενέρισμα ξενέρωμα ξενία ξεναγία ξεναγός
ξενηλασία ξενικούρα ξενισμός ξενιστής ξενιτεμός ξενιτιά ξενοίκιασμα
ξενογαμία ξενογλωσσία ξενοδουλευτής ξενοδουλεύτρα ξενοδοχείο ξενοδοχοϋπάλληλος
ξενοδόχος ξενοιασιά ξενοκληρία ξενοκρατία ξενολάτρης ξενολατρία ξενομανία
ξενομερίτισσα ξενορεξία ξενοτροπία ξενοτροπισμός ξενοφιλία ξενοφοβία
ξεντύσιμο ξενυχτάδικο ξενόκουμπο ξενόφοβος ξενύχιασμα ξενύχτης ξενύχτι
ξενύχτισσα ξενών ξενώνας ξεπάγιασμα ξεπάστρεμα ξεπάτωμα ξεπέζεμα ξεπέρασμα
ξεπέταγμα ξεπίκρισμα ξεπαλούκωμα ξεπαρθένεμα ξεπαρθενευτής ξεπατικωτούρα
ξεπεταρούδι ξεπεταρόνι ξεπλάνεμα ξεπλάτισμα ξεπλήρωμα ξεποδάριασμα
ξεπούλημα ξεπροβάδισμα ξεπροβόδισμα ξεπόρτισμα ξεράδι ξερή ξερίζωμα ξερατό
ξεριζωμός ξεροβούνι ξεροβόρι ξεροκεφαλιά ξεροκοκκίνισμα ξεροκόμματο ξερολίθι
ξερονήσι ξεροπήγαδο ξεροπόταμο ξεροπόταμος ξεροστάλιασμα ξεροσφύρι ξεροτήγανο
ξεροτηγανίδι ξεροφαγία ξεροχόρταρο ξεροψήσιμο ξερσίλα ξερό ξερόβηχας ξερόβρυση
ξερόκλαδο ξερόλας ξερόνησος ξερότοπος ξερόφυλλο ξερόχορτο ξερόψωμο ξεσέλωμα
ξεσαβούρωμα ξεσαμάρωμα ξεσηκωμός ξεσκάλισμα ξεσκάλωμα ξεσκέπασμα ξεσκαρτάρισμα
ξεσκλάβωμα ξεσκλίδι ξεσκονίστρα ξεσκονιστήρι ξεσκονόπανο ξεσκούντημα
ξεσκόλισμα ξεσκόνισμα ξεσπάθωμα ξεσπίτωμα ξεσπόριασμα ξεστάχυασμα ξεστήρ
ξεστράβωμα ξεστράτισμα ξεστροπαγίδα ξεστόλισμα ξεσυνέριο ξεσυνέριση
ξεσφράγιση ξεσφράγισμα ξετάπωμα ξετέντωμα ξετίναγμα ξετιμητής ξετρύπωμα
ξετσιπωσιά ξετυλιγάδι ξετύλιγμα ξευτίλας ξεφάντωμα ξεφάντωση ξεφαντωτής
ξεφλούδισμα ξεφορμάρισμα ξεφούρνισμα ξεφούσκωμα ξεφτέρι ξεφτέρια ξεφτίδι
ξεφτίλας ξεφωνητό ξεφόρτωμα ξεφύλλισμα ξεφύσημα ξεφύτρωμα ξεχέρσωμα
ξεχασιά ξεχείλισμα ξεχείλωμα ξεχείμασμα ξεχείριασμα ξεχειμαδιό ξεχειμώνιασμα
ξεχρέωμα ξεχόλιασμα ξεχόντρισμα ξεχώρισμα ξεψάρωμα ξεψάχνισμα ξεψείρισμα
ξεψύχισμα ξηγήτρα ξηγητής ξημέρωμα ξημαρισιά ξημαρόλογια ξηρά ξηραντήρας
ξηρασία ξηροδερμία ξηροκάρπι ξηροκαλλιέργεια ξηροκλίβανος ξηρολιθοδομή
ξηροστομία ξηροφαγία ξηροφθαλμία ξηρόπισσα ξηρότης ξηρότητα ξηρόφυτα ξι
ξικισμός ξινάδα ξινάρι ξινήθρα ξινίλα ξινοκέρασο ξινομηλιά ξινομούνα
ξινό ξινόγαλα ξινόγαλο ξινόμηλο ξιπασιά ξιπολησιά ξιφίας ξιφίδιο ξιφασκία
ξιφιός ξιφοθήκη ξιφολόγχη ξιφομάχος ξιφομαχία ξιφοποιός ξιφοφόρος ξιφούλκηση
ξοδεμός ξοδευτής ξοδεύτρα ξοδιάστρα ξοδιασμός ξοδιαστής ξολοθρεμός ξομολογητής
ξομολόγηση ξομολόγος ξομπλιάστρα ξορκίστρα ξορκισμένος ξορκισμός ξορκιστής ξου
ξούρα ξούρας ξούρος ξυ ξυλάγγουρο ξυλάδικο ξυλάκι ξυλάλευρο ξυλάνθρακας
ξυλάς ξυλέμπορας ξυλέμπορος ξυλίκι ξυλαγγουριά ξυλαποθήκη ξυλαράκι ξυλαρμογή
ξυλεμπόριο ξυλιά ξυλική ξυλοβιομηχανία ξυλογλυπτική ξυλογλυφία ξυλογλύπτης
ξυλογνωσία ξυλογράμμωση ξυλογράφημα ξυλογράφος ξυλογραφία ξυλοδάρτης
ξυλοδεσιά ξυλοθραύστης ξυλοκάρβουνο ξυλοκάρφι ξυλοκέρατο ξυλοκερατιά
ξυλοκρέβατο ξυλοκόπημα ξυλοκόπος ξυλολέβητας ξυλομετρία ξυλομπογιά
ξυλοπέδιλο ξυλοποικιλτική ξυλοπολτός ξυλοπόδαρο ξυλοσκίστης ξυλοσκεπή
ξυλοστάτης ξυλοσχίστης ξυλοτόρνευση ξυλουργία ξυλουργείο ξυλουργική ξυλουργός
ξυλωσιά ξυλόβιδα ξυλόγλυπτο ξυλόδεμα ξυλόδεσμος ξυλόδρομος ξυλόκαρφο
ξυλόκολλα ξυλόκοτα ξυλόκουκλα ξυλόλιο ξυλόμετρο ξυλόπισσα ξυλόπνευμα ξυλόσομπα
ξυλόστρωση ξυλόσφυρα ξυλότοιχος ξυλόφουρνος ξυλόφυλλο ξυλόφωνο ξυνομυζήθρα
ξυπνημός ξυπνητήρι ξυπνητούρια ξυπνοπούλι ξυπολυσιά ξυράφι ξυράφισμα ξυραφάκι
ξυρισματάκι ξυριστικά ξυρόν ξυρός ξυσιά ξυσιματιά ξυσμάρα ξυσούρα ξυστήρα
ξυστρί ξυστό ξυστός ξωθιά ξωκλήσι ξωμάχος ξωμερίτης ξωμερίτισσα ξωπατέρας
ξωτάρης ξωτάρισσα ξωτικό ξόανο ξόβεργα ξόβεργο ξόδεμα ξόδεψη ξόδι ξόδιαση
ξόμπλι ξόμπλιασμα ξόρκι ξόρκισμα ξόφλημα ξόφληση ξύγαλο ξύγκι ξύδι ξύλευση
ξύλημα ξύλιασμα ξύλισμα ξύλο ξύλωμα ξύλωση ξύπνημα ξύπνιος ξύπνο ξύπνος
ξύση ξύσιμο ξύσμα ξύστης ξύστρα ξύστρισμα ξύστρον ξύχορτο ξώθυρα ξώκκλησο
ξώπορτα ξώφυλλο οίακας οίαξ οίδημα οίηση οίησις οίκημα οίκηση οίκος οίκτος
οίστρος οβίδα οβελίας οβελίσκος οβελισμός οβελιστήριο οβελός οβιδοβόλο
οβολός οβριός ογδοηκονταετία ογδοηκονταετηρίδα ογδοηκοντούτης ογδοηκοντούτις
ογδοντάδα ογδοντάρα ογδοντάρης ογδοντάρισσα ογδονταριά ογδόη ογκάνισμα ογκίδιο
ογκεκτομή ογκηθμός ογκνήστρα ογκογονίδιο ογκολογία ογκολόγος ογκομείωση
ογκομετρική ογκοποίηση ογκοχρέωση ογκρατέν ογκόλιθος ογκόμετρο ογκόπαγος
οδήγηση οδήγησις οδαλίσκη οδηγήτρα οδηγήτρια οδηγία οδηγητής οδηγισμός οδηγός
οδογράφος οδοδείκτης οδοδείχτης οδοεπίβαινος οδοιπορία οδοιπορικά οδοιπορικό
οδοκαθαριστής οδομαχία οδομετρία οδονομία οδοντάγρα οδοντίατρος οδοντίνη
οδοντίτις οδονταλγία οδοντιατρείο οδοντιατρείον οδοντιατρική οδοντογένεση
οδοντογλυφίδα οδοντογλυφίς οδοντογονία οδοντογραφία οδοντοθεραπεία
οδοντολαβίδα οδοντολαβίς οδοντολογία οδοντοπάθεια οδοντορραγία οδοντοσκόπιο
οδοντοστοματολογία οδοντοτεχνία οδοντοτεχνίτης οδοντοτεχνική οδοντοτριβή
οδοντοφόρο οδοντόβουρτσα οδοντόγναθο οδοντόκρεμα οδοντόλιθος οδοντόπαστα
οδοντόφωνα οδοποιία οδοποιός οδοστρωσία οδοστρωτήρ οδοστρωτήρας οδοτερμίτης
οδούς οδυρμός οδωνυμικό οδωνύμιο οδόμετρο οδόμετρον οδόντωμα οδόντωση
οδός οδόσημο οδόσημον οδόστρωμα οδόστρωση οδόφραγμα οδύνη οζίδιο οζίδιον
οζονιστήρας οζονοθεραπεία οζονομετρία οζοντισμός οζοντομετρία οζοντόμετρο
οζοντόσφαιρα οζονόμετρο οζονόμετρον οζονόσφαιρα οθροτροπία οθωμανική οχιά
οθόνη οιάκιση οιάκισις οιάκισμα οιακισμός οιακιστήριο οιακιστής οιακοστρόφιο
οικήτορας οικία οικίσκος οικείωση οικειοποίηση οικειότητα οικισμός οικιστής
οικογένεια οικογενειάρχης οικογενειοκρατία οικοδέσποινα οικοδεσπότης
οικοδιδασκάλισσα οικοδομή οικοδομικά οικοδόμημα οικοδόμηση οικοδόμος οικοκυρά
οικοκυροσύνη οικοκύρης οικολογία οικολόγος οικονομία οικονομίες οικονομετρία
οικονομικότητα οικονομισάριος οικονομισμός οικονομιστής οικονομοκρατία
οικονομολόγος οικονόμα οικονόμος οικοπάρκο οικοπεδοποίηση οικοπεδοφάγος
οικοπροστασία οικοσημολογία οικοσημολόγος οικοσκευή οικοστολή οικοσύστημα
οικοτοξικολογία οικοτοξικολόγος οικοτουρίστας οικοτουρισμός οικοτροφείο
οικουμενικότητα οικουμενισμός οικουρία οικοφύλαξ οικοϋδραυλική οικτιρμός
οικόπεδο οικόσημο οικότοπος οικότροφος οικότυπος οιμωγή οινέμπορος οιναγορά
οινεμπόριο οινεώνας οινοβάρελο οινογνωσία οινογνώστης οινογραφία οινοδοχείο
οινοθήρα οινολογία οινολόγος οινομάγειρος οινομαγειρείο οινομανία οινομετρία
οινοπαραγωγός οινοπνευμάτωση οινοπνευματίαση οινοπνευματομέτρηση
οινοπνευματομετρητής οινοπνευματοποιία οινοπνευματοποιείο οινοπνευματοποιός
οινοποίηση οινοποιία οινοποιείο οινοποιός οινοποσία οινοπωλείο οινοπότης
οινοπώλισσα οινοφιλία οινοφυτιώτης οινοχαρής οινοχόη οινοχόος οινόγαλα
οινόπνευμα οινόφιλη οινόφιλος οινόφλυξ οισοφάγος οισοφαγίτιδα οισοφαγοσκόπηση
οιστραδιόλη οιστρηλασία οιστρογόνο οιωνισμός οιωνοσκοπία οιωνοσκόπος οιωνός
οκάπι οκέι οκαπία οκαρίνα οκλαδίας οκνηρία οκνιά οκρίβαντας οκτάβα οκτάγωνο
οκτάεδρο οκτάμηνο οκτάντας οκτάρι οκτάστιχο οκτάωρο οκτέτο οκταήμερο
οκταετία οκταετηρίδα οκταετηρίς οκτακοσαριά οκτανόλη οκταφωνία οκτωηχία οκτώ
ολίβανο ολίσθημα ολίσθηση ολίσθησις ολβιότης ολετήρας ολιβίνης ολιγάρκεια
ολιγανδρία ολιγανθρωπία ολιγαρχία ολιγαρχικότης ολιγαρχικότητα ολιγοδακτυλία
ολιγοδιψία ολιγοζωία ολιγοκαρπία ολιγολεξία ολιγολογία ολιγομάθεια ολιγομέλεια
ολιγομηνόρροια ολιγοπιστία ολιγοποσία ολιγοπραγμοσύνη ολιγοπότης ολιγοπότις
ολιγοπώλιον ολιγοσακχαρίτης ολιγοσιτία ολιγοσπερμία ολιγοστοιχεία ολιγοτεκνία
ολιγοφαγία ολιγοφρενία ολιγοχρηματία ολιγοψυχία ολιγοψώνιο ολιγοψώνιον
ολιγόνοια ολιγόστευμα ολιγόστευσις ολιγότης ολισθηρότητα ολισθητήρας ολισμός
ολκή ολκιμότης ολκός ολλανδέζος ολλανδικά ολλανδός ολμοβόλο ολμοστάσιο
ολοβάπτισμα ολογραφία ολοκαύτωμα ολοκλήρωμα ολοκλήρωση ολοκλήρωσις ολοκληρία
ολοκρατία ολολυγή ολολυγμός ολομέλεια ολομέρεια ολονυκτία ολονυχτία ολοπάθεια
ολοφυρμός ολυμπιάδα ολυμπιακάκιας ολυμπιονίκης ολυμπισμός ολωνυμία ολόγραμμα
ομάδα ομάλισις ομάλυνση ομάλυνσις ομάς ομήγυρη ομήγυρις ομίλημα ομίχλη ομαδάρα
ομαδάρχισσα ομαδικότητα ομαδοκρατία ομαδοποίηση ομαδούλα ομαλισμός ομαλοποίηση
ομαλότητα ομβρέλα ομβροδέκτης ομελέτα ομερτά ομηρία ομηρεία ομηριστής
ομιλία ομιλητής ομιλητικότητα ομιλουμένη ομιχλοβροχή ομιχλοκρύσταλλος ομμάτιον
ομοίωμα ομοίωση ομοίωσις ομοβροντία ομογένεια ομογαμία ομογενής ομογενοποίηση
ομογλωσσία ομογνωμοσύνη ομογονία ομογονεϊκότητα ομογραφία ομοδικία ομοδοξία
ομοεθνία ομοερωτικός ομοζυγία ομοθέσιο ομοθυμία ομοιογένεια ομοιοθερμία
ομοιοκαταληξία ομοιομέρεια ομοιομορφία ομοιομορφισμός ομοιοπάθεια
ομοιοπλαστική ομοιοστασία ομοιοτέλευτον ομοιοτροπία ομοιοτυπία ομοιοχρωμία
ομοιόσταση ομοιότης ομοιότητα ομοιότυπο ομοκεντρία ομοκεντρικότης
ομοκινητικός ομολογία ομολογητής ομολόγημα ομοουσιότης ομοουσιότητα ομοπλαστία
ομορφάνθρωπος ομορφάντρας ομορφιά ομορφονιά ομορφονιός ομορφούλα ομορφούλης
ομοσκεδαστικότητα ομοσπονδία ομοταξία ομοτιμία ομοτονία ομοτυπία ομοφαγία
ομοφροσύνη ομοφυλία ομοφυλοφιλία ομοφυλοφοβία ομοφυλόπουστας ομοφυλόφιλος
ομοχειρία ομοχρωμία ομοψηφία ομοψυχία ομοϊδεάτης ομοϊδεάτισσα ομπρέλα
ομπρελάς ομπρελίνο ομπρελίτσα ομπρελοθήκη ομφαλεπίδεσμος ομφαλοκήλη
ομφαλορραγία ομφαλοσκοπία ομφαλοσκόπηση ομφαλοσκόπος ομφαλόρροια ομφαλός
ομόλογο ομόλογος ομόνοια ομώνυμα ον ονάριο ονίσκος ονδουριανός ονείρεμα
ονείρωξη ονειδισμός ονειρευτής ονειρισμός ονειροκρίτης ονειροκρισία
ονειρολογία ονειρολόγος ονειρομαντεία ονειρομαντική ονειροπαγίδα ονειροπόλημα
ονειροπόλος ονειροφαντασία ονειροφαντασιά ονειροχρόνος ονειρόδραμα
ονηγός ονηλάτης ονηλασία ονομασία ονομασιολογία ονομαστήρια ονομαστική
ονοματεπώνυμο ονοματοδοσία ονοματοθέτης ονοματοθεσία ονοματοκρατία
ονοματολογικό ονοματολόγιο ονοματολόγιον ονοματολόγος ονοματομανία
ονοματοποίησις ονοματοποιία οντάριο οντάς οντισιόν οντογένεση οντογονία
οντολογισμός οντολόγος οντουλασιόν οντότης οντότητα ονυχία ονυχεκτομή
ονυχοκόπτης ονυχολυσία ονυχομαντεία ονυχοτιλλομανία ονυχοφάγος ονυχοφαγία
ονυχόλυση ονόρε ονύχωση οξάλμη οξέλαιο οξέλαιον οξέωση οξέωσις οξίδωση οξαλίδα
οξαποδός οξαποδώ οξεία οξείδιο οξείδιον οξείδωση οξείδωσις οξειδάση
οξειδωτής οξεοποίηση οξιά οξιτανικά οξοναιμία οξονουρία οξοποίηση οξοποίησις
οξυά οξυβόας οξυγναθισμός οξυγονοθεραπεία οξυγονοκολλητής οξυγονοκοπή
οξυγονοκόλλησις οξυγονοκόφτης οξυγραφία οξυγόνο οξυγόνωση οξυγόνωσις
οξυζενέ οξυηκοΐα οξυθυμία οξυκέρασος οξυκεφαλία οξυκωδόνη οξυμετρία οξυοξύ
οξυφωνία οξόνη οξύ οξύαυλος οξύγαλα οξύμετρο οξύμετρον οξύνοια οξύτης οξύτητα
οπάλιον οπή οπίσθια οπαίο οπαίον οπαδισμός οπαδός οπαλίνα οπαλισμός οπερέτα
οπερατέρ οπιομανία οπιούχο οπισθέλκουσα οπισθαρίθμηση οπισθαρίθμησις
οπισθοβουλία οπισθογράφηση οπισθογράφησις οπισθογωνία οπισθοδιάδοση
οπισθοδρόμηση οπισθοδρόμησις οπισθοπορία οπισθοπορεία οπισθοφυλακή οπισθοφύλαξ
οπισθοχώρησις οπισθόδομος οπισθόφυλλο οπισθόχωμα οπλή οπλίτης οπλαρχηγός
οπληφόρα οπληφόρο οπλισμού οπλισμός οπλιταγωγό οπλιταγωγόν οπλιτοδρομία
οπλοβαστός οπλοβιομηχανία οπλοβομβίδα οπλοδόκη οπλοθήκη οπλομάχος οπλομαχία
οπλονομείο οπλονόμος οπλοποιία οπλοποιείο οπλοποιός οπλοπολυβόλο οπλοπωλείο
οπλοστάσιο οπλουργείο οπλουργός οπλοφορία οπλοφόρος οπλοχρησία οποθεραπεία
οπορτουνισμός οπτάνθραξ οπτήρ οπτήρας οπτασία οπτασιασμός οπτασιαστής οπτικά
οπτικομετρία οπτικοποίηση οπτικόμετρο οπτιμίστρια οπτιμισμός οπτιμιστής
οπτοηλεκτρονική οπτοπλινθοδομή οπτόπλινθος οπωρικό οπωροκηπευτικά
οπωροπαντοπωλείο οπωροπωλείο οπωροπώλης οπωροπώλισσα οπωροσάκχαρο οπωροφαγία
οπωρώνας οπός οπόσουμ οπώρα οράριο ορίγανον ορίζοντας ορίζουσα οραματίστρια
οραματιστής ορατικότης ορατόριο ορατότης ορατότητα οργάντζα οργάνωση οργάνωσις
οργανάκι οργανέτο οργανίδιο οργανίστας οργανική οργανικισμός οργανισμός
οργανογένεια οργανογένεση οργανογένεσις οργανογραφία οργανοθεραπεία
οργανοπαίκτης οργανοπαίχτης οργανοποιία οργανοποιείο οργανοποιός οργανοταξία
οργανωτής οργανωτικοποίηση οργανόγραμμα οργανώτρια οργασμός οργιά οργιαστής
οργιλότητα οργκάντζα οργκανάιζερ οργκαντίνα οργωτής ορδή ορδί ορδαλία
ορειβάτης ορειβάτιδα ορειβάτις ορειβάτισσα ορειβασία ορειβατισμός ορειβατώ
ορειχάλκωση ορειχάλκωσις ορειχαλκουργία ορειχαλκουργός ορεκτικό ορεκτικότης
ορεογένεση ορεογένεσις ορεογονία ορεογραφία ορεοδομή ορεομετρία ορεσιπάθεια
ορθοέπεια ορθοβουλία ορθογένεση ορθογένεσις ορθογράφηση ορθογράφος ορθογραφία
ορθογώνιο ορθοδοντία ορθοδοντική ορθοδοντικός ορθοδοξία ορθοδοξοποίηση
ορθολογίστρια ορθολογικότητα ορθολογισμός ορθολογιστής ορθομαρμάρωση
ορθομετωπία ορθοξυλόλιο ορθοπαιδική ορθοπαιδικός ορθοπαντογράφος ορθοπεδική
ορθοπεταλιά ορθοπρωκτική ορθορεξία ορθοσιγμοειδοσκόπηση ορθοσκόπηση
ορθοσκόπιο ορθοστάτης ορθοστασία ορθοστοιχία ορθοτομία ορθοτονία ορθοτροπισμός
ορθοφροσύνη ορθοφωνία ορθοφωνητική ορθοφωτογραφία ορθοφωτοχάρτης ορθόκεντρο
ορθότητα ορθόφρων οριγανέλαιον οριγκάμι οριζοντίωση οριζοντιότητα οριογραμμή
ορισμοδοσία ορισμός οριστική οριστικοποίηση οριστικότης οριστικότητα ορκοδοσία
ορκωμοσία ορμάθισις ορμάνι ορμή ορμήνια ορμίδι ορμίσκος ορμαθός ορμητήριο
ορμητικότητα ορμιά ορμιόδεσμος ορμονοθεραπεία ορμόνη ορνίθι ορνιά ορνιθίσχιος
ορνιθοθήρας ορνιθοκλέπτης ορνιθοκομία ορνιθοκομείο ορνιθοκρίτης ορνιθοκόμος
ορνιθολόγος ορνιθοπωλείο ορνιθοσκαλίσματα ορνιθοτροφία ορνιθοτροφείο
ορνιθόρρυγχος ορνιθόρυγχος ορνιθών ορνιθώνας ορνιός ορντέβρ ορντινάντσα
οροαντίδραση οροαντίδρασις ορογένεια ορογένεση ορογένεσις ορογραφία
οροδιαγνωστική οροθέσιο οροθέτηση οροθέτησις οροθεραπεία οροθεσία
ορολογία ορολογία ορολόγιο ορομετρία ορονοσία οροπέδιο οροσήμανση οροσήμανσις
οροφή οροφοδιαμέρισμα οροφοκομία ορρωδία ορτανσία ορτσάρισμα ορτυγοθήρας
ορυζάλευρον ορυζάμυλο ορυζοκαλλιέργεια ορυζοφαγία ορυζών ορυζώνας ορυκτέλαιο
ορυκτογεωλογία ορυκτογραφία ορυκτοδεψία ορυκτολογία ορυκτολόγος ορυκτοτεχνία
ορυμαγδός ορυχή ορυχείο ορφάνεμα ορφάνια ορφανία ορφανισμός ορφανοτροφείο
ορχήστρα ορχίτιδα ορχίτις ορχεκτομή ορχεκτομία ορχεοειδή ορχηστής ορχηστρίδα
ορχιαλγία ορχιδέα ορωνύμιο ορόγαλα ορόμο ορός ορόσημο οσιομάρτυρας οσιοποίηση
οσιότητα οσμή οσμίδρωση οσμηρός οσμηρότης οσμηρότητα οσμιδρωσία οσμολογία
οσμομετρία οσμόμετρο οσπίτ οσποδάρος οσπριοφαγία οσσετικά οστάριο οστέωμα
οστέωσις οστίτης οστίτιδα οστίτις οστεΐνη οστεΐτιδα οστεάλευρο οστεαλγία
οστεοαρθρίτιδα οστεοαρθρίτις οστεοβλάστη οστεογένεση οστεογονία οστεοθήκη
οστεολογία οστεολυσία οστεομαλάκυνση οστεομαλακία οστεομαλακυνσία οστεομετρία
οστεομυελίτις οστεοπάθεια οστεοπλασία οστεοπλαστία οστεοπλαστική οστεοποίηση
οστεοπόρωση οστεοπόρωσις οστεορραγία οστεορραφία οστεοσάρκωμα οστεοσκλήρυνση
οστεοτομία οστεοτρύπανο οστεοφυΐα οστεοφυλάκιο οστεοψαθύρωση οστεοψαθύρωσις
οστεόκολλα οστεόλιθος οστεόλιπος οστεόφυμα οστεόφυτο οστπολιτίκ οστράκωση
οστρακιά οστρακισμός οστρακολογία οστρακόδερμο οστρεοκαλλιέργεια οστρεοκομία
οστρεοτροφείο οστρεοτρόφος οστρεοφαγία οστρογότθος οστό οσφραντικότητα
οσφρητικότητα οσφυαλγία οσφυοκάμπτης οσφυοκαμψία οσφυοϊσχιαλγία οσφύς
οσχεοπλασία οταβίνο οτζίμπουε οτομοτρίς οτοστόπ ουίσκι ουίστ ουαλικά ουασάμπι
ουβαόλη ουγγιά ουγγρικά ουγκιά ουδέτερο ουδετεροπενία ουδετεροποίηση
ουδετεροφιλία ουδετερόνιο ουδετερότης ουδετερότητα ουδετερόφιλα ουδός ουζάδικο
ουζμπέκικα ουζμπέκος ουζομεζές ουζομεζεδοπωλείο ουζοποσία ουζοπωλείο ουζοπότης
ουζόνι ουιγουρικά ουικιγράφος ουκρανικά ουκρανός ουλάνος ουλή ουλίτιδα
ουλαμός ουλεμάς ουλορραγία ουλτιμάτο ουμάμι ουμανίστρια ουμανισμός ουμανιστής
ουνίτισσα ουνιβερσαλισμός ουνιτισμός ουπανισάντ ουρά ουράνια ουράνιο ουρήθρα
ουρία ουρίτσα ουραίο ουραγία ουραγκοτάγκος ουραγός ουραιμία ουρακοτάγκος
ουρανισμός ουρανιστής ουρανοβάτης ουρανογνωσία ουρανογραφία ουρανοθέμελα
ουρανομαντεία ουρανοξύστης ουρανόλιθος ουρανός ουρηθρίτιδα ουρηθρίτις
ουρηθροπλαστική ουρηθροσκοπία ουρηθροσκόπηση ουρηθροσκόπιο ουρητήρ ουρητήρας
ουρητηρίτιδα ουρητηρίτις ουρητηροδερμοστομία ουρητηρολιθοτριψία
ουρητηροπυελολιθοτριψία ουρητηροπυελοσκόπιση ουριοδρομία ουρλιαχτό
ουρογραφία ουρογυναικολογία ουροδοχείο ουροδυναμική ουροδόχη ουροθήλιο
ουρολιθίαση ουρολιθίασις ουρολοίμωξη ουρολοίμωξις ουρολογία ουρολόγος
ουροογκολογία ουροποίηση ουροποίησις ουροσκοπία ουροφιλία ουροχολίνη
ουρόλιθος ους ουσάρος ουσία ουσιαστικοποίηση ουσιαστικό ουσιοκράτης
ουσνέα ουτιδανότης ουτοπία ουτοπίστρια ουτοπισμός ουτοπιστής ουχρονία
οφίκιο οφίτσιο οφειλέτης οφειλή οφθαλμία οφθαλμίατρος οφθαλμαλγία οφθαλμαπάτη
οφθαλμοκήλη οφθαλμοκινητικότητα οφθαλμολογία οφθαλμολόγος οφθαλμομέτρης
οφθαλμοπορνεία οφθαλμοπόρνος οφθαλμοσκοπία οφθαλμοσκόπηση οφθαλμοσκόπησις
οφθαλμόλουτρο οφθαλμός οφικιάλιος οφιολάτρης οφιολάτρις οφιολατρία οφιοφαγία
οφρύς οφσάιντ οφφίκιον οχαδερφισμός οχεία οχετός οχιά οχιά της μήλου οχλαγωγία
οχληρότης οχληρότητα οχλοβοή οχλοκρατία οχτάβα οχτάγωνο οχτάδα οχτάεδρο
οχτάστιχο οχτάσφαιρο οχτάωρο οχταήμερο οχταετία οχτακοσαριά οχτομηνίτης
οχτρός οχτωήχι οχτώ οχυρό οχυρότητα οχύρωμα οχύρωση οχύρωσις οψιανός οψιδιανός
οψοθήκη οψοφυλάκιον οψυγιάς ούγια ούζο ούλο ούλτιμο ούμπαλο ούντμουρτ ούπα
ούρηση ούρησις ούρλιασμα ούρντου ούρο ούρτικα ούρτσουλο ούτι ούφο οὐσιαστικόν
πάγιο πάγκα πάγκος πάγκρεας πάγος πάγουρας πάγουρος πάγρα πάγωμα πάθημα πάθηση
πάκο πάκτωμα πάκτωνας πάκτωση πάκτωσις πάλα πάλαισμα πάλεμα πάλη πάλι πάλιωμα
πάλσαρ πάμμαχον πάνα πάνδεινα πάνελ πάνθεο πάνθεον πάνθηρας πάνιασμα πάνισμα
πάντσο πάπας πάπια πάπιος πάπισσα πάπλωμα πάππος πάπρικα πάπυρος πάρδαλις
πάρεδρος πάρελξη πάρεση πάρεσις πάρκιν πάρκινγκ πάρκινσον πάρκο πάρλα πάροδος
πάροχος πάρσιμο πάρτη πάρτι πάρων πάσα πάσο πάσπαλη πάσπαρος πάσσαλος πάστα
πάστορας πάστρα πάστρεμα πάστωμα πάταγος πάταξη πάτερ πάτερ ημών
πάτερο πάτημα πάτμιος πάτος πάτρια πάτρονας πάτρονος πάτρων πάτρωνας πάτωμα
πάφλασμα πάχνη πάχνιασμα πάχος πάχτωμα πάχτωση πάχυνση πάχυνσις πάψη πέδηση
πέδικλο πέδικλον πέδιλο πέδιλον πέζεμα πέζευμα πέθαμα πέκαν πέλαγο πέλαγος
πέλεκας πέλεκυς πέλετ πέλλετ πέλμα πέλος πέλτη πέμπτο πέμφιξ πέμψις πένα
πένες πένης πένθος πέννα πένσα πένταθλο πένταθλον πέντε πέντολο πέος πέους
πέπλο πέπλος πέπων πέραμα πέρας πέραση πέρασμα πέργκολα πέργολα πέργουλα
πέρδιξ πέρκα πέρκη πέρκνα πέρλα πέρμαφροστ πέρπυρο πέρτικος πέσιμο πέστο
πέταγμα πέταλο πέταλον πέταμα πέτασμα πέτασος πέταυρο πέτης πέτο πέτρα πέτρωμα
πέτσιασμα πέτσωμα πέψη πέψις πήγμα πήδημα πήδος πήξη πήξιμο πήξις πήχη πήχης
πήχυς πίαρ πίδακας πίδαξ πίεση πίεσις πίεστρον πίθηκας πίθηκος πίθος πίκα
πίκολο πίκρα πίκραμα πίκρια πίκρισμα πίλαστρο πίλημα πίλησις πίλος πίνα
πίναξ πίντα πίξελ πίπα πίπιζα πίπισμα πίρος πίσσα πίσσωμα πίσσωση πίσσωσις
πίστη πίστις πίστωση πίτα πίτερο πίτουρο πίτσα πίττα πίτυρο πίτυρον πίτυς
πα παΐδι παέγια παίγνιο παίγνιον παίδαρος παίδεμα παίδευση παίδευσις παίδεψη
παίκτρια παίνεμα παίξιμο παίχτης παίχτρα παίχτρια πααιμός παβάνα παγάδα παγάκι
παγίδα παγίδευμα παγίδευση παγίδι παγίωση παγανίστρια παγανιά παγανισμός
παγανό παγανός παγαπόντης παγαπόντισσα παγγένεση παγγενεσία παγγερμανισμός
παγγνωσία παγγνώστης παγερότητα παγετωνολόγος παγετός παγετώνας παγιέτα
παγιοποίηση παγιοτιμή παγιότητα παγκάκι παγκάρι παγκαλιάδα παγκανοία παγκενιά
παγκοσμίωση παγκοσμιοποίηση παγκοσμιούπολη παγκοσμιότητα παγκράτιο
παγκρεατίνη παγκρεατίτιδα παγκρεατίτις παγκρεατεκτομή παγκυτοπενία παγκόσμιος
παγοδρομία παγοδρόμιο παγοδρόμος παγοθήκη παγοθραυστικό παγοθραύστης
παγοκολόνα παγοκρηπίδα παγοκρύσταλλος παγοκυψέλη παγοκόπτης παγοκόφτης
παγολεκάνη παγοπέδιλο παγοπίστα παγοπληξία παγοποιία παγοποιείο παγοποιός
παγοπώλης παγοπώλις παγοπώλισσα παγούρι παγωμάρα παγωνιά παγωνιέρα παγωτίνι
παγωτατζίδικο παγωτομηχανή παγωτό παγωτό ξυλάκι παγόβουνο παγόνι παγώνας
παδέλα παδελομούρης παζάρεμα παζάρι παζαρίτης παζαρευτής παζαρεύτρα παζαριλίκι
παζαρλίκι παθανθές το εδώδιμο παθητικοποίηση παθητικοποιητής παθητικό
παθητικότητα παθητισμός παθογένεια παθολογία παθολογοανατομία παθολογοανατόμος
παθοφυσιολογία παθός παιάν παιάνας παιανιώτης παιγνίδι παιγνίδισμα
παιγνιοχειριστήριο παιγνιόχαρτο παιγνιόχαρτον παιδάκι παιδάριο παιδάριον
παιδί παιδίατρος παιδίον παιδίσκη παιδαγωγία παιδαγωγική παιδαγωγός
παιδαγώγησις παιδαράς παιδαρέλι παιδεία παιδεμός παιδεραστής παιδεραστία
παιδιάρισμα παιδιατρική παιδικάτα παιδικότης παιδικότητα παιδισμός
παιδοβαπτιστής παιδογένεση παιδογένεσις παιδογονία παιδοθεσία παιδοκομία
παιδοκτονία παιδοκτόνος παιδοκόμος παιδολογία παιδολόγι παιδολόι παιδομάζωμα
παιδομετρία παιδομορφισμός παιδονομία παιδονόμος παιδοποίηση παιδοποιία
παιδοχειρουργική παιδοχειρουργός παιδοψυχίατρος παιδοψυχιατρική παιδοψυχολογία
παιδούλα παιδούπολη παιδωμή παιδόπουλο παιδότοπος παιδόφιλος παικταράς παινάδι
παινεσιά παιπάλη παις παιχνίδι παιχνίδισμα παιχνιδάκι παιχνιδιάρισμα
παιχνιδομάγαζο παιχνιδούπολη παιχτάρα παιχταράς παιώνια πακέτο πακετάρισμα
πακτωλός παλ παλάβρα παλάβρας παλάβωμα παλάγκο παλάμη παλάμισμα παλάντζα
παλάτι παλέτα παλέτσα παλίρροια παλαίμαχος παλαίστρα παλαίστρια παλαίτυπο
παλαίωσις παλαβάδα παλαβιά παλαβιάρης παλαβομάρα παλαβωμάρα παλαδίνος
παλαιοαρμενικά παλαιοβιβλιοπωλείο παλαιοβιβλιοπωλείον παλαιοβιβλιοπώλης
παλαιοβιβλιοπώλισσα παλαιοβιολογία παλαιοβιολόγος παλαιοβοτανική
παλαιογενετιστής παλαιογεωγραφία παλαιογράφος παλαιογραφία παλαιοεθνολογία
παλαιοελλαδίτης παλαιοελλαδίτισσα παλαιοζωολογία παλαιοημερολογίτης
παλαιοημερολογιτισμός παλαιοκαλλιτέχνης παλαιοκλιματολογία παλαιοκομματισμός
παλαιολιθική παλαιονετρίνο παλαιονευρολόγος παλαιονουκλεοσύνθεση
παλαιοντολόγος παλαιοπωλείο παλαιοπωλείον παλαιοπώλης παλαιοπώλις
παλαιοσίδηρος παλαιοφωτόνια παλαιοφωτόνιο παλαιοϊχνολογία παλαιστή παλαιστής
παλαιότητα παλαιότυπο παλαμάκια παλαμάρι παλαμίδα παλαμαράς παλαμιά
παλετοθέση παλετοποίηση παλιάλογο παλιάμπελο παλιάνθρωπος παλιάτσος
παλιατζής παλιατζίδικο παλιατζού παλιατζούρα παλιατσαρία παλιγγενεσία παλικάρι
παλικαράς παλικαριά παλικαρισμός παλικαροσύνη παλικαρού παλικινησία παλιλλογία
παλιμπαιδισμός παλινδρομία παλινδρόμηση παλιννοστούντας παλιννόστηση
παλινωδία παλινόρθωση παλινόρθωσις παλιοβάρελο παλιοβρόμα παλιογυναίκα
παλιοδουλειά παλιοελλαδίτης παλιοελλαδίτισσα παλιοζωή παλιοημερολογίτης
παλιοθήλυκο παλιοκάραβο παλιοκατάσταση παλιοκοινωνία παλιοκουβέντα
παλιολλαδίτης παλιολλαδίτισσα παλιομαλάκας παλιομασκαράς παλιομερολογίτης
παλιομπεκρής παλιομπεκρού παλιοπάπουτσο παλιοπαρέα παλιοπατσαβούρα
παλιορουφιάνος παλιοσίδερα παλιοσκρόφα παλιοτόμαρο παλιούρι παλιρροιογράφος
παλιόγερος παλιόγρια παλιόδρομος παλιόκαιρος παλιόκοσμος παλιόκρασο
παλιόμυγα παλιόπαιδο παλιόπουστας παλιόπραμα παλιόρουχο παλιόσκυλο παλιόσπιτο
παλιόφιλος παλιόφυτρα παλιόχαρτο παλκοσένικο παλλάδα παλλάδιο παλλαισθησία
παλλακεία παλληκάρι παλληκαράς παλληκαριά παλληκαρισμός παλληκαροσύνη
παλμαρέ παλμογεννήτρια παλμογράφος παλμοσκόπιο παλμός παλουκοκαύτης παλούκι
παλτουδάκι παλτουδιά παλτό παλτόν παμπ παμφαγία παμφορείο παμψηφία παμψυχισμός
πανάδα πανάκεια πανάκι πανάρισμα πανέρι πανήγυρη πανήγυρις πανί πανίδα πανίς
παναμάς παναμέζος παναμαίος παναμερικανισμός παναραβίστρια παναραβισμός
παναρθρόποδα πανδέκτης πανδαιμόνιο πανδαιμόνιον πανδαισία πανδαμάτειρα
πανδεκτική πανδημία πανδιδακτήριο πανδοχέας πανδοχείο πανδοχείον πανδοχεύς
πανελλήνιες πανελληνιονίκης πανεπιστήμιο πανεπιστήμιον πανεπιστημιακός
πανεπιστημοσύνη πανεράκι πανεράς πανεριά πανζουρλισμός πανηγυρίστρια
πανηγυρισμός πανηγυριστής πανηγυριώτης πανηγυριώτισσα πανηγυρτζής πανηγύρι
πανθεϊσμός πανθεϊστής πανιδρωσία πανιερότητα πανικά πανικός πανισλαμισμός πανκ
παννυχίδα παννυχίς πανομοιοτυπία πανομοιότης πανομοιότητα πανοπλία
πανοσιότης πανοσιότητα πανουργία πανούκλα πανσέληνος πανσές πανσιόν
πανσλαβισμός πανσλαβιστής πανσοφία πανσπερμία πανσπερμίστρια πανσπερμισμός
πανστρατιά πανσύμπαν παντάναξ παντάνασσα πανταλόνι παντατίφ πανταχούσα
παντελόνι παντεπόπτης παντεσπάνι παντεϊσμός παντζάμπι παντζάρι παντζέχρι
παντζαρόσουπα παντζοχέρι παντζούρι παντιέρα παντογνωσία παντογνώστης
παντογράφος παντοδυναμία παντοκράτορας παντοκράτωρ παντοκρατορία παντομίμα
παντοπώλης παντοπώλισσα παντουρκισμός παντουφλάδικο παντουφλάζ παντοφλάδικο
παντοφοβικός παντοχή παντούφλα παντρειά παντρεμένη παντρολογήματα
παντόγραμμα παντόφλα πανψυχισμός πανωβελονιά πανωλεθρία πανωμυλόπετρα
πανωσέντονο πανωτόκι πανωφόρι πανό πανόραμα πανώ πανώγραμμα πανώλη πανώλης
παξιμάδι παξιμάδιασμα παξιμαδάκι παξιμαδάκια παξιμαδοκλέφτης παξιμαδοκλέφτρα
παπάγια παπάζι παπάκης παπάκι παπάρα παπάρας παπάρι παπάς παπάτζα παπάτζας
παπαγάλος παπαγαλάκι παπαγαλία παπαγαλισμός παπαγιέλαιο παπαδάκι παπαδίστικα
παπαδιά παπαδική παπαδοκρατία παπαδοκόρη παπαδολόι παπαδομάνι παπαδοπαίδι
παπαδουριά παπαδόσπιτο παπαράτσι παπαρδέλα παπαρδέλας παπαριά παπαρολογία
παπατζής παπατρέχας παπατσόσυκο παπαφίγκος παπιέ μασέ παπιαμέντο παπιγιονάκιας
παπισμός παπιόν παπλωματάδικο παπλωματάκι παπλωματάς παπλωματζής παπλωματοθήκη
παποράκι παποράρα παποριά παποσύνη παπουράκι παπουτσάδικο παπουτσάκι
παπουτσής παπουτσοθήκη παπουτσόκαρφο παπούς παπούτσι παπούτσωμα παππούδες
παππούς παπυρογράφος παπυρογραφία παπυρολογία παπυρολόγος παπόρι παρά φύση
παράβλεψη παράβλεψις παράβλημα παράβολο παράγγελμα παράγκα παράγοντας
παράγωγο παράγωγος παράγων παράδειγμα παράδεισο παράδεισος παράδεισος παράδοξο
παράδοσις παράδρομος παράθεμα παράθεση παράθεσις παράθημα παράθλασις παράθυρο
παράκαμψις παράκληση παράκλησις παράκουση παράκουσις παράκουσμα παράκρουση
παράκυκλος παράλειψη παράλειψις παράληψις παράλια παράλλαγμα παράλλαμα
παράλλαξις παράλληλος παράλογο παράλυση παράλυσις παράμαλλο παράμεσος
παράνοια παράνομα παράνομος παράνυφος παράξυλο παράξυλον παράπηγμα παράπιομα
παράπλαγο παράπλους παράπονο παράπονον παράπτωμα παράριζο παράρτημα παράς
παράσημο παράσημον παράσιτα παράσιτο παράσπιτο παράστασα παράσταση παράστασις
παράταξη παράταξις παράταση παράτασις παράτημα παράτιτλος παράτριμμα παράτυφος
παράφραση παράφυλλο παράφυλλον παράφυση παράφυσις παράχρηση παράχρησις
παράχωση παράχωσις παρέα παρέαση παρέγχυμα παρέκβαση παρέκβασις παρέκκλιση
παρέκταση παρέλαση παρέλασις παρέλευση παρέλευσις παρέλκυση παρέμβαση
παρέμβλημα παρέμβυσμα παρέμφαση παρέμφασις παρένθεση παρένθεσις παρήχηση
παρίας παρίστια παρίστιο παραίνεση παραίνεσις παραίσθηση παραίσθησις παραίτηση
παραβάν παραβάτης παραβάτις παραβάτισσα παραβίαση παραβίωση παραβίωσις
παραβλάσταρο παραβλάστη παραβλάστημα παραβολή παραγάγγλιο παραγάδι παραγέμισμα
παραγαδιάρης παραγγελία παραγγελιά παραγγελιοδότης παραγγελιοδότρια
παραγγελιολήπτης παραγγελιοληψία παραγεμιστά παραγιός παραγκούλα παραγκωνισμός
παραγκώνιση παραγναθίδα παραγναθίς παραγνώριση παραγνώρισις παραγνώρισμα
παραγοντικό παραγοντισμός παραγοντοποίηση παραγουανός παραγραμματισμός
παραγωγή παραγωγικότης παραγωγικότητα παραγωγός παραγώνι παραδάκι παραδαρμός
παραδειγματισμός παραδοδουλειά παραδολώνιο παραδοξογράφος παραδοξολογία
παραδοξόνιο παραδοξότης παραδοξότητα παραδοσιαρχία παραδοσιοκρατία
παραδοχή παραδούλεμα παραδρομή παραδόσεις παραδότης παραεμπόριο παραεξουσία
παραζάλισμα παραθέριση παραθέρισμα παραθείο παραθερίστρια παραθερισμός
παραθετικά παραθετικό παραθυράκι παραθυρεοειδεκτομή παραθυρόφυλλο παραθύρι
παρακάλεση παρακάλεσμα παρακάλι παρακάλιο παρακάτιο παρακάτω παρακέντηση
παρακίνηση παρακίνησις παρακαλεστής παρακαλετό παρακαμπτήριος παρακαμψούλα
παρακατάθεσις παρακαταθέτης παρακαταθήκη παρακείμενος παρακείμενος παρακεντές
παρακινδύνευση παρακινδύνευσις παρακλάδι παρακλάδος παρακμή παρακοή
παρακοινωνία παρακοινωνός παρακολούθημα παρακολούθηση παρακολούθησις
παρακράτηση παρακράτησις παρακράτος παρακυβέρνηση παρακόρη παρακύηση
παρακώλυση παραλήγουσα παραλήπτης παραλήπτρια παραλήρημα παραλής παραλία
παραλαβή παραλαλητό παραλειπόμενα παραλλαγή παραλληλία παραλληλεπίπεδο
παραλληλογράφος παραλληλόγραμμο παραλληλότης παραλληλότητα παραλογή παραλογητό
παραλού παραλυσία παραλόγιασμα παραμάγειρος παραμάγερας παραμέλημα παραμέληση
παραμέρισμα παραμήτριο παραμίλημα παραμαγνητισμός παραμαγούλα παραμερισμός
παραμητρίτιδα παραμιλητό παραμονή παραμυθάς παραμυθία παραμυθατζής
παραμυθολόγιο παραμυθολόγιον παραμυθολόγος παραμυθοχώρα παραμυθού
παραμόνεμα παραμόρφωση παραμόρφωσις παραμύθα παραμύθι παραμύθιον παρανάλωμα
παρανυφάκι παρανυχίδα παρανόηση παρανόησις παρανόμι παραξενιά παραξυλόλιο
παραπάτημα παραπέντε παραπέταμα παραπέτασμα παραπέτο παραπαίδι παραπαιδεία
παραπεμπτικογραφία παραπεμπτικό παραπλάνηση παραπλάνησις παραπλήρωμα
παραπληγικός παραπληξία παραπληροφόρηση παραπληρωμή παραποίηση παραποίησις
παραπονιάρα παραπονιάρης παραπούλι παραπρεσβεία παραπροίκι παραπροϊόν
παραπόνεση παραπόρτι παραπόταμος παρασάγγης παρασήμανση παρασήμανσις
παρασίτωσις παρασελήνη παρασημαντική παρασημείωση παρασημοφορία παρασημοφόρηση
παρασιά παρασιτία παρασιτισμός παρασιτολογία παρασιώπηση παρασκήνιο
παρασκευάστρια παρασκευή παρασκευαστήριο παρασκευαστήριον παρασκευαστής
παρασκιά παρασπάς παρασπαδίας παρασπονδία παρασπόνδηση παρασπόνδησις παρασπόρι
παραστάς παραστάτης παραστάτιδα παραστάτις παραστάτρια παραστέγασμα
παραστατικό παραστατικότητα παραστιά παραστράτημα παραστράτισμα παρασυναγωγή
παρασχηματισμός παρασόκακο παρασόλ παρασόλι παρασύμπαν παρασύνθεση
παρασύνθετο παρασύνθημα παρασύρα παρατήρημα παρατήρηση παρατήρησις
παρατατικός παρατημός παρατηρήτρια παρατηρητήριο παρατηρητήριον παρατηρητής
παρατηρητικότητα παρατιμονιά παρατονία παρατράβηγμα παρατράγουδο παρατράπεζα
παρατροπή παρατροπίδιο παρατσούκλι παρατυπία παρατύπωμα παραφάγωμα παραφάρμακο
παραφέντρα παραφίνη παραφασάδα παραφασία παραφερνάλια παραφθορά παραφιλία
παραφινέλαιο παραφινόλαδο παραφορά παραφράστρια παραφραστής παραφρενία
παραφυάδα παραφωνία παραφωσώνιο παραφωτίς παραφωτισμός παραφόρτωμα παραφύλαγμα
παραφύλαξις παραχάιδεμα παραχάραξη παραχάραξις παραχέρι παραχαράκτης
παραχείμαση παραχείμασις παραχωρησιούχος παραχωρητήριο παραχωρητήριον
παραχώρηση παραχώρησις παραχώσιμο παραψυχολογία παραϋπνία παργινός παρδαλή
παρείσδυση παρείσδυσις παρείσφρηση παρείσφρησις παρεγκεφαλίδα παρεγκεφαλίς
παρεγκεφαλίτις παρειά παρεισαγωγή παρεκβολή παρεκκλήσι παρεκκλήσιο παρεκτροπή
παρελθοντολογία παρελθόν παρελκυστικότητα παρεμβατισμός παρεμβολή παρεμπόδιση
παρενέργεια παρενδυσία παρενογενεσία παρενόχληση παρενόχλησις παρεξήγηση
παρεξηγιάρα παρεξηγιάρης παρεοκρατία παρεούλα παρεπίτροπος παρεπιδημία
παρεπόμενο παρεπόμενον παρερμήνευση παρερμήνευσις παρερμηνεία παρερμηνευτής
παρετυμολογία παρετυμολόγηση παρεό παρηγορήτρα παρηγορήτρια παρηγορία
παρηγοριά παρηγόρηση παρηγόρησις παρηγόρια παρηκοΐα παρθένα παρθένιο παρθένιον
παρθενία παρθεναγωγείο παρθεναγωγείον παρθενιά παρθενικότης παρθενικότητα
παρθενογένεση παρθενογένεσις παρθενογονία παρθενοκαρπία παρθενοπιπίτσα
παρθενοφθορία παριανή παριανός παριζιάνα παριζιάνος παρκ φερμέ παρκάκι
παρκέ παρκέτο παρκαδόρος παρκετάρισμα παρκετέζα παρκετίνη παρκούρ παρκόμετρο
παρλάτα παρλαμάς παρλαμέντο παρλαπίπα παρλαπίπας παρμάρα παρμεζάνα παρμπρίζ
παρντεσού παρντόν παροδίτης παροδίτις παροδικότης παροδικότητα παροδοντίτιδα
παροιμία παροιμιογράφος παρολί παρομοίωση παρομοίωσις παρονομασία παρονομαστής
παροξυσμός παροπλισμός παροργισμός παρορμητικός παρουσία παρουσίαση
παρουσιαστής παρουσιαστικό παρουσιαστικόν παρουσιολόγιο παροχέας παροχέτευση
παροχή παροχετευτικότητα παροχολογία παρρησία παρσέκ παρσισμός παρτάκιας
παρτέντζα παρτέρι παρτίδα παρτίδες παρτενέρ παρτεναίρ παρτιζάνος παρτιτούρα
παρτούζα παρτσάς παρτσακλό παρτσινέβελος παρτόλα παρυφή παρωδία παρωνυμία
παρωνυχίδα παρωνυχίς παρωνύμιο παρωνύμιον παρωπίδα παρωρίτης παρωρεία παρωτίδα
παρωτίτιδα παρωτίτις παρόλα παρόν παρόνομα παρόξυνση παρόξυνσις παρόπλιση
παρόραμα παρόργιση παρόργισις παρόρμηση παρόρμησις παρότρυνση παρότρυνσις
παρώνυμο παρώνυμον παρώρεια πασάλειμμα πασάρισμα πασάς πασέρ πασέτα πασαβιόλα
πασαλίκι πασαλειμματάκι πασαλειμμός πασαλιμανιώτης πασαμέντο πασαπάγκος
πασασυστολή πασατέμπο πασατέμπος πασατεμπάς πασιέντζα πασιέντσα πασιφισμός
πασιφλωρέλαιο πασκαλιά πασμίνα πασμαντερί πασοκτζής πασουμάκι πασούμι πασπάλη
πασπάλισμα πασπάτεμα πασπαλιστήρι πασπαλιστής πασπαρτού πασσάλωμα πασσάλωση
πασσαλάκι πασσαλίσκος πασσαλοσανίδα πασσαλοσανίς πασσαλοφράκτης πασσαλόπηγμα
παστάκι παστάς παστέλ παστέλι παστέλο παστίλια παστίτσιο παστερίωση
παστεριώνω παστοκύδωνο παστορέλα παστορίνα παστουρμάς παστούλα παστρικάδα
παστρουμάς παστόκα πασχάλιο πασχαλίτσα πασχαλιά πασχαλιόγιορτα πασόκι πασόκος
πατάκα πατάκι πατάρι πατάτα πατέ πατέντα πατέρας πατήθρα πατήρ πατήτρια πατίκι
πατίνα πατίνι πατανία παταράτσο πατασμός πατατάκι πατατάλευρο πατατιά
πατατοκροκέτα πατατοπουρές πατατοσαλάτα πατατοφαγία πατατούκα πατατούλα
πατατόπιτα πατατόσουπα πατεντάρισμα πατερίτσα πατερημά πατερμά πατερναλισμός
πατερό πατημασιά πατησιά πατητή πατητήρι πατητής πατινάδα πατινάζ πατινάρισμα
πατισάχ πατομπούκαλα πατουλίνη πατουλιά πατούνα πατούρα πατούσα πατούχας
πατρίκια πατρίκιος πατρίς πατραγαθία πατραλοίας πατριά πατριάρχης πατριαρχία
πατριδογνωσία πατριδογραφία πατριδοκάπηλος πατριδοκαπηλία πατριδολάτρης
πατριδολάτρισσα πατριδολατρία πατριδωνυμικός πατρικία πατρικία πατρικότης
πατριμόνιο πατριμόνιον πατριωτάκι πατριωτισμός πατριός πατριώτης πατριώτις
πατροκτονία πατροκτόνος πατρολογία πατρονάρισμα πατρονία πατρονίστ πατρυιός
πατρωνυμία πατρωνυμικό πατρόγκα πατρόν πατρόνα πατρόνος πατρότης πατρότητα
πατρώνυμον πατσάς πατσίτσες πατσαβούρα πατσαβούρι πατσατζής πατσατζίδικο
παττίχα πατωματζής πατωσιά πατόζα πατόξυλο παυσίπονο παφίτης παφλασμός
παχνί παχυδερμία παχυδερμισμός παχυκεφαλία παχυλότης παχυλότητα παχυμέτρηση
παχυταινία παχύ παχύδερμα παχύμετρο παχύτης παχύτητα παϊδάκι παϊτόνι παύλα
παύσις πε χα πεΐχαμπέρης πείνα πείρα πείραγμα πείραμα πείρος πείσμα πείσμωμα
πεδίκλωμα πεδίλωση πεδίλωσις πεδίο πεδίον πεδιάδα πεδιάς πεδιλοδοκός
πεδιλοποιία πεδιλοποιείο πεδιλοποιείον πεδιλοποιός πεδούκλα πεδούκλι πεεκτομή
πεζεβέγκης πεζεβέγκισσα πεζικάριος πεζικό πεζογέφυρα πεζογράφημα πεζογράφος
πεζοδιάδρομος πεζοδρομία πεζοδρόμηση πεζοδρόμιο πεζοδρόμος πεζοκεφαλαία
πεζολογία πεζολόγος πεζομάχος πεζομαχία πεζοναύτης πεζοπορία πεζοτράγουδο
πεζούλα πεζούλι πεζούνι πεζούρα πεζό πεζόβολο πεζόβολος πεζόδρομος πεζός
πεθαμενατζής πεθαμενατζίδικο πεθαμός πεθερά πεθερικά πεθερούλης πεθερός
πειθάρχηση πειθανάγκη πειθαναγκασμός πειθαρχία πειθαρχείο πειθαρχικό
πειθώ πειθώ πειθώ πεινάλα πεινάλας πειραιώτης πειραματίστρια πειραματισμός
πειραματόζωο πειρασμός πειραστής πειρατής πειρατεία πειρατικό πειραχτήρι
πεισμάτωμα πεισματοσύνη πεισμονή πειστήριο πειστικότης πειστικότητα πεκάν
πεκούνια πελάγρα πελάγωμα πελάτης πελάτις πελάτισσα πελέκημα πελέκηση
πελέκι πελίδνωμα πελίδνωσις πελίνος πελαγοδρομία πελαγοδρόμημα πελαγοδρόμηση
πελαργόνι πελαργόνιον πελαργός πελατεία πελατολόγιο πελεκάνος πελεκητής
πελεκούδι πελελάδα πελερίνα πελιδνότης πελιδνότητα πελλάγρα πελλός
πελματοβάμων πελματογράφος πελματόδερμα πελούζα πελτές πελταστής πελότα
πεμπτημόριον πεμπτουσία πεμπτοφαλαγγίτης πεμπτοφαλαγγίτισσα πενία πεναλτάκιας
πενηντάδραχμο πενηντάευρο πενηντάλεπτο πενηντάρα πενηντάρι πενηντάρικο
πενηντάχρονος πενηνταπεντάχρονος πενηνταράκι πενηνταριά πενθήμερο πενθερά
πενθερός πενθημερία πενιά πενικίλιο πενικίλλιο πενικιλίνη πενιουάρ πενιχρότης
πενουάρ πεντάγραμμο πεντάγραμμον πεντάγωνο πεντάγωνον πεντάδα πεντάδραχμο
πεντάευρο πεντάλ πεντάλεπτο πεντάλι πεντάμηνο πεντάνιο πεντάνιον πεντάρα
πεντάς πεντάωρο πενταήμερος πενταετία πενταετηρίδα πενταθλητής πεντακάλιο
πεντακοσάρα πεντακοσάρι πεντακοσάρικο πεντακοσαριά πεντακοσιομέδιμνος
πενταλό πενταμερία πενταμηνία πεντανάτριο πενταπλασιασμός πενταπόσταγμα
πενταροδεκάρες πενταρχία πενταφωνία πενταχρωμία πεντζέχρι πεντηκοντάδα
πεντηκονταετία πεντηκονταετηρίδα πεντηκονταετηρίς πεντηκοντούτης
πεντηκοντοῦτις πεντηκοστημόριο πεντικιούρ πεντικουρίστα πεντοζάνη πεντοξείδιο
πεντουίλ πεντοχίλιαρο πεντόβολα πεντόδραχμο πεντόδραχμον πεντόλιρο πεντόφραγκο
πεοθηλασμός πεολειξία πεολειχία πεορούφης πεπατημένη πεπλόγλαυκα πεποίθηση
πεπονάκι πεπονιά πεπονόσπορος πεπονόφλουδα πεπρωμένο πεπτίδιο πεπτόνη πεπόνι
περάτωση περάτωσις περέχυμα περίαπτο περίαψη περίβλημα περίβολος περίγειο
περίγελο περίγελος περίγελως περίγραμμα περίγραπτος περίγυρο περίγυρος
περίδεση περίδεσμος περίδρομος περίζωμα περίζωση περίζωσις περίθαλψη
περίθλαση περίθλασις περίκαμψις περίκεντρο περίκεντρον περίκλειση περίκλεισις
περίληψις περίμετρος περίνεο περίνεον περίνοια περίοδος περίοικος περίπαιγμα
περίπατος περίπλεκτρο περίπλεξη περίπλους περίπολο περίπολος περίπτερο
περίπτυξη περίπτυξις περίπτωση περίπτωσις περίσκεψη περίσκεψις περίσσεια
περίσσευμα περίσταση περίστασις περίστερος περίστροφο περίστωον περίσφιγξη
περίσωση περίσωσις περίτμηση περίτριμμα περίττωμα περίφραγμα περίφραξη
περίχυμα περίχωρα περαίωση περαιτέρω περαματάρης περαματιώτης περασιά
περαστική περαστικός περατάρης περαταριά περατζάδα περατότητα περβάζι
περβολάρισσα περβόλι περγέλι περγαμηνή περγαμηνοποιία περγαμόντο περγαμότο
περγαντίνο περγολιά περγουλιά περδίκι περδίκλωμα περδικάκι περδικοθήρας
περδικοπάτημα περδικοπαγίδα περδικοπαγίς περδικοπούλι περδικοστήθω
περδικούλα περδικούλι περδικόπουλο περδικόστηθη περδούκλα περδούκλι
περεστρόικα περηφάνια περιάνθιο περιάνθιον περιέλιγμα περιέλιξη περιέλιξις
περιήγηση περιήγησις περιήλιο περιήλιον περιαγωγή περιαδενίτιδα περιαδενίτις
περιαρθρίτις περιαρτηρίτιδα περιαρτηρίτις περιαυτολογία περιαύγασις περιαύλιο
περιβάλλον περιβαλλοντολογία περιβαλλοντολόγος περιβολάκι περιβολάρης
περιβολή περιβραχιόνιο περιβραχιόνιον περιβόλι περιγέλασμα περιγέλι περιγέλιο
περιγελαστής περιγιάλι περιγράμμιση περιγραπτός περιγραφή περιγραφικότης
περιγυριά περιγόνιο περιγόνιον περιδέραιο περιδέραιον περιδίνηση περιδίνησις
περιδιάβασμα περιδρομόχορτο περιδρόμιασμα περιεκτικότης περιεκτικότητα
περιεχόμενα περιεχόμενο περιεχόμενον περιζώστρα περιηγήτρια περιηγητής
περιθωριοποίηση περιθύρωμα περιθώριο περιθώριον περικάλυμμα περικάρδιο
περικάρπιο περικάρπιον περικαρδίτιδα περικαρδίτις περικαψύλιο περικεφαλαία
περικνημίδα περικνημίς περικοκλάδα περικοπή περικόχλιο περικόχλιον περικύκλωση
περιλαίμιο περιλαίμιον περιλαιμίδα περιληψούλα περιμάζεμα περιμάζωμα
περιμήτριο περιμήτριον περιμαζέματα περιμενάκιας περιμετρία περιμετωπίδα
περιμητρίτιδα περινεοπλαστική περινεύριο περινεύριον περιοδία περιοδεία
περιοδικό περιοδικότης περιοδικότητα περιοδολόγηση περιοδοντίτιδα
περιοδόντιο περιοδόντιον περιορισμός περιοριστής περιοστίτιδα περιοστίτις
περιουσιολόγιο περιοχή περιπάθεια περιπέτεια περιπατήτρια περιπατητής
περιπλάνησις περιπλοκάδα περιπλοκή περιπνευμονία περιποίηση περιποίησις
περιπολάρχης περιπολία περιπολικό περιπτεράκι περιπτεράς περιπτερού
περιπτωσιολογία περιπόδιο περιπόδιον περιπόλιο περιπόλιον περιρραντήριο
περισκελίδα περισκελίς περισκόπηση περισκόπησις περισκόπιο περισκόπιον
περισπέρμιον περισπασμός περισπωμένη περιστάχυο περιστέρα περιστέρι περιστήθιο
περιστερά περιστεράκι περιστερεώνας περιστεριδεύς περιστεριώνας
περιστεροτροφείο περιστεροτρόφος περιστερώνα περιστερώνας περιστολή περιστροφή
περιστύλιο περισυλλογή περισυναγωγή περισφύριο περισχοινισμός περιτείχιση
περιτείχισμα περιτοίχιση περιτοίχισις περιτοίχισμα περιτοιχισμός περιτομή
περιτριγύρισμα περιτροπή περιττολογία περιττολόγημα περιτόναιο περιτύλιγμα
περιτύπωμα περιφέρεια περιφερειάρχης περιφερειάρχισσα περιφερειακά περιφορά
περιφρούρηση περιφρόνηση περιφρόνια περιχάραξη περιχαράκωμα περιχαράκωση
περιχερίς περιχρύσωση περιχρύσωσις περιχόνδριο περιχόνδριον περιχώρηση περιωπή
περιόπτης περιόστεο περιόστεον περιύβριση περιώμιον περκάλ περκάλη περκνάδα
περλίτης περμαφρόστ περντάχι περοβοκίτης περονόσπορος περουβιανός περουζές
περουκιέρης περούκα περπάτημα περπατησιά περπατούρα περσέμολο περσίδα περσίδα
περσοναλίστρια περσοναλισμός περσοναλιστής περσόνα περφεξιονισμός περφορατέρ
περόνη περόνιασμα πεσέτα πεσιμίστρια πεσιμισμός πεσιμιστής πεσκέσι πεσκίρι
πεσκανδρίτσα πεσκαντρίτσα πεσσιμίστρια πεσσιμιστής πεσσοί πεσσός πετάλι
πετάλωμα πετάλωση πετάλωσις πετάρισμα πετέχια πεταλίδα πεταλίδες πεταλισμός
πεταλοποιείον πεταλοποιός πεταλουδίτσα πεταλουργείο πεταλουργείον πεταλουργός
πεταλούδι πεταλούδισμα πεταλωτήριο πεταλωτήριον πεταλωτής πεταξιά πεταρούδι
πεταχτό πετεινά πετεινάρι πετειναράκι πετεινός πετιμέζι πετιμεζόχωμα πετιφούρ
πετνές πετονιά πετοσφαίριση πετούγια πετούνια πετράδι πετράς πετρέλαιο
πετρίτης πετραγγουριά πετραδάκι πετραχήλι πετρελαιάκατος πετρελαιαγωγός
πετρελαιοκίνηση πετρελαιοκίνησις πετρελαιοκηλίδα πετρελαιοκινητήρ
πετρελαιομηχανή πετρελαιοπαραγωγή πετρελαιοπαραγωγός πετρελαιοπηγή
πετρελαιούπολη πετρελαιόπισσα πετριά πετροβάμβακας πετροβολισμός πετροβόλημα
πετρογενετική πετρογλυφικό πετρογονία πετρογραφία πετροδολάριο πετροδολλάριο
πετροδόλλαρο πετροκάραβο πετροκάρβουνο πετροκέρασο πετροκαλαμήθρα
πετροκερασιά πετροκοπιό πετροκόπος πετροκότσυφας πετρολογία πετροπέρδικα
πετροσέλινο πετροτόπι πετροχελίδονο πετροχημεία πετροχημικά πετροψυχιά
πετρόβουνο πετρόγλυφο πετρότοπος πετρόχορτο πετρόψαρο πετσέτα πετσί πετσετάκι
πετσετούλα πετσόκομμα πεττείες πεττός πετόσφαιρα πευκάκι πευκιάς πευκοβελόνα
πευκόδασος πευκόδεντρο πευκόμελο πευκών πευκώνας πεφταργά πεφταστέρι
πεχάμετρο πεχλιβάνης πεψίνη πεϊνιρλί πεύκη πεύκι πεύκο πεύκος πηγάδα πηγάδι
πηγαδάκι πηγαδάρα πηγαδάς πηγαδομούνα πηγαδόνερο πηγαδόπετρα πηγαιμός
πηγεμός πηγούλα πηγούνι πηδάλιο πηδάλιον πηδαλιοέλικα πηδαλιουχία πηδαλιουχείο
πηδηματάκι πηδηματιά πηδηξιά πηκτή πηκτίνη πηκτικότης πηκτικότητα
πηλά πηλάλα πηλάλημα πηλάσβεστο πηλήκιο πηλήκιον πηλίκιο πηλίκο πηλίκον
πηλοβάτης πηλοβατίς πηλοθεραπευτήριο πηλοπλάστης πηλοπλαστική πηλουργός
πηλός πηνίο πηνίον πηξιοσκοπία πηροδακτυλία πηρομέλεια πηροποδία πηρουνάκι
πηρούνι πησσί πηχάκι πηχτή πηχτόγαλο πι πιάν πιάνο πιάνο μπαρ πιάσιμο πιάσμα
πιάστρα πιάτα πιάτο πιάτσα πιένα πιέτα πιανίστα πιανίστας πιανίστρια πιανόλα
πιατάκι πιατέλα πιατέλο πιατίνι πιατικά πιατικό πιατοθήκη πιβουλιά πιγκ πογκ
πιγκουίνος πιγμέντο πιγούνι πιδάκισμα πιδεξιοσύνη πιεζοηλεκτρισμός πιεζομετρία
πιεζόμετρον πιεμοντέζικα πιερότος πιεστήριο πιεστήριον πιεστής πιεστικότης
πιεσόμετρο πιεσόμετρον πιετά πιετά πιετισμός πιζάμα πιθάρι πιθαμή πιθανισμός
πιθανοβαρύτητα πιθανοθεωρία πιθανοκρατία πιθανοκύμα πιθανολογία πιθανολόγημα
πιθανοντολόγος πιθανοτικότητα πιθανοφάνεια πιθανότης πιθανότητα πιθαράδικο
πιθηκάκι πιθηκάνθρωπος πιθηκίνα πιθηκιδεύς πιθηκισμός πιθυμιά πικ απ πικάπ
πικέα πικές πικέτο πικαλίλι πικετοφορία πικνίκ πικράδα πικρία πικρίλα
πικραλίδα πικραμυγδαλέλαιον πικραμυγδαλιά πικραμυγδαλόλαδο πικραμός
πικραμύγδαλον πικροβάσανα πικροδάφνη πικροθάλασσα πικροκυματούσα πικροπηγή
πικρό πικρόγελο πικρόλογα πικρότης πικρότητα πικτογράφημα πικτογραφή
πικτόγραμμα πικόμετρο πιλάλα πιλάλημα πιλάτεμα πιλάτες πιλάφι πιλίδιο πιλαλητό
πιλοθήκη πιλοποιία πιλοποιείο πιλοποιείον πιλοποιός πιλοπωλείον πιλοπώλης
πιλοτή πιλοτήριο πιλοτίνα πιλοτιέρα πιλότος πινάκα πινάκι πινάκιο πινάκιον
πινέζα πινέλο πινακίδα πινακίδιο πινακίδιον πινακίς πινακλάκι πινακογλείφτης
πινακογράφηση πινακοθήκη πινακομηχανική πινακωτή πινγίν πινγκ πονγκ πινελάκι
πινιάτα πιξελίδα πιονέρισσα πιονέρος πιονιέρης πιονιέρισσα πιονιέρος πιοτής
πιοτό πιούτερ πιπέρι πιπέρωμα πιπέτο πιπί πιπίλα πιπίλισμα πιπίνι πιπερίνη
πιπεριά πιπεριέρα πιπεριδίνες πιπεροδοχείον πιπερόριζα πιπετιστής πιράνχα
πιροπλάσμωση πιροσκί πιρουνάκι πιρουνιά πιρουνόδοντο πιρούνα πιρούνι
πιρτέλο πιρόγα πισί πισίνα πισινός πισσάνθρακας πισσάνθραξ πισσάσφαλτος
πισσουρανίτης πισσωτής πισσόστρωση πισσόστρωσις πισσόχαρτο πισσόχαρτον πιστάκη
πιστακιά πιστεύω πιστιά πιστικιά πιστικός πιστοδότης πιστοδότηση πιστοδότησις
πιστοδότρια πιστοκρατία πιστολάκι πιστολήπτης πιστολήπτις πιστολήπτρια
πιστολιά πιστολισμός πιστολοθήκη πιστοποίηση πιστοποίησις πιστοποιητικό
πιστοχρέωση πιστοχρέωσις πιστού πιστρόφια πιστωτής πιστόλα πιστόλι πιστόλιον
πιστόνι πιστός πιστότης πιστότητα πιστώτρια πισωβελονιά πισωγάζι πισωγλέντης
πισωδρόμισμα πισωκολλητό πισωπεταλιά πιτζάμα πιτζαμάκι πιτζαμούλα πιτσίλισμα
πιτσικάτο πιτσιλάδα πιτσιλιά πιτσιρίκα πιτσιρίκι πιτσιρίκος πιτσιρικάς
πιτσουνάκι πιτσουνάκια πιτσούνα πιτσούνι πιτυρίαση πιτυρίδα πιόμα πιόνι πιόνιο
πλάβα πλάγι πλάγια πλάγιασμα πλάι πλάκα πλάκωμα πλάκωση πλάνεμα πλάνισμα πλάνο
πλάση πλάσιμο πλάσμα πλάστης πλάστιγγα πλάστρα πλάστρες πλάστρια πλάστρο
πλάτεμα πλάτη πλάτος πλάτσα πλούτσα πλάτυνση πλάτυνσις πλάτυσμα πλάτωμα πλέγμα
πλέθρον πλέκτης πλέκτρια πλέμπα πλέξη πλέξιμο πλέξις πλέχτης πλέχτουρο πλέχτρα
πλήγιασμα πλήγμα πλήγωμα πλήθεμα πλήθος πλήθυνση πλήθυνσις πλήκτρα πλήκτρο
πλήμμη πλήμνη πλήξη πλήξις πλήρωμα πλήρωση πλήρωσις πλίθα πλίθος πλίθρα
πλαίσια πλαίσιο πλαγίαυλος πλαγγόνα πλαγιά πλαγιοβάδιση πλαγιοβάδισμα
πλαγιοδέτηση πλαγιοδιποδισμός πλαγιοδρομία πλαγιοκόπηση πλαγιοκόφτης
πλαγιοποδισμός πλαγιοπρυμνοδέτηση πλαγιοτομία πλαγιοτροπία πλαγιοτροπισμός
πλαγιοφυλακή πλαγιοφύλακας πλαγιοφύλαξη πλαγιότητα πλαγιότιτλο πλαγιότιτλος
πλαδαρότητα πλαζ πλαισίωμα πλαισίωση πλαισίωσις πλακάκι πλακάς πλακάτ πλακάτο
πλακί πλακίδιο πλακίδιον πλακατζής πλακατζού πλακομούνι πλακοπαγίδα
πλακουτσομύτα πλακουτσομύτης πλακούντας πλακούντιο πλακωμός πλακόπιτα
πλακόστρωση πλακόστρωσις πλανήτης πλανίδι πλαναισθησία πλανεμπορία πλανευτής
πλανητάριο πλανητάριον πλανητάρχης πλανητίσκος πλανητοσκόπιο πλανκόκοκκοι πλαξ
πλασέ πλασέμπο πλασιέ πλασματοκύτταρο πλασμαφαίρεση πλασμολυσία πλασμόλυση
πλαστήρι πλαστίδιο πλαστίνη πλασταριά πλαστελίνη πλαστική πλαστικοποίηση
πλαστικοταινία πλαστικό πλαστικότητα πλαστογράφημα πλαστογράφηση πλαστογράφος
πλαστοπροσωπία πλαστουργός πλαστούργημα πλαστότητα πλατάγισμα πλατάνι πλατάρια
πλατίκα πλατίνα πλαταγή πλαταγισμός πλαταμώνας πλατανιάς πλατανότοπος
πλατανώνω πλατεία πλατειασμός πλατσομύτα πλατσομύτης πλατυκεφαλία πλατυποδία
πλατφόρμα πλατωνικά στερεά πλατωνισμός πλατωσιά πλατό πλατόνι πλατύβαθρο
πλατύποδας πλατύπους πλατύσκαλο πλατύτης πλατύτητα πλαφονιέρα πλαφόν πλειάδα
πλειοδοσία πλειοδότης πλειοδότις πλειοδότρια πλειονοψηφία πλειονότης
πλειοψηφία πλειστηρίαση πλειστηρίασις πλειστηρίασμα πλειστηριασμός
πλειστόκαινο πλειστόκαινος πλεκτάνη πλεκτήριο πλεκτήριον πλεκτική πλεκτό
πλεμπάγια πλεμόνι πλεξάνα πλεξίδα πλεξίς πλεξιγκλάς πλεξούδα πλεονέκτημα
πλεονέκτις πλεονέκτρα πλεονέκτρια πλεονέχτης πλεονέχτρα πλεονασμός
πλεονεκτικότητα πλεονεξία πλεούμενο πλεούσα πλερέζα πλερωμή πλερωτής πλερωτικά
πλευρίς πλευρίτης πλευρίτιδα πλευρίτις πλευρεκτομία πλευροδεσία πλευροδυνία
πλευροκόπηση πλευροκόπησις πλευρονήκτης πλευροτομή πλευροτομία πλευρό πλευρόν
πλευστότης πλευστότητα πλεχτήριο πλεχτική πλεχτό πλεόνασμα πλεύριση πλεύρισις
πλεύση πλεύσις πληβεία πληβείος πληγή πληθάριθμος πληθοπαραγωγή
πληθυσμογράφος πληθυσμογραφία πληθυσμός πληθωρικότης πληθωρικότητα πληθωρισμός
πληθώρα πληκτρολογητής πληκτρολόγηση πληκτρολόγιο πληκτρολόγιον πληκτροφόρο
πλημμέλεια πλημμέλημα πλημμελειοδίκης πλημμελειοδικείο πλημμελειοδικείον
πλημμυρίς πλημμύρα πλημμύρισμα πλημύρα πληρεξουσιότης πληρεξουσιότητα
πληροφορία πληροφοριακός πληροφορικάριος πληροφορική πληροφορικοπαγής
πληροφοριοδότης πληροφοριοδότις πληροφοριοδότρια πληροφόρηση πληροφόρησις
πληρωτής πληρότης πληρότητα πληρώτρια πλησίασις πλησίασμα πλησίον πλησμονή
πλιατσικολόγημα πλιατσικολόγος πλιγούρι πλιθί πλινθοδομή πλινθοδομία
πλινθοδόμος πλινθοκεραμοποιία πλινθοποίηση πλινθοποίησις πλινθοποιία
πλινθοποιείον πλινθοποιός πλισάρισμα πλισές πλοήγηση πλοήγησις πλοίαρχος πλοίο
πλοηγία πλοηγίδα πλοηγίς πλοηγεσία πλοηγός πλοιάριο πλοιάριον πλοιαρχία
πλοιοκτήτρια πλοιοκτησία πλοκάμι πλοκή πλοκαμίδα πλοκαμίς πλοκαμός πλοκός
πλουμί πλουμίδι πλουραλίστρια πλουραλισμός πλουραλιστής πλους πλουσιόπαιδο
πλουτοκράτης πλουτοκράτις πλουτοκράτισσα πλουτοκρατία πλουτολογία πλουτωνισμός
πλουτώνιο πλουτώνιον πλοχμός πλοϊμότης πλοϊμότητα πλούμισμα πλούτισμα πλούτος
πλυντήριο πλυντήριον πλυντρίδα πλυνός πλυσταριό πλυστικά πλωροδέτηση πλωτάρχης
πλωτήρας πλόκαμος πλόσκα πλότερ πλύμα πλύντης πλύντρια πλύση πλύσιμο πλύστρα
πλῆκτρον πλῆκτρον πλῆξις πλῆξις πνίγος πνίξιμο πνίχτης πνευμάτωση
πνευματικός πνευματικότητα πνευματισμός πνευματιστής πνευματοθεραπεία
πνευματολατρεία πνευματολογία πνευμοθώρακας πνευμοκονίαση πνευμονία
πνευμονογράφηση πνευμονογράφος πνευμονοθώρακας πνευμονοκονίαση πνευμονολογία
πνευμονοπάθεια πνευμονοπλευρίτιδα πνευμονορραγία πνευμονόκοκκος πνευμόνι
πνευστό πνεύμα πνεύμονας πνιγηρότητα πνιγμονή πνιγμός πνιγούρα πνοή ποάνθρακας
ποίηση ποίησις ποίκιλμα ποίκιλσις ποίμανδρος ποίμνη ποίμνιο ποίμνιον πογκρόμ
ποδάρας ποδάρι ποδήλατο ποδίατρος ποδίσκος ποδανά ποδαντλία ποδαράκι ποδαράς
ποδαρικό ποδαρού ποδαρόδρομος ποδεσιά ποδηγέτης ποδηγέτηση ποδηγέτησις
ποδηλάτης ποδηλάτις ποδηλάτισσα ποδηλασία ποδηλατάδα ποδηλατάδικο ποδηλατάς
ποδηλατιστής ποδηλατοδρεζίνα ποδηλατοδρομία ποδηλατοδρόμιο ποδηλατοδρόμιον
ποδηλατοπορία ποδηλατοπορεία ποδηλατοτουρισμός ποδηλατόδρομος ποδιά ποδοβολή
ποδοβόλημα ποδοδάχτυλο ποδοδέτης ποδοθεραπευτής ποδοκομία ποδοκρουσία
ποδοκόπι ποδοκύλημα ποδοκύλισμα ποδομοχλός ποδοπάτημα ποδοπάτηση ποδοπάτησις
ποδοστρόφαλος ποδοσφαίριση ποδοσφαίρισις ποδοσφαιρίστρια ποδοσφαιριστής
ποδόδεσμος ποδόλουτρο ποδόμακτρο ποδόμακτρον ποδόμυλος ποδόπληκτρο
ποδόσταμα ποδόσταμο ποδόστημα ποδόσφαιρα ποδόσφαιρο ποδόσφαιρον ποδότης
ποετάστρος ποζάρισμα ποζιτιβισμός ποζιτιβιστής ποζιτρόνιο ποζολάνη
ποιήτρια ποιημάτιον ποιηματάκι ποιηματολόγιο ποιητάκος ποιητάρης ποιητής
ποιητικότης ποιητικότητα ποικιλία ποικιλομορφία ποικιλοχρωμία ποικιλτής
ποικιλότητα ποιμένας ποιμήν ποιμαντική ποιμαντορία ποιμενάρχης ποιμεναρχία
ποιμνιοβοσκή ποιμνιοστάσιο ποιμνιοστάσιον ποιμνιοτρόφος ποινή ποινικολογία
ποινικοποίηση ποινικότης ποινικότητα ποινολόγιο ποινολόγιον ποιόν ποιότης
ποκάρι πολάκα πολάκρα πολέμαρχος πολέντα πολίτευμα πολίτης πολίτις πολίτισσα
πολίτσια πολίχνη πολίχνη πολίωσις πολειφάδι πολεμάρχης πολεμάρχος πολεμίστρα
πολεμαρχία πολεμική τέχνη πολεμικό πολεμικότης πολεμικότητα πολεμιστής
πολεμόσημο πολεοδομία πολεοδόμηση πολεοδόμος πολεολογία πολεομορφία
πολικότητα πολιοεγκεφαλίτιδα πολιομυελίτιδα πολιομυελίτις πολιομυελιτικός
πολιορκητής πολιούχος πολισμάνος πολισμός πολιτάκι πολιτάρχης πολιτεία
πολιτειολογία πολιτειολόγος πολιτευτής πολιτικά πολιτικάντης πολιτική
πολιτικολογία πολιτικολόγος πολιτικομανία πολιτικοποίηση πολιτικός πολιτικότης
πολιτισμολογία πολιτισμός πολιτογράφηση πολιτογράφησις πολιτοφυλακή
πολιτοφύλαξ πολιτσμάνος πολλαπλάσιο πολλαπλάσιον πολλαπλασιασμός
πολλαπλότης πολλαπλότητα πολλοστημόριο πολλοστημόριον πολτοποίηση πολτοποίησις
πολυάγκιστρο πολυάνδριο πολυέλαιος πολυαδενία πολυαιθυλένιο πολυαιμία
πολυακετάλη πολυαμίδιο πολυαμίνη πολυανδρία πολυανθρωπία πολυαπασχόληση
πολυαρθρίτις πολυαρχία πολυβινυλοπυρρολιδόνη πολυβολαρχία πολυβολητής
πολυβουία πολυβουταδιένιο πολυβουτυλένιο πολυβόλο πολυβόλον πολυγένεση
πολυγαμία πολυγλωσσία πολυγνωσία πολυγονία πολυγράφηση πολυγράφος πολυγραφία
πολυδακτυλία πολυδιάσπαση πολυδιεργασία πολυδιψία πολυδυνητικότητα πολυδωρία
πολυεκατομμυριούχος πολυεκτοξευτήρας πολυεστέρας πολυευσπλαγχνία
πολυζωία πολυηλεκτρολύτης πολυθεΐα πολυθεΐστρια πολυθεσία πολυθεσίτης
πολυθεϊσμός πολυθεϊστής πολυθρόνα πολυκάνδηλον πολυκάντηλο πολυκαιρία
πολυκαλλιέργεια πολυκαρμπονάτο πολυκαρπία πολυκατάστημα πολυκατοικία
πολυκινηματογράφος πολυκλαδία πολυκλινική πολυκομματισμός πολυκοσμία
πολυκουάρκ πολυκυτταρικότητα πολυκόμβος πολυκόσμος πολυλαλία πολυλαλιά
πολυλεξία πολυλογάς πολυλογία πολυλογού πολυμάθεια πολυμέλεια πολυμέρεια
πολυμεταλλισμός πολυμηνόρροια πολυμηχάνημα πολυμηχανία πολυμορφία πολυμορφικό
πολυμορφοπύρηνο πολυμουσικός πολυνίκης πολυνευρίτιδα πολυνευρίτις
πολυνημάτωση πολυνομία πολυνομοσχέδιο πολυνοσηρότητα πολυολεφίνη πολυομβρία
πολυοσμία πολυουρία πολυουρεθάνη πολυοψία πολυπάθεια πολυπειρία πολυπεκτομή
πολυπλέκτης πολυπλεξία πολυπλοκότητα πολυποδία πολυποδεκτομή
πολυποσία πολυπράγμονας πολυπραγματικότητα πολυπραγμοσύνη πολυπρογραμματισμός
πολυπροσωπία πολυπτύχωση πολυπότης πολυπώλιο πολυπώλιον πολυσακχαρίτης
πολυσεξουαλικότητα πολυσημία πολυσκάφος πολυσπερμία πολυσταυρία πολυσταύριο
πολυστυρένιο πολυσυγγραμικότητα πολυσυγγραμμικότητα πολυσυμπαντικότητα
πολυσύμπαν πολυσύνδετο πολυσύνδετον πολυτέλεια πολυτεκνία πολυτεχνίτης
πολυτεχνίτρα πολυτεχνείο πολυτεχνισμός πολυτιμότητα πολυτοκία πολυτονίστρια
πολυτονισμός πολυτονιστής πολυτοπικότητα πολυτρίχι πολυτραυματίας πολυτριχία
πολυτροφία πολυτυπία πολυυπνογραφία πολυφαγάς πολυφαγία πολυφαρμακία πολυφημία
πολυφυλετισμός πολυφωνία πολυχρηματία πολυχρονικότητα πολυχρονισμός
πολυχρονιότητα πολυχρωμία πολυχρωμισμός πολυχρόνιο πολυχρόνιση πολυχρόνισμα
πολυψώνιον πολυωνυμία πολυωπία πολυϊατρείο πολυόλη πολυώνυμο πολφίτιδα
πολφεκτομή πολφός πολωνέζα πολωνέζα πολωνέζικα πολωνικά πολωνός πολωσίμετρο
πολωσιοσκόπιο πολωσιοσκόπιον πολωτής πολύγραφος πολύγωνο πολύγωνον πολύεδρο
πολύζυγον πολύμπριζο πολύνησο πολύνησον πολύορχις πολύποδας πολύπους πολύπριζο
πολύπτυχον πολύσπαστο πολύσπαστον πολύτεκνος πολύφωτο πολύφωτον πολώνιο πομάδα
πομπάρισμα πομπή πομποδέκτης πομπός πομφόλυγα πομφόλυξ πομφός πομόνα πομώνα
πονάκια πονέντες πονήρεμα πονήρευμα πονήρω πονεντογάρμπης πονεντομαΐστρος
πονημάτιον πονηράδα πονηρία πονηριά πονοκέφαλος πονοκεφάλιασμα πονοψυχιά
ποντίκι ποντίφικας ποντίφιξ πονταδόρα πονταδόρος πονταρισιά ποντικάκι ποντικί
ποντικοκούραδο ποντικομαμή ποντικοουρά ποντικοπαγίδα ποντικοφάγωμα
ποντικοφωλιά ποντικός ποντικότρυπα ποντοπλοΐα ποντοπορία πονόδοντος πονόκοιλος
πονόματος ποπ ποπκόρν ποπλίνα ποπολάρος ποπός πορδή πορδαλάς πορδαλού
πορδοβούλωμα πορδού πορεία πορθητής πορθμέας πορθμίδα πορθμείο πορθμείον
πορθμός ποριά πορισμός ποριώτης ποριώτισσα πορνίδιο πορνίδιον πορνεία πορνείο
πορνοβοσκός πορνογράφημα πορνογράφος πορνογραφία πορνοκρατία πορνοπεριοδικό
πορνοστάσιο πορνοστάσιον πορνοταινία πορνό πορνόγερος πορνόσπιτο ποροσκοπία
πορσελάνη πορτ κλε πορτ μπεμπέ πορτάκι πορτάρης πορτέλο πορτίτσα πορταμέντο
πορτιέρης πορτιέρισσα πορτμαντό πορτμονέ πορτμπαγκάζ πορτμπεμπέ πορτμπονέρ
πορτογαλέζα πορτογαλέζος πορτογαλικά πορτοκάλι πορτοκάλιον πορτοκαλάδα
πορτοκαλί πορτοκαλεών πορτοκαλεώνας πορτοκαλιά πορτοκαλόμελο πορτολάνα
πορτοπαράθυρο πορτοφολάς πορτοφολού πορτοφόλι πορτούλα πορτρέτο πορτραίτο
πορτόνι πορτόφυλλο πορφυρίτης πορφυρό πορφύρα ποσειδωνισμός ποσειδωνιστής
ποσηγορία ποσθίτιδα ποσολογία ποσοστηµόριο ποσοστικοποίηση ποσοστό ποσοστόν
ποστάλι ποστίς ποστουρογραφία ποσό ποσόν ποσόστωση ποσόστωσις ποσότης ποσότητα
ποτ-ο-φε ποτάμι ποτάσα ποτήρι ποτήριον ποτίστρα ποταμάκι ποταμίσκος ποταμιά
ποταμολίμνη ποταμοπλοΐα ποταμόβαρκα ποταμόκολπος ποταμόπλοιο ποταμόπλοιον
ποταμόσκυλο ποταμότρυγγας ποταμόψαρο ποταπαγόρευση ποταπότης ποταπότητα
ποτηράκι ποτηριά ποτιστήρι ποτιστής ποτοαπαγόρευση ποτοποιία ποτοποιείο
ποτοποιός ποτοπωλείο ποτούμπα ποτό ποτό του μάη ποτόκι πουαντιλισμός πουγκί
πουδρίτσα πουδριέρα πουθενά πουκάμισο πουκαμίσα πουκαμισάδικο πουκαμισάκι
πουκαμισού πουλάδα πουλάκι πουλάρα πουλάρι πουλέν πουλί πουλακίδα πουλερικό
πουλοβεράκι πουλολόγος πουλούκα πουλόβερ πουνέντες πουνέντης πουντριέρα
πουράκλα πουρές πουρί πουργατόριο πουργατόριον πουργκατόριο πουργκατόριον
πουριτανισμός πουριτανός πουρμπουάρ πουρνάρι πουρνό πουρού πουρσουίτ πουρό
πουστάρα πουστίτσα πουσταράς πουσταρέλι πουσταρδέλι πουσταριό πουστιά
πουστράκι πουστρέσα πουστρόνι πουστόγερος πουτάνα πουτίγκα πουτανάκι
πουταναριό πουτανιά πουτσαράς πουτσοκέφαλο πουτσοσκάμπιλο πούδρα πούζα
πούλημα πούληση πούλι πούλια πούλλα πούλμαν πούλος πούλουδο πούλπα πούμα
πούντιασμα πούντρα πούπουλο πούππα πούρμπερη πούρο πούσι πούσταρος πούστης
πούτσα πούτσος πούττος ππάλα ππαλουζές ππαράς ππαραλλής ππούλιν πράγμα
πράμα πράξη πράξις πράσινο πράσο πράτα πράτγιο πράτιγο πράυνση πράυνσις πρέζα
πρέκνα πρέμνο πρέπον πρέσα πρέσβειρα πρέσβευση πρέσβης πρέσβυς πρέστο πρέφα
πρήχτης πρίβη πρίγκηψ πρίγκιπας πρίζα πρίμα πρίμο πρίνος πρίσμα πραίτορας
πραγμάτευση πραγμάτευσις πραγμάτωση πραγμάτωσις πραγματάκι πραγματίστρια
πραγματικότης πραγματικότητα πραγματισμός πραγματιστής πραγματογνωμοσύνη
πραγματογνώμονας πραγματογνώμων πραγματοκρατία πραγματολογία πραγματοποίηση
πραικόκκιον πραιτοριανοί πραιτοριανός πραιτόριο πραιτώριον πρακτέον πρακτικά
πρακτικισμός πρακτικογράφος πρακτικό πρακτικόν πρακτικός πρακτικότης
πρακτορεία πρακτορείο πρακτορείον πρακτόρευση πρακτόρευσις πρακτόρισσα πραλίνα
πραματάκι πραματευτάδικο πραματευτής πρανές πραξικοπηματίας πραξικόπημα
πρασίνισμα πρασεοδύμιο πρασιά πρασινάδα πρασινίλα πρασινοδύμιο πρασινοκέφαλη
πρασινοφρουρός πρασουλίδα πρασόπιτα πρασόρυζο πρασόσουπα πρασόφυλλο πρατήριο
πρατηριούχος πραχτικότητα πραότης πραότητα πρεβάζι πρεβεζάνος πρεβεντόριο
πρεβιοτικός πρεζάκι πρεζάκιας πρεζάρισμα πρεζόνι πρελούδιο πρελούντιο πρεμιέρα
πρεμούρα πρες κόνφερανς πρεσάρισμα πρεσβεία πρεσβευτής πρεσβυτέρα πρεσβυτέριο
πρεσβυτερείον πρεσβυτεριανοί πρεσβυωπία πρεσβύτης πρεσβύωπας πρεστίζ πρηνισμός
πριαπισμός πριγκίπισσα πριγκιπάτο πριγκιπέσα πριγκιποπούλα πριγκιπόπουλο πριμ
πριμαντόνα πριμιτιβισμός πριμιτιβιστής πριμοδότηση πριμοδότησις πριμούλα πριν
πριναρόδεντρο πριονίδι πριονιστήριο πριονιστήριον πριονιστής πριονοκορδέλα
πριονόμυλος πριστήριο πριστήριον πριτς πριτσίνι πριόνι πριόνιση πριόνισις
προΐστιο προΐστιον προάγγελμα προάγγελος προάλλες προάνθρωπος προάσκηση
προάσπιση προάσπισις προάστια προάστιο προέκταση προέκτασις προέλαση προέλασις
προέλευση προέλευσις προέμβασμα προέφηβος προίκα προίκιση προίκισμα προΰπαρξη
προαίρεση προαίρεσις προαίσθημα προαίσθηση προαίσθησις προαγγελία προαγορά
προαγωγεία προαγωγός προανάκριση προανάκρισις προανάκρουση προανάκρουσις
προανάφλεξη προανάφλεξις προαναγγελία προαπάντημα προαπαγόρευση προαπαιτούμενο
προαποβίωσις προαποστολή προαπόδειξη προαπόδειξις προασβέστωση προασπίστρια
προαστικοποίηση προασφάλιση προασφάλισις προαφαίρεση προαφαίρεσις προαύλιο
προβάδιση προβάδισις προβάδισμα προβάρισμα προβέντζα προβίβαση προβασκάνι
προβατάρης προβατάρισσα προβατέμπορος προβατίλα προβατίνα προβατοκάμηλος
προβατοτροφία προβενσιανός προβηγκιανά προβιά προβιβασμός προβιοτικό
προβιταμίνη προβλήτα προβλήτας προβλαστήριο προβλεπτικότης προβλεπτικότητα
προβληματική προβληματικότητα προβληματισμός προβοκάρισμα προβοκάτορας
προβοκατόρισσα προβολέας προβολή προβολικό προβολιστής προβοσκίδα προβοσκιδωτά
προβούλευμα προβόδισμα προβόδωμα προγάστορας προγάστωρ προγεστερόνη
προγηρία προγιαγιά προγκάρισμα προγναθία προγναθισμός προγνωστικό προγνωστικόν
προγονισμός προγονολάτρης προγονολατρία προγονολατρεία προγονοπληξία
προγονός προγούλι προγραμματάκι προγραμματίστρια προγραμματισμός
προγραφή προγυμνάστρια προγυμναστήριο προγυμναστήριον προγυμναστής προγόμφιοι
προγύμναση προγύμνασμα προδημοσίευση προδιάθεση προδιάθεσις προδιαβούλευση
προδικασία προδοσία προδραστικότητα προδόρπιο προδόρπιον προδότης προδότις
προδότρα προδότρια προείσπραξη προείσπραξις προεγγραφή προεδρία προεδρίνα
προεδριλίκι προεδροδημοκράτης προεδροδημοκρατικός προειδοποίηση προειδοποίησις
προεκβολή προεκλαμψία προεκτύπωση προεμπλουτισμός προενέργεια προενισχυτής
προεξέλεγξις προεξοφλήτρια προεξοφλητής προεξοχή προεξόφλημα προεξόφληση
προεπερίδα προεπισκόπηση προεργασία προεσπερίς προεστός προεστώς προετοιμασία
προζωστρίδα προζωστρίς προζύμι προηγιασμένη προηγουμένη προηγούμενο
προημιτελικός προθάλαμος προθέρμανση προθέρμανσις προθήκη προθερμαντήρας
προθρομβίνη προθυμία προθυμιά προθώρακας προθώραξ προικισμός προικιό
προικοδότης προικοδότηση προικοδότησις προικοθήρας προικοθηρία προικολήπτης
προιξ προκάλυμμα προκάλυψη προκάλυψις προκάρδιο προκήρυξη προκήρυξις
προκαθορισμός προκατάληψη προκατάληψις προκατάρτιση προκατάρτισις προκατήχηση
προκαταβολή προκατασκευή προκλητικότης προκλητικότητα προκοίλι προκοπή
προκυμαία προλίνη προλακτίνη προλεγόμενα προλεξιμότητα προλετάριος
προλεταριάτο προλεταριοποίηση προλιμένας προλιμήν προλύτης προμάμμη προμάντεμα
προμέρισμα προμήθεια προμήθειο προμήνυμα προμήτωρ προμίσθωμα προμακέτα
προμαχώνας προμελέτη προμετωπίδα προμετωπίς προμετωπιαίο προμηθέας προμηθευτής
προμηθεύτρα προμηθεύτρια προμνησία προνήπιο προνευστασμός προνοητικότης
προνομία προνομιούχος προνομοθετικός προνουντσιαμέντο προνόμιο προνόμιον
προξενήτρα προξενείο προξενείον προξενητής προξενιά προξενιό προοίμιο
προοδευτικότης προοδευτικότητα προολκέας προολκή προολκεύς προοπτική
προοπτικότητα προορατικότης προορατικότητα προορισμός προπάνιο προπάπποι
προπάππους προπάτορας προπάτωρ προπέλα προπέτασμα προπέτεια προπέτης προπέτις
προπαίδεια προπαίδευση προπαίδευσις προπαγάνδα προπαγάνδιση προπαγανδίστρια
προπαγανδιστής προπαιδεία προπαππούς προπαράγοντας προπαραλήγουσα προπαραμονή
προπαρασκευή προπαρασκευαστής προπελάς προπηλάκιση προπηλακισμός προπηλακιστής
προπλασμός προπληρωμή προπληρωτής προπομπή προπομπός προπονήτρια προπονητής
προποτζίδικο προπυλένιο προπόνηση προπόρευση προπύλαια προπύργιο προσάναμμα
προσάραξις προσάρμοση προσάρμοσις προσάρτημα προσάρτηση προσάρτησις προσέγγιση
προσέγχυμα προσέλευση προσέλευσις προσέλκυση προσέλκυσις προσήλιο προσήλωση
προσήμανσις προσήνεια προσαγωγή προσαγωγός προσαγόρευση προσαγώγιο
προσανατολισμός προσαρμογή προσαρμοστία προσαρμοστικότης προσαρμοστικότητα
προσαύξησις προσβασιμότητα προσβλητικότης προσβλητικότητα προσβολή προσγείωση
προσγεγραμμένη προσγειάλωση προσδετήρ προσδετήρας προσδιορισμός προσδιοριστής
προσδοκώμενο προσεδάφιση προσεπίκληση προσεπίκλησις προσεπικύρωση
προσεταιρισμός προσεταιριστικόεδρο προσεταιριστικότητα προσευχάδιο προσευχή
προσευχητάριον προσευχούλα προσεχώς προσηγορία προσηλίαση προσηλίασις
προσηλυτισμός προσηλύτιση προσηλύτισις προσημείωση προσημείωσις προσθαλάσσωση
προσθαφαίρεση προσθαφαίρεσις προσιτότητα προσκάλεσμα προσκέφαλο προσκήνιο
προσκεφάλαιον προσκεφάλι προσκεφαλάδα προσκεφαλάδι προσκλητήριο προσκλητήριον
προσκοπίνα προσκοπιμότητα προσκοπισμός προσκρουστήρας προσκυνήτρα προσκυνήτρια
προσκυνητάριον προσκυνητής προσκυνοχάρτι προσκόλληση προσκόλλησις προσκόμιση
προσκύνημα προσκύνηση προσκύνησις προσκύρωση προσκύρωσις προσλαλιά προσμέτρηση
προσμονάριος προσμονή προσνήωση προσομοίωση προσομοιωτής προσομολόγηση
προσονομασία προσοχή προσπάθεια προσπέλαση προσπέλασις προσπέραση προσπέρασμα
προσποίησις προσπορισμός προσροφητής προσρόφηση προσρόφησις προσσελήνωση
προστάδιο προστάθι προστάτης προστάτιδα προστάτις προστάτισσα προστάτρια
προσταγή προσταγλανδίνη προστακτική προστασία προστατίτιδα προστατίτις
προστατόρροια προστερνίδιον προστιμάρισμα προστριβή προστυχάντζα προστυχιά
προστυχόκοσμος προστυχόλογα προστυχόπραμα προστυχών προστώο προστώον
προσυδάτωση προσυλλογισμός προσυνεννόηση προσυνόψιση προσυπογραφή προσυστολή
προσφάι προσφιλή προσφορά προσφορά προσφοράκι προσφοριάρης προσφυγάκι προσφυγή
προσφυγιά προσφυγοκάπηλος προσφυγοπαίδι προσφυγοπατέρας προσφυγοπούλα
προσφώνηση προσφώνησις προσχέδιο προσχέδιον προσχεδίασμα προσχηματισμός
προσχώρησις προσωδία προσωνυμία προσωνύμιο προσωπάρχης προσωπίδα προσωπίς
προσωπείο προσωπείον προσωπιδοφορία προσωπιδοφόρος προσωπικό προσωπικόν
προσωπικότητα προσωπογράφος προσωπογραφία προσωποκράτηση προσωποκράτησις
προσωπολάτρης προσωπολήπτης προσωπολατρία προσωποληψία προσωπολογία
προσωπομετρική προσωποποίηση προσωποποίησις προσωποποιία προσωρινότης
προσόδιον προσόν προσόρμιση προσόρμισις προσόψι προσόψιον προσύμβαση
προσύμφωνο προσύμφωνον προσύνταξη προτέρημα προτίμηση προτίμησις προτακτικό
προτείχιον προτείχιση προτείχισις προτείχισμα προτεκτοράτο προτεραία
προτεραιότης προτεραιότητα προτερόχρονο προτεστάντης προτεστάντις
προτεσταντισμός προτζέκτορας προτιμολόγηση προτιμολόγιο προτιμολόγιον προτομή
προτσές προτυποποίηση προφάρμακο προφέσορας προφήτης προφήτισσα προφίλ
προφητάναξ προφητεία προφιλοπλαστική προφορά προφορικά προφορικότητα
προφυλάκισις προφυλακή προφυλακισμός προφυλακτήρας προφυλακτικό προφυλαχτήρας
προφύλαξη προφύλαξις προφύσιο προχείρηση προχείρισις προχειρίδα προχειρίς
προχειροδουλειά προχειρολογία προχειρολόγημα προχειρότης προχειρότητα προχοΐδα
προχρηματοδότησις προχρονολόγηση προχρονολόγησις προχώ προχώρημα προχώρηση
προωθητής προωνύμιο προωνύμιον προωστήρας προωστικό προϊδέαση προϊστάμενος
προϊστορία προϊόν προϋπάντηση προϋπάντησις προϋπηρεσία προϋπογραφή
προϋπόθεση προϋπόθεσις προϋπόσταση προϋπόστασις προϋπόσχεση προϋπόσχεσις
προύνο προύχοντας προύχων προώθηση προώθησις πρυμάτσα πρυματσάρισμα πρυμνήτης
πρυμνοδέτηση πρυτάνισσα πρυτανεία πρυτανείο πρωί πρωία πρωθιεράρχης πρωθιερέας
πρωθυπολοχαγός πρωθυπουργία πρωθυπουργίνα πρωθυπουργησιμότητα
πρωθυπουργός πρωιμάδι πρωιμιά πρωιμότης πρωιμότητα πρωινή πρωινό πρωκτοβασία
πρωκτός πρωράτης πρωρατικά πρωρεύς πρωτάθλημα πρωτάκι πρωτάριθμος πρωτάρχισμα
πρωτέα πρωτέκδικος πρωτέωμα πρωτίδια πρωταίτιος πρωταγωνίστρια πρωταγωνιστής
πρωταθλητής πρωταθλητισμός πρωτακτίνιο πρωταπριλιά πρωταρχίνισμα
πρωταυγουστιά πρωτεΐνη πρωτεΐνωμα πρωτείο πρωτεξάδελφος πρωτεξαδέλφη
πρωτεργάτις πρωτεργάτισσα πρωτεργάτρια πρωτευαγγέλιο πρωτευαγγέλιον
πρωτεϊνοθεραπεία πρωτεϊνόλυση πρωτεϊνόλυσις πρωτεύουσα πρωτιά πρωτινοί
πρωτοβλάστη πρωτοβουλία πρωτοβρόχι πρωτογένεια πρωτογέννημα πρωτογερμανικά
πρωτοδίκης πρωτοδικείο πρωτοδικείον πρωτοεπιστάτης πρωτοθηρία πρωτοκάθεδρος
πρωτοκαθεδρία πρωτοκανονικά πρωτοκαπετάνιος πρωτοκλέφτης πρωτοκλέφτρα
πρωτοκολλητής πρωτοκόλληση πρωτοκύτταρο πρωτολογισμός πρωτομάρτυρας
πρωτομάστορης πρωτομαγιάτικα πρωτομαρτιά πρωτομαρτιάτικα πρωτομηνιά
πρωτονοτάριος πρωτονουκλεοσύνθεση πρωτοξείδιο πρωτοπάθεια πρωτοπαλίκαρο
πρωτοπλάστης πρωτοπορία πρωτοπρεσβύτερος πρωτοπυγμάχος πρωτοπόρος πρωτοπόρος
πρωτοσπαθάριος πρωτοστάτης πρωτοσύγκελλος πρωτοσύγκελος πρωτοτοκία πρωτοτυπία
πρωτοφειλέτης πρωτοφωτόνια πρωτοφωτόνιο πρωτοψάλτης πρωτοϊταλικά πρωτόγαλα
πρωτόγραμμα πρωτόγραφο πρωτόγραφον πρωτόζωο πρωτόζωον πρωτόθρονος πρωτόκολλο
πρωτόλειο πρωτόλειον πρωτόνιο πρωτόνιον πρωτόπαπας πρωτόπιασμα πρωτόπλασμα
πρωτόσκολος πρωτόσχολος πρόβα πρόβατο πρόβλεψη πρόβλεψις πρόβλημα πρόβολος
πρόγευση πρόγκα πρόγκηγμα πρόγκισμα πρόγνωση πρόγνωσις πρόγονος πρόγραμμα
πρόδειπνον πρόδομος πρόδρομος πρόεδρος πρόζα πρόθεμα πρόθεση πρόθεσις πρόθημα
πρόθυρον πρόκα πρόκληση πρόκλησις πρόκομμα πρόκραμα πρόκριμα πρόκριση
πρόκριτος πρόκτηση πρόκτησις πρόκυψη πρόκυψις πρόληψη πρόληψις πρόλοβος
πρόμαχος πρόναος πρόναυλος πρόνευση πρόνευσις πρόνοια πρόξενος πρόοδος
πρόπηγμα πρόπλασμα πρόποδες πρόπολις πρόποση πρόπτωση πρόπυλο πρόσβαση
πρόσδεση πρόσδεσις πρόσημο πρόσθεση πρόσθεσις πρόσθετο πρόσθημα πρόσθιο
πρόσκλησις πρόσκομμα πρόσκοπος πρόσκρουση πρόσκρουσις πρόσκτηση πρόσκτησις
πρόσληψις πρόσμειξη πρόσμειξις πρόσοδος πρόσοψη πρόσοψις πρόσπτωση πρόσπτωσις
πρόσρηση πρόσρησις πρόσταγμα πρόστεγο πρόστιμο πρόστιμον πρόστρατος πρόστριψη
πρόστυμμα πρόστυχη πρόσφορο πρόσφυγα πρόσφυγας πρόσφυμα πρόσφυση πρόσφυσις
πρόσχωμα πρόσχωση πρόσχωσις πρόσωπο πρόσωπον πρόταγμα πρόταξη πρόταξις πρόταση
πρότονος πρότσα πρότυπο πρόφαση πρόφασις πρόφυλλα πρόχειρο πρόχειρον πρόχωμα
πρόωσις πρύμη πρύμισμα πρύμνα πρύμνη πρύτανης πρώρα πρώσος πτέραρχος πτέρις
πτέρυγα πτέρυξ πτέρωμα πτήση πτήσις πτίλο πτίλωμα πτίση πταίσμα πταίστης
πταισματοδικείο πταισματοδικείον πταρμός πταῖσμα πτελέα πτερνιστήρ
πτεροφυΐα πτερυγίδιο πτερόν πτερόρροια πτερόσαυρος πτερύγιο πτερύγιον
πτερύγωμα πτηνομορφία πτηνοσφαγείο πτηνοτροφία πτηνοτροφείο πτηνοτρόφος πτηνό
πτηνόσπιτο πτητικότης πτητικότητα πτι-φουρ πτιλοβόρα πτιλωτόν πτισάνη πτισμός
πτολεμαϊδιώτης πτυελοδοχείο πτυσμός πτυχή πτυχίο πτωμαΐνη πτωματοφαγία
πτωχαλαζόνας πτωχαλαζών πτωχεία πτωχοκομείο πτωχοπροδρομισμός πτωχοπρόδρομος
πτύξη πτύξις πτύχωση πτύχωσις πτώμα πτώση πτώσις πτώχευση πτώχευσις πυαιμία
πυγμάχος πυγμή πυγμαχία πυγολαμπίδα πυελίτιδα πυελίτις πυελογραφία
πυελοκυστίτις πυελοσκόπηση πυελοσκόπησις πυελοτομία πυθιονίκης πυθμένας πυθμήν
πυκνωτής πυκνόμετρο πυκνότης πυκνότητα πυλωρεκτομή πυλωρισμός πυλωρός πυλωτή
πυλώνας πυξάρι πυξίδα πυξιδοθήκη πυοσφαίριο πυουρία πυοφύτης πυρ πυρά πυράγρα
πυράκανθος πυράκτωση πυράκτωσις πυρέξ πυρέτιο πυρήν πυρήνα πυρήνας πυρίαμα
πυρίτιδα πυρίτιο πυρίτις πυραμίδα πυραμίδιο πυραμίς πυρανάφλεξη πυρανάφλεξις
πυρανεκτικότητα πυραντίσταση πυραντοχή πυρασφάλεια πυραυλάκατος
πυραυλομοντελισμός πυργάκι πυργί πυργίσκος πυργοδεσπότης πυργοκεφαλία
πυρείον πυρεξία πυρετάκος πυρετοθεραπεία πυρετολογία πυρετολόγος πυρετός
πυρηνελαιουργία πυρηνελαιουργείο πυρηνολυσία πυριδοξίνη πυριτιδαποθήκη
πυριτιδοποιείο πυριτιδοποιός πυριτιδόκονις πυριτοδόκη πυριτοδότης
πυριτόλιθος πυριφλεγέθων πυρκαγιά πυρκαϊά πυροβάτης πυροβάτισσα πυροβασία
πυροβολείο πυροβολητής πυροβολικό πυροβολισμός πυροβόληση πυροβόλησις πυροβόλο
πυροβόλον πυρογραφία πυροδιάσπαση πυροδιάσπασις πυροδότης πυροδότηση
πυροηλεκτρισμός πυροκλάνι πυροκρατήρας πυροκροτητής πυρολάτρης πυρολάτρισσα
πυρομάντης πυρομάντισσα πυρομαγνητισμός πυρομανής πυρομανία πυρομαντεία
πυρομεταλλουργία πυρομετρία πυρονίνη πυροπροστασία πυροσβέστης πυροσβεστήρ
πυροσβεστική πυροστάτης πυροστιά πυροσυσσωμάτωση πυροσωλήν πυροσωλήνας
πυροτέχνης πυροτεχνίτης πυροτεχνική πυροτεχνουργία πυροτεχνουργός πυροφάνι
πυροφραγμός πυροφόρος πυροφύλακας πυρπολητής πυρπολικό πυρπολικόν πυρπόληση
πυρρίχιος πυρσός πυρόλιθος πυρόλυση πυρόλυσις πυρόμαντις πυρόμετρο πυρόμετρον
πυρόσφαιρα πυρότουβλο πυτιά πυόρροια πφένιχ πωλήτρια πωλησιμότητα πωλητήριο
πωλητής πωμάτισμα πωματισμός πωπουδέλι πωπός πωρόλιθος πόα πόδας πόδεμα πόδημα
πόδισμα πόζα πόθος πόιντερ πόκα πόκερ πόκος πόλβερη πόλεμος πόλη πόλις
πόλιτσμαν πόλκα πόλντερ πόλο πόλος πόλωση πόλωσις πόμολο πόμπα πόμπεμα
πόμπευση πόμπευσις πόμπιασμα πόνεμα πόνεση πόνεϊ πόνημα πόνος πόντικας πόντιος
πόντιση πόντισμα πόντσο πόπαστο πόπολο πόρδος πόρεψη πόρθηση πόρθησις πόρισμα
πόρνος πόρος πόρπη πόρτα πόση πόσθη πόσις πόσουμ πόστα πόστερ πόστο πόταμος
πότης πότισμα πότος πότρια πότσα πύαρ πύελος πύθωνας πύκνωμα πύκνωση πύκνωσις
πύξος πύο πύον πύρα πύραρχος πύραυλος πύραυνον πύργος πύρωμα πύρωση πύρωσις
πώγων πώληση πώλησις πώλος πώμα πώρος πώρωση πώρωσις πῦρ ράβδισμα ράβδος
ράγα ράγισμα ράγκμπι ράγκπι ράδιο ράδιο ράδιο/δοκιμή ράδιο/δοκιμή2
ράδιο/δοκιμή2/δοκιμή2 ράδιο/δοκιμή2/δοκιμή2 ράδιο/δοκιμή2/δοκιμή2 ράισμα ράιχ
ράλι ράλληδες ράμμα ράμπα ράμφισμα ράμφος ράντζο ράντισμα ράντσο ράπα ράπερ
ράπτης ράσμπα ράσο ράσπα ράστερ ράτσα ράφι ράφτης ράφτινγκ ράφτρα ράχη ράψιμο
ρέγγα ρέγγος ρέγκα ρέγκε ρέγουλα ρέγουλο ρέζους ρέκασμα ρέκβιεμ ρέκορντμαν
ρέκτης ρέκτις ρέλι ρέλιασμα ρέμα ρέμβη ρέντα ρέντγκεν ρέπι ρέπιο ρέπλικα ρέπος
ρέφα ρέψιμο ρήγαινα ρήγας ρήγισσα ρήγμα ρήμα ρήμαγμα ρήμασμα ρήνιο ρήξη ρήση
ρήτορας ρήτρα ρήτωρ ρίγα ρίγανη ρίγος ρίγωμα ρίζα ρίζω ρίζωμα ρίμα ρίνα ρίνη
ρίνισμα ρίξιμο ρίπος ρίσκο ρίφι ρίχτι ρίψασπις ρίψη ρίψις ραέτι ραβέντι
ραβί ραβίνος ραβαΐσι ραβανί ραβασάκι ραββίνος ραβδάκι ραβδί ραβδίο ραβδιά
ραβδιστήρα ραβδιστήρι ραβδιστής ραβδομάντης ραβδομάχος ραβδομαντεία ραβδομαχία
ραβδοσκοπία ραβδοσκόπος ραβδοφανής ραβδούχος ραβδωτό ραβδόγραμμα ραβδόμαντις
ραβιόλια ραγάδα ραγάνι ραγιάς ραγιαδισμός ραγισματιά ραγοειδίτιδα ραγολόγημα
ραδίκι ραδιαισθησία ραδιαστρονομία ραδιατέρ ραδιενέργεια ραδικοβλάσταρο
ραδικοσαλάτα ραδικόζουμο ραδιοαστρονομία ραδιοβιολογία ραδιοβοήθημα
ραδιοβόλιση ραδιογαλαξίας ραδιογενετική ραδιογράφημα ραδιογράφηση ραδιογραφία
ραδιογωνιόμετρο ραδιοδέκτης ραδιοδέσμη ραδιοδίαυλος ραδιοδιάσπαση
ραδιοεντοπισμός ραδιοεντοπιστής ραδιοεπικοινωνία ραδιοεπισήμανση
ραδιοηλεκτρισμός ραδιοηλεκτρολογία ραδιοηλεκτρολόγος ραδιοηλεκτροτεχνία
ραδιοθεραπεία ραδιοκαίσιο ραδιοκασετόφωνο ραδιοκύματα ραδιολογία ραδιολόγος
ραδιομόλυβδος ραδιοναυτιλία ραδιονουκλίδιο ραδιοπάθεια ραδιοπειρατής
ραδιοπηγή ραδιοπικάπ ραδιοπλοήγηση ραδιοπομπός ραδιοπυξίδα ραδιοσκηνοθέτης
ραδιοσκοπία ραδιοσκόπηση ραδιοσταθμός ραδιοστοιχείο ραδιοσυμβολόμετρο
ραδιοτεχνία ραδιοτεχνική ραδιοτηλέγραφος ραδιοτηλέφωνο ραδιοτηλέφωνον
ραδιοτηλεγραφία ραδιοτηλεπικοινωνία ραδιοτηλεσκόπιο ραδιοτηλεφωνία
ραδιοτηλεόραση ραδιουργία ραδιοφάρμακο ραδιοφάρος ραδιοφωνάκι ραδιοφωνία
ραδιοχημεία ραδιοχρονολόγηση ραδιοϊσότοπα ραδιοϊσότοπο ραδιούργημα ραδιόφωνο
ραδόνιο ραδόνιον ραζακί ραθυμία ραθυμιά ραιβοκοιλοποδία ραιβοποδία ραιβοσκελία
ραιβόκρανο ραιβόκρανον ραιγιόν ραιτορομανικά ρακέτα ρακή ρακί ρακαριό ρακιά
ρακιτζοκάζανο ρακιτζό ρακλέτα ρακοκάζανο ρακομανδάριος ρακοπουλειό ρακοπωλείο
ρακοπότηρο ρακοπότης ρακοπώλης ρακοσυλλέκτης ρακοσυλλέκτις ρακοσυλλέκτρια
ρακόμελο ρακόρ ραλίστας ραμί ραμαζάνι ραμολής ραμολί ραμολίρισμα ραμολιμέντο
ραμφισμός ρανίδα ρανίς ρανιτιδίνη ραντάρ ραντίτσιο ραντεβουδάκι ραντεβού
ραντισμός ραντιστήρας ραντιστήρι ραντιτσιοσαλάτα ραξ ραπ ραπάνι ραπέλ ραπανάκι
ραπτική ραπτομηχανή ραπόρτο ρασιοναλισμός ρασιοναλιστής ρασκέτα ρασοφόρος
ρατσίστρια ρατσισμός ρατσιστής ραφή ραφίδα ραφανίδα ραφανίδωση ραφανίς ραφείο
ραφιέρα ραφιγράφος ραφιγραφία ραφιδογράφος ραφιδογραφία ραφινάρισμα ραφιναρία
ραφτάδικο ραφτάκι ραφτάκος ραφτικά ραφτική ραφτόπουλο ραχάτ λουκούμ ραχάτεμα
ραχάτι ραχίτιδα ραχίτις ραχατιλίκι ραχατλής ραχατλίκι ραχατλού ραχιαλγία
ραχοκοκαλιά ραχοκόκαλο ραχούλα ραψωδία ραψωδός ραϊσματιά ρε ρεΐσης ρεάλι
ρείθρο ρείκι ρεαλίστρια ρεαλισμός ρεαλιστής ρεαλπολιτίκ ρεβάνς ρεβένι ρεβέρ
ρεβίθι ρεβανί ρεβανσίστρια ρεβανσισμός ρεβανσιστής ρεβεγιόν ρεβεράντζα
ρεβιζιονισμός ρεβιζιονιστής ρεβιθάδα ρεβιθιά ρεβιθοκεφτές ρεβιθοκοτόσουπα
ρεβιθόσουπα ρεβόλβερ ρεγάλο ρεγκλάν ρεγουλάρισμα ρεγχασμός ρεζέρβα ρεζές
ρεζίλης ρεζίλι ρεζεντά ρεζερβουάρ ρεζιλίκι ρεζιοναλισμός ρεζισέρ ρεζουμέ
ρεικιά ρεκασμός ρεκλάμα ρεκλαμάρισμα ρεκλαμαδόρα ρεκλαμαδόρος ρεκλαματζής
ρεκτιφιέ ρεκόρ ρελάνς ρελέ ρελές ρελαντί ρελατιβισμός ρελιάστρα ρεμάλι ρεμέδιο
ρεμέντζο ρεμέτζο ρεματάκι ρεματιά ρεμβασμός ρεμεντζάρισμα ρεμετζάρισμα
ρεμιτζάρισμα ρεμούλα ρεμούλκα ρεμούρκιο ρεμπέτης ρεμπέτισσα ρεμπελιό ρεμπεσκές
ρενάρ ρεναγκούλα ρεντές ρεντίκολο ρεντιγκότα ρεντινγκότα ρεοστάτης
ρεπάνι ρεπανάκι ρεπανόσουπα ρεπεράζ ρεπερτουάρ ρεπερτόριο ρεπεσάζ ρεπετισιόν
ρεπλικάση ρεπορτάζ ρεπουλίνη ρεπουμπλικάνα ρεπουμπλικάνος ρεπουμπλικανισμός
ρεπουσιάδα ρεπούμπλικα ρεπρίζ ρεπροντιξιόν ρεπό ρεπόρτερ ρεσάλτο ρεσβερατρόλη
ρεσεψιόν ρεσιτάλ ρεσπέρης ρεστία ρεστοράν ρεσό ρετάλι ρετάρισμα ρετιγκότα
ρετουσάρισμα ρετούς ρετροϊός ρετρό ρετσέλι ρετσέτα ρετσίνα ρετσίνι ρετσινιά
ρετσιτατίβο ρευματαλγία ρευματικά ρευματισμός ρευματοβάση ρευματοδότης
ρευματολήπτης ρευματολογία ρευματολόγος ρευματοπάθεια ρευστοδυναμική
ρευστοποίηση ρευστό ρευστότητα ρεφενές ρεφερέντουμ ρεφλέ ρεφορμίστρια
ρεφορμιστής ρεφρέν ρεύμα ρεύση ρηγάτο ρηγμάτωση ρηγοπούλα ρηγόπουλο ρημάδα
ρημαδιό ρηματάκι ρημοκλήσι ρηξικελευθότητα ρητίνευση ρητίνη ρητίνωση
ρητινίτης ρητινεργάτης ρητινοκαλλιέργεια ρητινοκαλλιεργητής ρητινοσυλλέκτης
ρητινόλασπη ρητινόπισσα ρητορεία ρητορισμός ρητοριότητα ρητό ρηχία ριάλι
ριβοφλαβίνη ριβόσωμα ριγανάτο ριγανόλαδο ριγοπίνελο ριζά ριζάρι ριζάφτι
ριζίδιον ριζίτης ριζίτισσα ριζικάρι ριζικό ριζοβούνι ριζοβράχι ριζοβόλημα
ριζοδόντι ριζολόγημα ριζονευρίτιδα ριζονευρίτις ριζοσπάστης ριζοσπάστρια
ριζοσπαστικός ριζοσπαστικότητα ριζοσπαστισμός ριζοφυΐα ριζοχώρι ριζόβραχο
ρικετσίωση ριμάριο ριμάτα ριμέικ ριμαδόρος ριμπάουντ ρινί ρινίδι ρινίτιδα
ρινισμός ρινιστήρι ρινιστής ρινοδέλφινο ρινολαλία ρινολαλιά ρινολογία
ρινοπλαστική ρινορραγία ρινοσκόπηση ρινοσκόπιο ρινοσκόπιον ρινοφάρυγγας
ρινοφαρυγγίτιδα ρινοφωνία ρινοψία ριντό ρινόκερος ρινόκερως ρινόλιθος
ρινόρροια ριξιά ριπή ριπίδι ριπολίνη ριπτασμός ρις ριτιράτα ριφιφί ριχτάρι ρο
ροή ροβίθι ροβιθιά ροβόλημα ροβόλισμα ροδάδα ροδάκινο ροδάμι ροδάμυλο ροδάνι
ροδάριο ροδάς ροδέλα ροδέλαιο ροδέλας ροδή ροδίτης ροδίτης ροδακινέλαιο
ροδακινοπαραγωγή ροδοήτης ροδοδάφνη ροδοζάχαρη ροδοκοκκίνισμα ροδοπέταλο
ροδοπελεκάνος ροδοστέφανο ροδοστέφανος ροδωνιά ροδόδεντρο ροδόκηπος ροδόμελι
ροδόξιδο ροδόξυλο ροδόπλεκτο ροδόσταγμα ροδόσταμα ροδόσταμο ροδότοπος ροδώνας
ροζάριο ροζέ ροζέτα ροζακί ροζοπάλινη ροιά ροιάς ροκ ροκ εντ ρολ ροκάνα ροκάνι
ροκάς ροκέ ροκαμπίλι ροκανάς ροκανίδι ροκιά ροκοκό ροκφόρ ροκόλα ρολίνα
ρολογάκι ρολογάς ρολό ρολόι ρομ ρομά ρομάντζα ρομάντζο ρομάτζι ρομανέσκο
ρομανικές γλώσσες ρομαντζάδα ρομαντικότητα ρομαντισμός ρομβία ρομπατσίνα
ρομπόλα ρομπότ ρομφαία ρονιά ροντέο ροντό ροξατιδίνη ροογράφημα ροογράφος
ροπή ροπαλάκι ροπαλιά ροπογεννήτρια ροσμαρί ροσμαρίνι ροσμπίφ ροσόλι ροτόντα
ρουβίδιο ρουβίδιον ρουζ ρουθήνιο ρουθηνικά ρουθουνισμός ρουθούνι ρουθούνισμα
ρουκετοπόλεμος ρουλέτα ρουλεμάν ρουλό ρουλότα ρουμάνι ρουμάνικα ρουμάνος
ρουμελιώτης ρουμελιώτικα ρουμελιώτισσα ρουμπίζω ρουμπίνι ρουμπαγιάτ ρουμπινές
ρουπάκι ρουπία ρουπακιά ρους ρουστίκ ρουσφέτι ρουσφετολογία ρουσφετολόγα
ρουτίνα ρουτινοποίηση ρουφήχτρα ρουφηγματιά ρουφηξιά ρουφιάνα ρουφιάνος
ρουφοκαυλέτα ρουχαλάκι ρουχικό ρουχισμός ροφός ροχάλα ροχάλισμα ροχαλητό
ροϊκός ροϊκότητα ροόμετρο ροόμετρον ρούβλι ρούγα ρούμι ρούμπα ρούμπος ρούνοι
ρούστικο ρούτερ ρούφηγμα ρούφι ρούφουλας ρούχο ρυάκι ρυάσιμο ρυζάκι ρυζάλευρο
ρυζοκαλλιέργεια ρυζοκροκέτα ρυζοφυτεία ρυζόγαλο ρυζόνερο ρυζόσουπα ρυθμαπόδοση
ρυθμικότητα ρυθμιστήρ ρυθμιστήρας ρυθμολογία ρυθμολογικός ρυθμολόγος ρυθμός
ρυκάνησις ρυκάνισμα ρυμοτομία ρυμοτόμος ρυμουλκατζής ρυμουλκό ρυμουλκόν
ρυμούλκηση ρυμούλκιο ρυπαντής ρυπαρογράφημα ρυπαρογράφος ρυπαρογραφία
ρυπαρότητα ρυτήρ ρυτίδα ρυτίδωμα ρυτίδωση ρυτίδωσις ρυτίς ρυτιδεκτομή ρυτό
ρω ρωγμάτωση ρωγμή ρωγμόμετρο ρωγοβύζι ρωδιός ρωμαίικο ρωμαίος ρωμαιοκρατία
ρωμανιώτης ρωμανιώτισσα ρωμαντικότης ρωμαντισμός ρωμαϊκό ρωμαϊστής ρωμηός
ρωμιός ρωπογράφος ρωπογραφία ρωποπωλείον ρωσίδα ρωσικά ρωσομάθεια ρωσοπόντια
ρόβολος ρόγα ρόγχος ρόδα ρόδακας ρόδι ρόδιο ρόδισμα ρόδο ρόζιασμα ρόζος ρόιδι
ρόκα ρόκολος ρόλεϊ ρόλος ρόμβος ρόμπα ρόμπας ρόνια ρόπαλον ρόπτρο ρόπτρον
ρότα ρότορας ρότσα ρόφημα ρόφηση ρόχαλο ρόχθος ρύαξ ρύγχος ρύζι ρύθμιση
ρύμη ρύπανση ρύπανσις ρύπος ρύση ρύσις ρώγα ρώθων ρώμη ρώμι ρώσικα ρώσος
ρῆξις σάβανο σάβανον σάββατο του λαζάρου σάγια σάγισμα σάγμα σάγουλα σάζι
σάιτ σάκα σάκε σάκευση σάκιασμα σάκκος σάκος σάκχαρις σάκχαρο σάλα σάλαγο
σάλεμα σάλι σάλιαγκας σάλιο σάλιωμα σάλος σάλπη σάλπιγγα σάλπιγξ σάλπισμα
σάλτο σάλτσα σάμαλι σάμισεν σάμπα σάνταλο σάντολος σάντουιτς σάουνα σάπισμα
σάπων σάρα σάρακας σάρισα σάρισμα σάρκα σάρκωμα σάρκωση σάρκωσις σάρπα σάρωθρο
σάρωση σάρωσις σάστισμα σάτζιη σάτινα σάτιρα σάτυρος σάχης σάχλα σάχλας σάψαλο
σέγα σέκι σέκτα σέλα σέλας σέλινο σέλλα σέλμα σέλφι σέλωμα σέμνωμα σέμπρος
σέντερ φορ σέντρα σέντσι σέπαλο σέπια σέρα σέρβερ σέρβικα σέρβις σέρβος σέρτης
σέρφερ σέρφιγκ σέρφινγκ σέσκλο σέσκουλο σέσουλα σέστο σέτερ σέχτα σήκωμα
σήμα σήμανση σήμανσις σήμαντρο σήμαντρον σήμερα σήραγγα σήραγξ σήριαλ σήσαμον
σήψη σήψις σίαλος σίβυλλα σίγηση σίγμα σίδερο σίδηρος σίελος σίκαλη σίκλα
σίκυς σίμωμα σίντο σίολ σίριαλ σίτεμα σίτευση σίτευσις σίτιση σίτος σίφουνας
σίφωνας σίχαμα σαΐνης σαΐνι σαΐτα σαΐτεμα σαβάνα σαβάνωμα σαβαγιάρ σαβανωτής
σαβανώτρια σαβαρέν σαββατιανό σαββατικός τράγος σαββατοκύριακο σαββατόβραδο
σαβουρομηχανή σαβούρα σαβούρωμα σαβόρε σαβόρι σαβόρο σαγάνι σαγή σαγήνευμα
σαγήνευσις σαγήνη σαγανάκι σαγηνευτής σαγηνεύτρα σαγηνεύτρια σαγιάκι σαγιάς
σαγκουίνι σαγκρία σαγκριώτης σαγκριώτισσα σαγματοποιία σαγματοποιείο
σαγματοποιός σαγματοπωλείο σαγματοπωλείον σαγματοπώλης σαγονάς σαγονιά σαγονού
σαγρέ σαγρές σαγόνι σαδίστρια σαδδουκαίος σαδισμός σαδιστής σαδομαζοχίστρια
σαδομαζοχιστής σαζάνι σαηεντολογία σαηεντολόγος σαθρότης σαθρότητα σαιζλόνγκ
σαικσπηριστής σαιξπηριστής σακ βουαγιάζ σακάκι σακάς σακάτεμα σακάτης
σακέ σακί σακίδιο σακαράκα σακαράκας σακατιλίκι σακελάριος σακελλάριος
σακκογκόλιθος σακκοράφος σακκόφιλτρο σακοβελόνα σακογκόλιθος σακολέβα σακοράφα
σακουλές σακουλίτσα σακούλα σακούλι σακούλιασμα σακχαρίνη σακχαραιμία
σακχαροδιαβήτης σακχαροκάλαμον σακχαρομετρία σακχαρομηκητίαση
σακχαρομύκης σακχαρομύκητας σακχαροποίηση σακχαροποίησις σακχαροποιία
σακχαρόμετρον σακχαρόπηκτο σακχαρόπηκτον σακχαρότευτλον σαλάδο σαλάμι σαλάτα
σαλέ σαλέπι σαλίγκαρος σαλαβάτι σαλαμάνδρα σαλαμάντρα σαλαμάστρα σαλαμετλίκια
σαλαμοποίηση σαλαμούρα σαλατιέρα σαλατικό σαλαφίστρια σαλαφισμός σαλαφιστής
σαλεπιτζήδικο σαλεπιτζής σαλεπιτζίδικο σαλιάρα σαλιάρισμα σαλιέρα
σαλιαρίστρα σαλιγκάρι σαλιγκαράκι σαλμί σαλμονέλα σαλμονέλλα σαλμονέλλωσις
σαλοπέτα σαλοτραπεζαρία σαλούν σαλπάρισμα σαλπιγγίτιδα σαλπιγγίτις
σαλπιγκτής σαλτάρισμα σαλταδόρος σαλτιμπάγκος σαλτσιέρα σαλόνι σαμάν σαμάνος
σαμάριο σαμάρωμα σαμανισμός σαμαράδικο σαμαράκι σαμαράς σαμαρακατρανέμια
σαμαρείτισσα σαμαροσκούτι σαμαρσκίτης σαμαρτζής σαματάς σαματατζής σαματατζού
σαμιαμίθι σαμιώτης σαμιώτισσα σαμντάνι σαμοανικά σαμοανός σαμοβάρι σαμογιτιανά
σαμοθρακιώτης σαμουράι σαμούρι σαμπάνι σαμπάνια σαμπάνιασμα σαμπάνιο σαμπάχ
σαμπανιά σαμπανιέρα σαμπαχαδάκι σαμπλέ σαμπλεδάκι σαμποτάζ σαμποτάρισμα
σαμπουάν σαμπούκα σαμπούκος σαμπρ σαμπρέλα σαμπό σαμόλαδο σαμόσα σανίδα σανίδι
σανίδωση σανίδωσις σανίς σανατόριο σανδάλι σανδαλοποιείο σανδαλοποιός
σανιδάς σανιδόδεσμος σανιδόσκαλα σανοπωλείο σανοπωλείον σανοπώλης σανσκριτικά
σανσκριτολόγος σαντάλι σαντακρούτα σανταλόξυλο σαντζάκι σαντζάκιο σαντιγί
σαντορινιός σαντουιτσάδικο σαντουιτσάκι σαντούρι σανφασονισμός σανό σανός σαξ
σαξοφωνίστας σαξοφωνίστρια σαξόκερας σαξόφωνο σαπάκι σαπέλι σαπίλα σαπίτης
σαπιοκάραβο σαπιολέμονο σαποκώλιασμα σαπουνάδα σαπουνάδικο σαπουνάς
σαπουνόνερο σαπουνόπερα σαπουνόπετρα σαπουνόφουσκα σαπουνόχορτο σαπουνόχωμα
σαπούνισμα σαπρία σαπρότης σαπρόφιλα σαπρόφυτα σαπρόφυτο σαπφισμός σαπωνίνες
σαπωναρία σαπωνομάζα σαπωνοποίηση σαπωνοποίησις σαπωνοποιία σαπωνοποιείο
σαπωνόλιθος σαράβαλο σαράγι σαράι σαράκι σαράκιασμα σαράντα σαράντισμα
σαράφης σαράφικο σαράφισσα σαρία σαρίδι σαρίκι σαραβάλιασμα σαραβαλάκι
σαρακατσάνοι σαρακατσαναίοι σαρακοστή σαρακοστιανά σαρακοφάγωμα σαραντάδα
σαραντάρα σαραντάρης σαραντάρι σαραντάχρονα σαρανταήμερο σαρανταλείτουργο
σαρανταποδαρούσα σαρανταριά σαραφιάτικα σαραφλίκι σαργός σαρδάμ σαρδέλα
σαρδελοβάρελο σαρδελοκούτι σαρδηνιακά σαρδόνυξ σαρικοπιτάκι σαριό σαρκίδιο
σαρκασμός σαρκαστής σαρκογομφίος σαρκοείδωση σαρκομύξωμα σαρκοστέωση
σαρκοφάγα σαρκοφάγος σαρκοφαγία σαρκοφυΐα σαρκωμάτωση σαρκωμάτωσις σαρμάκο
σαρμαδάκι σαρμανίτσα σαρξ σαρσέλα σαρωτής σασί σασίμι σασμάν σασπένς σαστιμάρα
σατέν σατίρι σατακρούτα σατανάς σατανικότης σατανικότητα σατανισμός σατανιστής
σατινέτα σατιρισμός σατιρογράφος σατιρογραφία σατράπης σατράπισσα σατραπίσκος
σατραπισμός σατυρίαση σατυρίασις σαυράκι σαυρίδι σαυρίτσα σαυροειδή σαφάρι
σαφήνιση σαφήνισις σαφράν σαφράνι σαφρίδι σαχ σαχάνι σαχλίτσα σαχλαμάρα
σαχλαμαρίτσα σαχλαμπούχλα σαχλαμπούχλας σαχλόμαγκας σαχνισί σαχνισίνι
σαϊεντολογία σαϊεντολόγος σαϊτευτής σαϊτεύτρια σαϊτιά σαϊτοθήκη σαϊτοπόλεμος
σβάρα σβάρνα σβάρνισμα σβάστικα σβέρκο σβέρκος σβέση σβήσιμο σβήστρα σβίγα
σβανάρισμα σβαρνιάρα σβαρνιάρης σβελτάδα σβελτοσύνη σβερκιά σβησιματιά
σβηστήρας σβηστήρι σβουνιά σβουράκι σβουριχτή σβούρα σβούρισμα σβωλάκι
σβόλιασμα σβόλος σβόμπος σβώλιασμα σβώλος σγουμπός σεΐζης σεΐχης σείσιμο
σείστρο σεβάσματα σεβασμιότατος σεβασμιότητα σεβασμιώτατος σεβασμός
σεβαστοκράτορας σεβαστοκράτωρ σεβαστοκρατόρισσα σεβιότ σεβντάς σεβνταλής
σεβρό σεγκούνα σεγκούνι σεγκόντο σεζλόνγκ σεζόν σειρά σειράριθμος σειρήνα
σειριά σεισάχθεια σεισμικότητα σεισμογράφημα σεισμογράφος σεισμογραφία
σεισμολογία σεισμολόγος σεισμομετρία σεισμοσκόπιο σεισμόγραμμα σεισμόμετρο
σεισοπυγίς σεκιουριτάς σεκλέτι σεκρετάριος σεκρετέρ σεκταρισμός σεκόγια
σελάγισμα σελάδικο σελάς σελέμης σελέμισσα σελήνη σελήνιο σελίδα σελίδωμα
σελίνι σελαγισμός σελαμλίκι σεληνάκατος σεληνιασμός σεληνογράφος σεληνογραφία
σεληνοτοπογραφία σεληνοτροπισμός σεληνόφως σεληνόφωτο σελιδαρίθμηση
σελιδοδείκτης σελιδοδείχτης σελιδοθέτης σελιδοποίηση σελιδοσήμανση σελιλόιντ
σελινόριζα σελινόσουπα σελοποιείο σελοποιός σελοτέιπ σελοφάν σελτές σελτεδάκι
σελφίτιδα σεμέ σεμέν σεμέν ντε φερ σεμές σεμίδαλις σεμεδάκι σεμιγδάλι σεμιζιέ
σεμνολογία σεμνοπρέπεια σεμνοτυφία σεμνότητα σεμπουάνο σεμπροπούλα σενάζι
σενίλ σεναριογράφος σεναριογραφία σεναριολογία σενεγαλέζος σενιόρα σενσέι
σεντ σεντέφι σεντίνα σεντονόπανο σεντούκι σεντράρισμα σεντόνι σεντόνιασμα σεξ
σεξαπίλ σεξισμός σεξιστής σεξοθεραπεία σεξοθεραπευτής σεξολογία σεξολόγος
σεξοπατζής σεξοπατζού σεξοπού σεξουαλικότητα σεξουαλισμός σεξουλιάρης
σεξυπνία σεπαρέ σεπτέτο σεπτεμβριανά σερ σεράγι σεράι σερέτης σερέτισσα
σερίνη σερίφης σερασκέρης σεραφίμ σερβάν σερβάντα σερβί σερβίρισμα σερβίς
σερβιέτα σερβικά σερβιτόρα σερβιτόρισσα σερβιτόρος σερβοκίνηση σερβοκροάτικα
σερβομοτέρ σεργιάνι σερενάδα σερενάτα σερετιά σερετιλίκι σερζ σεριάνι
σεριφιώτισσα σερμαγιά σερμπέτι σερνικοβότανο σεροτονίνη σερπαντίνα
σερπετάδα σερραίος σερσέμα σερσέμισσα σερσένι σερσερής σερτζής σερφ σερφάρισμα
σεστέτο σετ σεφ σεφ πατισιέ σεφέρι σεφερτάσι σεφτές σεφταλιά σεχταρισμός σεχόλ
σηκωμός σηκός σημάδεμα σημάδι σημάτιον σημαία σημαίνον σημαδάκι σημαδευτής
σημαινόμενο σημαιολογία σημαιολόγος σημαιοστολισμός σημαιοφόρος σημαντήρ
σημαντικότης σημαντικότητα σημασία σημασιολογία σημασιολόγηση σηματοδότης
σηματοδότησις σηματολογία σηματολόγηση σηματολόγησις σηματολόγιο σηματολόγιον
σημείο σημείον σημείωμα σημείωση σημείωσις σημειακότητα σημειογραφία
σημειολογία σημειολόγος σημειοσειρά σημειοσύνολο σημειωματάκι σημειωματάριο
σημειωτέον σημειωτική σημειωτόν σημειόγραμμα σημειώσεις σημιτάνθρωπος
σημύδα σηπία σηπεδών σηπτίνη σηπτικότης σηπτικότητα σηρ σηροτροφία σηροτροφείο
σηροτρόφος σησάμη σησάμι σησαμέλαιο σησαμέλαιον σησαμιά σησαμοπολτός
σησαμόπολτος σηψίνη σηψαιμία σηψιρριζία σθένος σθεναρότης σθεναρότητα σι σιάδι
σιάξιμο σιέλ σιέλωση σιέστα σιίτης σιαγόνα σιακατούρι σιαλαδενίτιδα
σιαλόρροια σιαμέζα σιαμέζικα σιαμέζος σιαπέρας σιβέτ σιγάρο σιγάρον σιγή
σιγίλλιον σιγαλιά σιγανοπαπαδιά σιγανοψιχάλα σιγανοψιχάλισμα σιγαρέτο
σιγαροθήκη σιγαροποιία σιγαροποιείο σιγαροποιείον σιγαροποιός σιγαστήρ
σιγκούνα σιγκούνι σιγματισμός σιγμός σιγοντάρισμα σιγουράδα σιγουράντζα
σιγουριά σιγούρεμα σιγόντο σιδέρωμα σιδεράδικο σιδεράκι σιδεράκια σιδεράς
σιδεριά σιδερικό σιδερογωνιά σιδερομετάλλευμα σιδεροπρίονο σιδεροστιά
σιδερωτής σιδερόδρομος σιδερόπανο σιδερόχορτο σιδερώστρα σιδερώτρα σιδερώτρια
σιδηροβιομήχανος σιδηροβιομηχανία σιδηρογραφία σιδηρογροθιά σιδηροδοκός
σιδηροκατασκευή σιδηρομεταλλουργία σιδηρονικέλιο σιδηροπενία σιδηροπυρίτης
σιδηροπώλης σιδηροσύντηξη σιδηροτεχνία σιδηροτροχιά σιδηρουλικό σιδηρουργία
σιδηρουργείον σιδηρουργική σιδηρουργός σιδηροχρώμιο σιδηρωρυχείο σιδηρωτήριον
σιδηρόκραμα σιδηρόστοκος σιδηρόστρωση σιελ σιελόρροια σιενίτης σιζαλόσχοινο
σικινιώτης σικλέτι σικλαμέν σικορέ σικορεσαλάτα σικυός σικύα σιλανσιέ σιλικόνη
σιλό σιμίτης σιμίτι σιμετιδίνη σιμιγδάλι σιμιγδαλομηχανή σιμιγδαλόσουπα
σιμιτεργάτρια σιμιτζής σιμούν σιμωνία σιμωνιακά σιμότητα σινάπι σινάφι
σινί σινίκι σιναλεζικά σιναλεζική σιναμική σιναπάλευρο σιναπάλευρον σιναπέλαιο
σιναπισμός σιναποβλάσταρο σιναπόσπορος σινδόνιον σινδών σινεμά σινεμασκόπ
σινιάλο σινιορίνα σινιόν σινιόρ σινιόρα σινολογία σινολόγος σινουά σιντέφι
σιντριβάνι σινχάλα σιορ σιρίτι σιργιάνι σιρκουΐ σιρκουί σιρμαγιά
σιρόκος σιρόπι σιρόπιασμα σιρός σισανές σισπανσιόν σισύρα σιτάκα σιτάλευρο
σιτάρ σιτάρι σιτάρκεια σιτέλαιο σιτέμπορος σιταγωγία σιταγωγός σιταποθήκη
σιταρέμπορος σιταρήθρα σιταρόσουπα σιταρόσπορο σιταρόσπορος σιταρότοπος
σιτεμπόριο σιτεμπόριον σιτζίμι σιτηρά σιτηρέσιο σιτιοδόχη σιτισμός σιτιστής
σιτοβολώνας σιτοδεία σιτοκαλλιέργεια σιτοπαραγωγή σιτοπαραγωγός σιτοφύλακας
σιφνιώτισσα σιφονιέρα σιφούνι σιφωνιάτης σιφωνιάτισσα σιφόν σιφόνι σιφώνιο
σιχαμάρα σιχαμός σιχασιά σιχτίρι σιχτίρισμα σιωνίστρια σιωνισμός σιωνιστής
σιωπηλότης σιωπηλότητα σιωπητήριο σιωπητήριον σιόρα σκάγι σκάι σκάκι σκάλα
σκάλος σκάλπερ σκάλωμα σκάμμα σκάνδαλο σκάνδιο σκάνταλο σκάντζα σκάρα σκάρος
σκάρωμα σκάση σκάσιμο σκάτωμα σκάφανδρο σκάφανδρον σκάφη σκάφος σκάψιμο
σκέδαση σκέιτμπορντ σκέλεθρο σκέλια σκέλος σκένδαμος σκέπασμα σκέπαστρο
σκέπη σκέρτσο σκέψη σκέψις σκήνωμα σκήπτρο σκήπτρον σκήτη σκίαση σκίασμα
σκίζα σκίμπους σκίνο σκίνος σκίουρος σκίρο σκίρτημα σκίρων σκίσιμο σκίτσο
σκαδιώτισσα σκαθάρι σκαιότης σκαιότητα σκακίστρια σκακιέρα σκακιστής
σκαλάκι σκαλέτα σκαλί σκαλικάτζαρος σκαλιστήρι σκαλιστής σκαλιώτης σκαλμίσκος
σκαλμός σκαλοπάτι σκαλοπόδαρο σκαλπ σκαλτσούνι σκαλωσιά σκαμιά σκαμνάκι σκαμνί
σκαμπίλι σκαμπαβία σκαμπανέβασμα σκαμπό σκανδάλη σκανδαλιά σκανδαλισμός
σκανδαλοθηρία σκανδαλολογία σκανδιναβή σκανδιναβός σκανδιναβός σκαντάγιο
σκανταλιά σκαντζόχοιρος σκαπάνη σκαπέτισμα σκαπανέας σκαπανικό σκαπουλάρισμα
σκαρίφημα σκαραβαίος σκαριφησμός σκαριφισμός σκαρλατίνα σκαρμούτσο σκαρμός
σκαρπίνι σκαρτάδα σκαρτάδος σκαρτάρισμα σκαρταδούρα σκαρφάλωμα σκαρφιστήρας
σκασιά σκασιάρχης σκασιαρχείο σκασιματιά σκασμός σκατάς σκατίλα σκατζιά σκατιά
σκατολογία σκατολόημα σκατομαλάκας σκατουλάκι σκατουλί σκατοφαγία σκατοψυχία
σκατούλικο σκατό σκατόγρια σκατόκαιρος σκατόμυγα σκατόπαιδο σκατόστομα
σκατόφλωρος σκαφάκι σκαφέας σκαφή σκαφίδι σκαφίδιασμα σκαφίδιον σκαφίδωμα
σκεδασμός σκεδαστήρας σκελέα σκελίδα σκελίδι σκελίς σκελαλγία σκελετά
σκελετολογία σκελετός σκελετόσαυρος σκεμπές σκεπάρνι σκεπάρνισμα σκεπή
σκεπαστή σκεπαστήρι σκεπτικίστρια σκεπτικισμός σκεπτικιστής σκεπτικό σκεπτικόν
σκεπτικότητα σκερβελές σκερτσάκι σκετς σκετσάκι σκευάμαξα σκευή σκευαγωγία
σκευοβασία σκευοθήκη σκευομορφισμός σκευοφυλάκιο σκευοφυλάκιον σκευοφόρος
σκευοφύλαξ σκευωρία σκευωρός σκεύασμα σκεύος σκηνή σκηνίτης σκηνίτις
σκηνικό σκηνογράφος σκηνογραφία σκηνοθέτης σκηνοθέτιδα σκηνοθέτις σκηνοθέτρια
σκηνοπηγία σκηνοποιία σκηνοποιός σκηνορράφος σκηνορραφία σκηνοφύλακας
σκηπτουχία σκητιώτης σκι σκιά σκιάγραμμα σκιάδα σκιάδι σκιάδιον σκιάξιμο σκιάς
σκιάχτρο σκιέρ σκιαγράφημα σκιαγράφηση σκιαγραφία σκιαδανθή σκιαμαχία σκιασμός
σκινόχωμα σκιοσκόπιο σκιουράκι σκιοφιλία σκιοφοβία σκιοφωτισμός σκισιματιά
σκισμή σκιτζής σκιτσάρισμα σκιτσογράφος σκιόφως σκλάβα σκλάβος σκλάβωμα
σκλήρισμα σκλήρυνση σκλήρυνσις σκλήρωμα σκλήρωση σκλαβάκι σκλαβάκια σκλαβέρι
σκλαβιά σκλαβοπάζαρο σκλαβόπουλο σκληράδα σκληρία σκληρίαση σκληρίτιδα
σκληραγώγηση σκληρεκτασία σκληριά σκληροδακτυλία σκληροδερμία σκληροθεραπεία
σκληροκερατίτιδα σκληροκερατίτις σκληροκεφαλιά σκληρομετρία σκληροπάθεια
σκληροστένωσις σκληροφυλλία σκληρωνυχία σκληρόλυση σκληρόλυσις σκληρόμετρο
σκληρότης σκληρότητα σκλόπα σκνίπα σκοινάκι σκοινάς σκοινί σκολίωση
σκολειαρόπαιδο σκολειό σκολιαρούδι σκολιαρόπαιδο σκολιός σκολιότης σκολιότητα
σκολόπαξ σκολόπενδρα σκολόπεντρα σκολύμπρι σκομβρίον σκομινιά σκονάκι
σκοπελίτης σκοπευτήριο σκοπευτήριον σκοπευτής σκοπεύτρια σκοπιά σκοπιμότης
σκοπιωρός σκοποβολή σκοποθεσία σκοπούμενον σκοπός σκορ σκοράρισμα σκορβούτο
σκορδέλαιο σκορδέλαιον σκορδίλα σκορδαλιά σκορδοκαΐλα σκορδοπλεξίδα
σκορδοστούμπι σκορδοφάγος σκορδοφαγία σκορδούλα σκορδόξιδο σκοροφάγωμα
σκορπίνα σκορπίος σκορπαλευράς σκορπαλευρού σκορπιδόχορτο σκορπιός σκορποχέρα
σκορποχώρι σκοτάδι σκοτία σκοτίδι σκοτίδιασμα σκοταδισμός σκοταδιστής
σκοτείνια σκοτείνιασμα σκοτεινάγρα σκοτεινάδα σκοτεινή ύλη σκοτεινιά
σκοτεινότητα σκοτικά σκοτισμάρα σκοτισμός σκοτοδίνη σκοτοδινία σκοτοδινίασις
σκοτούρα σκοτσέζικα σκοτσέζος σκοτωμός σκοτώστρα σκουλήκι σκουλί σκουλαμέντο
σκουληκάκι σκουληκαντέρα σκουληκομερμηγκότρυπα σκουληκομυρμηγκότρυπα
σκουληκότρυπα σκουληκόψαρο σκουμπρί σκουνιέρης σκουντιά σκουντούφλα
σκουντούφλιασμα σκουπάκι σκουπίδι σκουπίδια σκουπιδάκι σκουπιδαριό σκουπιδιάρα
σκουπιδιάρικο σκουπιδομάνι σκουπιδοντενεκές σκουπιδοτενεκές σκουπιδότοπος
σκουπόσπορος σκουπόχορτο σκουράντζος σκουρέτο σκουριά σκουρόχρωση σκουσμάρι
σκουτάριον σκουτέλα σκουτέλι σκουτί σκουφάκι σκουφί σκουφίτσα σκουός σκούδο
σκούλλος σκούνα σκούντημα σκούξιμο σκούπα σκούπισμα σκούρα σκούριασμα σκούτερ
σκούφια σκούφος σκούφωμα σκράπας σκρίνιο σκρίνιον σκραπ σκριβάνος σκριβάς
σκριπτάκι σκροφάκι σκροφίτσα σκρόφα σκυθρωπότης σκυθρωπότητα σκυλάδικο σκυλάκι
σκυλί σκυλίτσα σκυλοδρομία σκυλοκαβγάς σκυλοκλάμα σκυλολόι σκυλοπνίχτης
σκυλοτροφή σκυλού σκυλόβρισμα σκυλόδοντο σκυλόμουτρο σκυλόψαρο σκυριανός
σκυριδωρύχος σκυριδόκονις σκυρμιόνιο σκυροδέτηση σκυροκονίαμα σκυρόδεμα
σκυρόδεσις σκυρόστρωμα σκυρόστρωση σκυρόστρωσις σκυτάλη σκυταλοδρομία
σκυτοτόμος σκωλήκιον σκωληκίασις σκωληκοειδίτιδα σκωληκοειδίτις
σκωρία σκωρίαση σκωρίασις σκωραμίδα σκωτικά σκωτσέζικα σκωτσέζος σκωψ σκόλασμα
σκόλοψ σκόλυμπρος σκόμβρος σκόνη σκόνισμα σκόνταμμα σκόντο σκόπελος σκόπευση
σκόρδο σκόρδον σκόρερ σκόροδον σκόρος σκόρπαινα σκόρπισμα σκόρσο σκότα σκότη
σκότισις σκότισμα σκότος σκότωμα σκύβαλο σκύβαλον σκύλα σκύλαξ σκύλευση
σκύλον σκύλος σκύμνος σκύρα σκύρο σκύτος σκύψιμο σκώληξ σκώμμα σκώτι σλάβος
σλάλομ σλέπι σλίπιν-μπαγκ σλίπινγκ-μπαγκ σλαβισμός σλαβογραφή σλαβοκρατία
σλαβομακεδονικά σλαβοφιλία σλαυολόγος σλαυϊσμός σλαϊτσιέρα σλιπάκι σλοβάκος
σλοβακικά σλοβενικά σλόγκαν σμάλτο σμάλτωμα σμάλτωση σμάλτωσις σμάρι σμάρτφον
σμέρνα σμήγμα σμήναρχος σμήνος σμίκρυνση σμίκρυνσις σμίλαξ σμίλευμα σμίλευση
σμίλη σμίξιμο σμαράγδι σμαρίδα σμαραγδίτης σμεουρέλαιο σμεουριά σμερδάκι
σμηγματόρροια σμηνίας σμηνίτης σμηνίτισσα σμηναγός σμηναρχία σμηνοσεισμοί
σμιγάδι σμιγός σμιλάρι σμιρίγλι σμιχτοφρύδα σμούλα σμπάρος σμπίρος σμπαράλια
σμυρίγλι σμυρίδα σμυριγλάς σμυριδαποθήκη σμυριδεργάτης σμυριδορυχείο
σμυριδοσωρός σμυριδοτροχός σμυριδοφύλακας σμυριδωρυχείον σμυριδόκαδος
σμυριδόπετρα σμυριδόσκαλα σμυριδόσκονη σμυριδόχαρτο σμυριδόχαρτον σμυρνιός
σμόκιν σμύρη σμύριδα σμύρις σμύρνα σνίτσελ σνίχι σνομπάρισμα σνομπίστρια
σνομπισμός σνομπιστής σοβάντισμα σοβάς σοβάτισμα σοβαροφάνεια σοβαρότης
σοβατεπί σοβατζής σοβιέτ σοβιετισμός σοβιετολογία σοβινίστρια σοβινισμός
σοβχόζ σογιάλευρο σογιάλευρον σογιέλαιο σογιέλαιον σογκούν σοδειά σοδομία
σοδομίτης σοδομισμός σοδομιστής σοκ σοκάκι σοκάρισμα σοκακάς σοκακού
σοκολάτα σοκολατάκι σοκολατίνα σοκολατίτσα σοκολατοποιία σοκολατοφαγία
σοκολατόπαιδο σοκοφρέτα σολ σολάριουμ σολέα σολέας σολίστ σολίστας σολανίνη
σολδίο σολινταρισμός σολιψισμός σολοικισμός σολομομαρουλοσαλάτα σολομωνική
σολφέζ σολωμιστής σολόδερμα σομακί σομαλικά σομαλός σομιέ σομιές σομπίτσα
σομφότης σομόν σονάρ σονάρισμα σονάτα σονέτο σονέττο σοουγούμαν σοουμπίζ
σορβιά σορβικά σορμπέ σοροκάδα σοροκολεβάντες σορολόπ σορολόπι σορτ σορτάκι
σορτς σορτσάκι σορόκος σορόπι σορόπιασμα σορός σοσιαλίστρια σοσιαλδημοκράτης
σοσιαλδημοκράτισσα σοσιαλδημοκρατία σοσιαλισμός σοσιαλιστής σοσονάκι σοσόνι
σοτέ σοτοβέντο σουάζι σουέτ σουίτα σουαρέ σουαχίλι σουβάλα σουβάς σουβέρ
σουβενίρ σουβλάκι σουβλί σουβλίας σουβλίτσα σουβλατζής σουβλατζίδικο σουβλιά
σουγιάς σουδάκι σουδάρι σουδάριο σουδάριον σουηδέζα σουηδέζος σουηδή σουηδικά
σουκρούτ σουλάντισμα σουλάτσο σουλαντιστήρι σουλατσάδα σουλατσάρισμα
σουλατσαδόρος σουλατσαρία σουλιμάς σουλιωτοχώρια σουλιώτης σουλούπι σουλούπωμα
σουλτάνος σουλτανάτο σουλτανάτον σουλτανίνα σουλφοναμίδες σουμάδα σουμάκι
σουμέν σουμπλιμέ σουμπλιμές σουμπρέτα σουνέτι σουνίτης σουναμιτισμός
σουνισμός σουξέ σουξεδάκι σουπέ σουπίδι σουπίνο σουπερμάρκετ σουπερνόβα σουπιά
σουπλά σουπῖνον σουράτα σουραύλι σουρβιά σουρεαλίστρια σουρεαλισμός
σουρικάτα σουρλουλού σουρμές σουρμή σουρμελής σουρμελίδισσα σουρντίνα
σουρούπωμα σουρτή σουρτούκα σουρτούκεμα σουρτούκης σουρτούκο σουρτούκω
σουσάμι σουσάφωνο σουσαμάτο σουσαμιά σουσαμόλαδο σουσαμόπιτα σουσουδισμός
σουσού σουσούμι σουτ σουτάρισμα σουτέρ σουτζουκάκι σουτζούκι σουτζούκος
σουφισμός σουφλέ σουφραζέτα σουϊπστέικ σοφάρισμα σοφάς σοφέρ σοφία σοφίτα
σοφεράντζα σοφερίνα σοφιστής σοφιστεία σοφιστική σοφολογιοτατισμός
σοφολογιότητα σοφορά σοφράς σοφός σούβλα σούβλισμα σούγλος σούδα σούδρα σούζα
σούμα σούμο σούνα σούπα σούπερ σούπερ μάρκετ σούπερ σταρ σούπερμαν σούρβα
σούργελο σούρισμα σούρλος σούρουπο σούρσιμο σούρτα φέρτα σούρτης σούρωμα σούσι
σούστα σούφρα σούφρωμα σπάγγος σπάγκος σπάθα σπάθη σπάλα σπάλαθο σπάνις
σπάραχνο σπάργανα σπάργανο σπάρος σπάρσιμο σπάρτο σπάσας σπάσιμο σπάτουλα
σπέκουλας σπέντζα σπέρμα σπέτζα σπήκερ σπήλαιο σπήλιο σπίζα σπίθα σπίθισμα
σπίλος σπίλωμα σπίλωση σπίλωσις σπίνος σπίρτο σπίτι σπίτωμα σπαής σπαγέτο
σπαζοκεφαλιά σπαθάρης σπαθάριος σπαθί σπαθίον σπαθίς σπαθίφυλλο σπαθασκία
σπαθισμός σπαθιστής σπαθολόγχη σπαθοφορία σπαθοφόρος σπαθόφυτο σπαθόχορτο
σπαλαθιά σπαλομπριζόλα σπαμ σπανάκι σπανακοπιτάκι σπανακοσαλάτα
σπανακοτυρόπιτα σπανακόπιτα σπανακόρυζο σπανακόσουπα σπανιόλος σπανιότης
σπανομαρία σπαράγγι σπαράκι σπαρίλα σπαρίλας σπαραγγόσουπα σπαραγμός
σπαργάνωση σπαργάνωσις σπαρματσέτο σπαρολόγος σπαρτά σπαρτάρισμα σπαρτιάτης
σπαρτολούλουδο σπαρτοπλεχτική σπαρτό σπασίκλα σπασίκλας σπασαρχίδας
σπασικλάκι σπασμολυτικά σπασμοφιλία σπασμωδία σπασμωδικότητα σπασμός σπασοκέφι
σπασταόλας σπατάλη σπαταίος σπαχής σπείρα σπείραμα σπείρωμα σπείρωση
σπειροτόμος σπειροχαίτη σπειρόνημα σπεκουλάρισμα σπεκουλάτσια σπεκουλαδόρα
σπεντζοφάι σπερδούκλα σπερδούκλι σπερμίνη σπερματέγχυση σπερματίνη
σπερματισμός σπερματοβλάστη σπερματογένεση σπερματογονία σπερματοδότης
σπερματοθήκη σπερματοκύτταρο σπερματολογία σπερματοτοξίνη σπερματσέτο
σπερματόφυτα σπερμοβλάστη σπερμογονία σπερμοθήκη σπερμοκύτταρο σπερμολογία
σπερμοτοξίνη σπεσιαλίστας σπεσιαλιτέ σπετασρία σπετζοφάι σπετσέρης σπετσαρία
σπετσιώτης σπετσιώτισσα σπηλαίωση σπηλαιολίμνη σπηλαιολογία σπηλαιολόγος
σπιέρα σπιθαμή σπιθοβολή σπιθοβόλημα σπιθουράκι σπιθούρι σπικάζ σπικάτο
σπιλιαδίτσα σπιν σπινθήρ σπινθήρας σπινθήρισμα σπινθηρισμός σπινθηριστής
σπινθηροβόλημα σπινθηρογράφημα σπινθηρογραφία σπινθηροσκόπιο σπινθηροσκόπιον
σπινθηρωπία σπινιάλο σπιουνιά σπιούνα σπιούνος σπιράγιο σπιριτουαλισμός
σπιροσκόπιο σπιρουλίνα σπιρουνιά σπιρούνι σπιρούνιασμα σπιρούνισμα σπιρτάδα
σπιρτοκούτι σπιρτόκουτο σπιρόμετρο σπισισμός σπιτάκι σπιτάλι σπιταρόνα σπιτικό
σπιτονοικοκύρης σπιτόγατος σπιτόφιδο σπλάγχνα σπλάγχνο σπλάγχνον σπλάχνα
σπλήνα σπλήνας σπλήνιασμα σπλήνωση σπλήνωσις σπλαγχναλγία σπλαγχνογραφία
σπλαγχνοτομία σπλαγχνόπτωση σπλαγχνόπτωσις σπλαχνιά σπλαχνότη σπλαχνότητα
σπληνάντερο σπληνίτιδα σπληνίτις σπληναλγία σπληνεκτομή σπληνεκτομία
σπληνογραφία σπληνολογία σπληνομεγαλία σπληνορραγία σπογγάνθρακας σπογγάνθραξ
σπογγαλιέας σπογγαλιεία σπογγαλιευτικό σπογγαλιευτικόν σπογγαλιεύς
σπογγοθήκη σποδιά σποδός σπολάς σπολλάτη σπολλάτι σπονδές σπονδή σπονδείος
σπονδυλίτις σπονδυλαρθρίτιδα σπονδυλαρθρίτις σπονδυλεξάρθρωση
σπονδυλοδεσία σπονδυλολίσθηση σπονδυλολυσία σπονδυλοπάθεια σπονδυλωτά
σπονδύλωσις σπορ σπορά σποράγγειο σπορέας σπορέλαιο σπορέλαιον σπορίτης
σποραδικότητα σπορείο σπορείον σπορεύς σποριά σποριάγγειο σποριάγγειον σποριάς
σποριόφυλλο σποριόφυλλον σποριόφυτο σπορκαρισμός σποροβλάστη σπορογονία
σποροπαραγωγή σπορτσούμαν σπορόζωα σποτάκι σπουδάρχης σπουδάστρια σπουδές
σπουδαιολογία σπουδαιολόγημα σπουδαιοφάνεια σπουδαιότης σπουδαιότητα
σπουδαρχίδης σπουδαστήριο σπουδαστής σπουργίτης σπουργίτι σπουργιτάκι
σπούδαγμα σπούδασμα σπούργιτας σπούτνικ σπρέι σπρίντερ σπρεντ σπρωξίδι σπρωξιά
σπρωξούλα σπρώξιμο σπυράκι σπυρί σπυρίς σπυρίς σπόγγισμα σπόγγος σπόδιο
σπόνδυλος σπόνσορ σπόνσορας σπόντα σπόρι σπόρια σπόριασμα σπόριο σπόριον
σπόρος σπόρτσμαν σπύριασμα σράναν στάβλισμα στάβλος στάγμα στάδιο στάδιον
στάθμευσις στάθμη στάθμιση στάθμισις στάλα στάλαγμα στάλαμα στάλαξη στάλαξις
στάλος στάλπη στάλσιμο στάμα στάμνα στάμπα στάνη στάνταρ στάνταρτ στάντζος
στάρετς στάρι στάρλετ στάρπη στάση στάσιμο στάσιμον στάσις στάτζος στάτους κβο
στάφνισμα στάχτη στάχτιασμα στάχτωμα στάχυ στάχυασμα στάχωμα στάχωση στέβια
στέγασις στέγασμα στέγαστρο στέγαστρον στέγη στέγνα στέγνη στέγνωμα στέγνωση
στέκα στέκι στέλεχος στέμμα στέμφυλο στέναγμα στένεμα στένσιλ στένωμα στένωση
στέπα στέρα στέρεμα στέρημα στέρηση στέρησις στέριωμα στέρνα στέρνο στέρνον
στέφανο στέφανος στέψη στέψις στήθι στήθος στήλη στήμονας στήριγμα στήριξη
στήσιμο στίβος στίγμα στίλβη στίλβωμα στίλβωση στίλβωσις στίμα στίμη στίξη
στίφος στίχιση στίχος σταβάρι σταβλάρχης σταβλίτης σταγμοδόχη σταγονίδιο
σταγονόμετρο σταγονόμετρον σταγονόρροια σταγόνα σταγών σταδία σταδιοδρομία
σταδιομέτρησις σταδιόμετρο σταζ σταζιέρ σταθερά σταθεροθερμία σταθεροποίηση
σταθεροποιητής σταθερό σταθερότης σταθερότητα σταθερότυπο σταθερότυπος σταθμά
σταθμαρχείο σταθμαρχείον σταθμιστής σταθμός στακάτο στακτή στακτοθήκη σταλία
σταλίστρα σταλαγμίτης σταλαγματιά σταλαγμός σταλακτίτης σταλαμίδα σταλαματιά
σταλαξιά σταλαχτίτης σταλιά σταλινισμός σταλινιστής σταλλακτηφόρος σταλτικά
σταματημός σταμνάγκαθο σταμνάκι σταμνάς σταμνί σταμνίτσα σταμναγκάθι
σταμπάρισμα στανιό σταντ σταξιά σταρ σταράς σταρέμπορος σταρήθρα σταριλίκι
σταρχιδισμός σταρχιδιστής σταρότοπος σταρόψειρα στασίαρχος στασίαση στασίασις
στασίδιον στασιάρχης στασιαστής στασιμοπληθωρισμός στασιμότης στασιμότητα
στατήρ στατήρας στατική στατικολόγος στατικότητα στατιστική στατιστικολόγος
σταυραδέρφι σταυραδερφός σταυραετός σταυρανθή σταυραϊτός σταυρεπικονίαση
σταυροδοσία σταυροδρόμι σταυροθεοτόκιο σταυροθόλιο σταυροθόλιον
σταυροκόπημα σταυροκόπι σταυρομάνα σταυροπάτης σταυροπήγιο σταυροπήγιον
σταυροπληγία σταυροπληξία σταυροπροσκύνηση σταυροπροσκύνησις σταυρουδάκι
σταυροφορία σταυροφόρος σταυρωτής σταυρόκομπος σταυρόλεξο σταυρόλεξον
σταυρόνημα σταυρός σταφίδα σταφίδιασμα σταφίς σταφιδάμπελος σταφιδέμπορος
σταφιδίτης σταφιδεμπόριο σταφιδεμπόριον σταφιδοκτήμονας σταφιδοπαραγωγή
σταφιδόκαρπος σταφιδόπανο σταφιδόψωμο σταφυλέλαιο σταφυλή σταφυλίτης
σταφυλίτις σταφυλοθεραπεία σταφυλοκοκκίαση σταφυλοκοκκίασις σταφυλοκόφινο
σταφυλορώγα σταφυλοσάκχαρο σταφυλοσάκχαρον σταφυλοφαγία σταφυλόκοκκος
σταφύλι σταχανοβίτης σταχανοβίτισσα σταχανοφισμός σταχολόγημα σταχομαζώχτρα
σταχτοδοχείο σταχτοθήκη σταχτοκουλούρα σταχτοτσικνιάς σταχτόνερο σταχτόπανο
σταχυολόγηση σταχωτής σταύρωμα σταύρωση σταύρωσις στεάτωμα στεάτωση στεάτωσις
στείρος στείρωση στείφτης στείψιμο στεαρίνη στεατίνη στεατίτης στεατοπυγία
στεατουργείον στεβιοσίδη στεγάνωση στεγανογραφία στεγανοποίηση στεγανόποδα
στεγανότητα στεγαστής στεγνοκαθαριστήριο στεγνωτήρας στεγνωτήριο στεγνωτήριον
στεγνότητα στειλεός στειλιάρι στειπτήριο στειροβότανο στειρολόγημα
στειροποίησις στειρότητα στειφτήρι στελέχωση στενή στεναγμός στεναχώρια
στενογράφηση στενογράφος στενογραφία στενοθώρακας στενοθώραξ στενοκαρδία
στενομετωπία στενομυαλιά στενοπορία στενοποριά στενορύμι στενοσόκακο
στενωπός στενό στενόν στενότης στενότητα στερέωμα στερέωση στερέωσις
στερεογνωσία στερεογραφία στερεογραφόμετρο στερεογραφόμετρον στερεοελλαδίτης
στερεομετρία στερεομηχανική στερεοποίηση στερεοποίησις στερεοσκοπία
στερεοσκόπιον στερεοστατική στερεοτομία στερεοτυπία στερεοτυπείο στερεοτύπης
στερεοφωτογραφία στερεοχημεία στερεοχρωμία στερεοϊσομέρεια στερεωτής στερεό
στερεόραμα στερεόσφαιρα στερεότητα στερεότυπα στερεότυπο στερεόφερτος ήχος
στερλίνα στερναλγία στερνογέννητο στερνοπαίδι στερνοπούλι στερνοταξιδευτής
στερνοτομή στεροειδές στερόλη στεφάνη στεφάνι στεφάνιο στεφάνιον στεφάνωμα
στεφάνωσις στεφανιογράφημα στεφανιογραφία στεφανοθήκη στεφανοφόρος στεφοδότης
στηθαίο στηθαίον στηθοσκόπηση στηθοσκόπησις στηθοσκόπιο στηθοσκόπιον στηθούρι
στηθόπονος στηλίτευση στηλίτευσις στηλίτης στηλιτευτής στηλιτικά στημόνι
στια στιβάδα στιβάλι στιβάνι στιβαδόρος στιβαρότης στιβαρότητα στιβνίτης
στιγμάτωσις στιγμή στιγμασταδιένιο στιγματισμός στιγμιογράφηση στιγμιογράφησις
στιγμιότυπον στιγμόμετρο στικ στικάκι στιλ στιλέτο στιλίστας στιλβαδάμας
στιλβωτήριο στιλβωτής στιλβώτρο στιλιζάρισμα στιλπνότης στιλπνότητα στιλό
στιφάδο στιχάριο στιχάριον στιχογράφος στιχογραφία στιχομετρία στιχομυθία
στιχοπλόκος στιχοποίηση στιχοποιία στιχοποιός στιχουργία στιχουργική
στιχούργημα στιχόμετρο στλεγγίδα στοά στοίβα στοίβαγμα στοίβασμα στοίχειωμα
στοίχιση στοίχισις στοίχος στοιβάδα στοιβασία στοιχείο στοιχείον στοιχειοθέτης
στοιχειοθέτησις στοιχειοθήκη στοιχειοθεσία στοιχειολογία στοιχειομετρία
στοιχειοχυτήριον στοιχειοχύτης στοιχειό στοιχηματισμός στοκ στοκάρισμα
στοκαριτζής στοκατζής στολή στολή στολίδι στολίδωση στολίδωσις στολίσκος
στολισμός στολοδρομία στομάχι στομάχιασμα στομίδα στομαλίμνη στομαλγία
στοματάρα στοματάς στοματίτιδα στοματολογία στοματοπάθεια στοματορραγία
στοματού στομαχόπονος στομαχόχορτο στοναχή στοπ στοπάρισμα στορ στοργή
στορύνη στουπέτσι στουπί στουπόχαρτο στουρνάρι στουρνάριον στουρναρόπετρα
στοχασμός στοχαστής στοχαστική στοχαστικότητα στοχοποίηση στοχοπροσήλωση
στούμπισμα στούμπος στούντιο στούπωμα στούρνος στράβωμα στράγγιση στράγγισμα
στράπον στράτα στράτευμα στράτευση στράτευσις στράτζα στράτσο στρέβλωμα
στρέβλωσις στρέμμα στρέξιμο στρέτο στρέχα στρέψη στρέψις στρίγγλα στρίγκλα
στρίγκλος στρίκινγκ στρίμωγμα στρίποδο στρίφωμα στρίψιμο στραβάδα στραβάδι
στραβισμός στραβοκεφαλιά στραβοκοίταγμα στραβολέκα στραβολαίμιασμα
στραβομάρα στραβομουτσούνιασμα στραβοξυλιά στραβοπάτημα στραβοπίνελο
στραβούλιακας στραβωμάρα στραβόξυλο στραγάλι στραγαλατζής στραγαλατζίδικο
στραγγάλη στραγγάλισμα στραγγίδιο στραγγαλίστρια στραγγαλισμός στραγγαλιστής
στρακαστρούκα στραμπούλισμα στραπάτσο στραπατσάδα στραπατσάρισμα στρας
στρατάρχης στρατήγημα στρατί στραταρχία στρατηγία στρατηγείο στρατηγείον
στρατηγός στρατηλάτης στρατιά στρατιωτάκι στρατιωτίνα στρατιωτικοποίηση
στρατιωτικός στρατιωτισμός στρατιώτης στρατοδίκης στρατοδικείο στρατοδικείον
στρατοκρατία στρατοκρατικός στρατοκόπος στρατολάτης στρατολάτισσα στρατολογία
στρατολόγος στρατονόμος στρατοπέδευση στρατοπεδάρχης στρατοπεδεία
στρατούλα στρατσόχαρτο στρατωνισμός στρατόπεδο στρατόπεδον στρατός
στρατών στρατώνα στρατώνας στρείδι στρεβλωτής στρεβλότης στρεβλότητα
στρεμματοζάχαρο στρεπτοκοκκίαση στρεπτοκοκκίασις στρεπτομυκίνη στρεπτόκοκκος
στρεσάρισμα στρεφοποδία στρεψοδικία στρεψουχενία στριγγοπούλι στριγερός
στριγκλιά στριγξ η αείσκωψ στριμμάδα στριμμάδι στριμωξίδι στρινγκ στρινγκάκι
στριπτίζ στριπτιζάδικο στριπτιζέζ στριφογύρισμα στριφτάδι στριφτάρι στριφόνι
στροβιλισμός στροβιλοαυλωθητήρας στροβιλοσυμπιεστής στροβιλοϋπερπληρωτής
στροβοσκόπιο στροβοσκόπιον στρογγυλάδα στρογγυλοποίηση στρογγυλότης
στρογγύλεμα στρογγύλευμα στρογγύλωση στρογγύλωσις στρουγγολίθι στρουγκόλιθος
στρουθίο στρουθοκάμηλος στρουθοκαμηλισμός στρουκτουραλισμός στρουκτούρα
στροφή στροφίδι στροφίλι στροφαλοθάλαμος στροφείο στροφείον στροφικότητα
στροφισμός στροφοδίνη στροφορμή στροφυλιά στροφόμετρο στρούγκα στρυφνάδα
στρυφνότητα στρυχνίνη στρυχνισμός στρωμάτσο στρωματάδικο στρωματάς στρωματέξ
στρωματογραφία στρωματοθήκη στρωματοποίηση στρωματοσωρείτης στρωματού
στρωματσόπανο στρωμνή στρωσίδι στρόβιλος στρόμβος στρόντιο στρόφαλο στρόφαλος
στρόφιγξ στρόφος στρύχνος στρώμα στρώση στρώσιμο στυγερότης στυγερότητα
στυλ στυλάκι στυλίδα στυλίστας στυλίτης στυλίτισσα στυλιδιώτης στυλοβάτης
στυλογράφος στυλοκέφαλο στυλοπάτι στυλό στυπείον στυπιοθλίπτης στυπτήριο
στυπτικότης στυπτικότητα στυπόχαρτο στυπόχαρτον στυρένιο στυρόλιο στυφάδα
στυφότης στυφότητα στωικισμός στωικός στωικότητα στωμυλία στόκολο στόκος
στόλισμα στόλος στόμα στόμα στόμαχος στόμιο στόμφος στόμωμα στόμωση στόνος
στόρι στόρισμα στόφα στόχαση στόχαστρο στόχευση στόχος στύλος στύλωμα στύλωση
στύπωμα στύση στύσις στύφνος στύφτης στύψη στύψιμο στύψις συΐδες συάκι
συβαρίτισσα συβαριτισμός συγγένεια συγγένισσα συγγενάδι συγγενής συγγενικά
συγγνώμη συγγραφέας συγγραφή συγκάλεση συγκάλεσις συγκάλυψη συγκάλυψις
συγκέντρωση συγκέντρωσις συγκέρασμα συγκίνηση συγκίνησις συγκαλά συγκαρπία
συγκατάβασις συγκατάθεση συγκατάθεσις συγκατάκλισις συγκατάνευση συγκατάνευσις
συγκατάταξις συγκαταβατικότης συγκαταβατικότητα συγκατανευσιφάγος
συγκαταρίθμησις συγκατηγόρημα συγκατοίκηση συγκατοίκησις συγκατοικία συγκατοχή
συγκεκριμενοποίηση συγκεντρωσιάρχης συγκεντρωσιμότητα συγκεντρωτής
συγκερασμός συγκεφαλαίωση συγκεφαλαίωσις συγκινησία συγκινητικότης
συγκληροδόχος συγκληρονομία συγκληρονόμος συγκλονισμός συγκοινωνία
συγκοινωνιολόγος συγκολλητήρ συγκολλητήρας συγκολλητής συγκομιδή συγκοπή
συγκράτηση συγκράτησις συγκρητισμός συγκρότημα συγκρότηση συγκρότησις
συγκυβέρνησις συγκυβερνήτης συγκυρία συγκυριαρχία συγκυριότης συγκυριότητα
συγκόλλησις συγκύριος συγκύτιο συγνώμη συγυρίστρα συγχαρίκια συγχαρητήρια
συγχορευτής συγχορεύτρια συγχρηματοδότηση συγχρονία συγχρονικότητα
συγχρονιστής συγχρωτισμός συγχυτής συγχωρητικότητα συγχωριανή συγχωριανός
συγχώνευση συγχώρεση συγχώρηση συγύριο συγύρισμα συδαύλιση συζήτηση συζητητής
συζυγαρχία συηνίτης συκάμινο συκαμιά συκαμινιά συκαμνιά συκιά συκομαντεία
συκοπερίβολο συκοπιταρίδα συκοφάγος συκοφάντης συκοφάντηση συκοφάντισσα
συκοφαντία συκωτάκι συκωτάκια συκωταριά συκόμουρο συκόφυλλο συκώτι συλητής
συλλέκτρια συλλέχτης συλλέχτρια συλλαβή συλλαβισμός συλλαβισμός συλλαβογραφία
συλλαλητήριο συλλαλητήριον συλλείτουργο συλλειτουργός συλλογέας συλλογή
συλλογισμός συλλογιστική συλλοχίτης συλλυπητήρια συλφίδα συλφίς συμβάν συμβία
συμβίωσις συμβασιλέας συμβασιλεία συμβασιλεύς συμβασιοκράτης συμβασιοκρατία
συμβατικότητα συμβατισμός συμβατότης συμβατότητα συμβεβηκός συμβιβασμός
συμβιβαστικότητα συμβολή συμβολαιογράφος συμβολαιογραφία συμβολαιογραφείο
συμβολαιογραφικά συμβολαιοποίηση συμβολική συμβολισμός συμβολιστής συμβολογία
συμβολοσειρά συμβουλάτορας συμβουλή συμβουλευτής συμβούλιο συμβούλιον
συμβόλαιον συμεταβλητότητα συμιακός συμμάζεμα συμμάζωμα συμμαζεμός συμμαθήτρια
συμμαθητεία συμμαχήτρια συμμαχία συμμαχητής συμμεταβλητή συμμετοχή συμμετρία
συμμετρικότητα συμμορία συμμορίτης συμμορίτισσα συμμοριτισμός συμμοριτοπόλεμος
συμμόρφωσις συμπάθεια συμπάθια συμπάθιο συμπάντωση συμπέθερος συμπέρασμα
συμπίεσις συμπίλημα συμπίληση συμπαίκτης συμπαίκτρια συμπαίχτης συμπαίχτρια
συμπαθεκτομή συμπαθητικομιμητικά συμπαθητικότης συμπαθητικότητα συμπαιγνία
συμπαντισμός συμπαντιστής συμπαντοβράνη συμπαντογένεση συμπαντογενεά
συμπαντογονία συμπαντοδαισία συμπαντοδιαστολή συμπαντολογία συμπαντολόγος
συμπαντοπληθωρισμός συμπαντοφορμαλισμός συμπαντοχρονολόγιο συμπαράσταση
συμπαράταξη συμπαραγωγή συμπαραγωγός συμπαραστάτης συμπαραστάτισσα
συμπατριώτης συμπατριώτισσα συμπεθέρα συμπεθέρεμα συμπεθέρια συμπεθέριασμα
συμπεθεριό συμπερίληψη συμπερασματολογία συμπερασμός συμπεριφορά
συμπιεστής συμπιεστό συμπιεστόν συμπιεστότης συμπιεστότητα συμπιλητής
συμπλήρωμα συμπλήρωση συμπλήρωσις συμπληγάδες συμπληρωματικότητα συμπλησιασμός
συμπλοιοκτήτρια συμπλοιοκτησία συμπλοκή συμπλοκογόνο συμπλοκοποιητής
συμπολίτευσις συμπολίτης συμπολίτισσα συμπολεμίστρια συμπολεμιστής συμπολιτεία
συμποσίαρχος συμποσιαστής συμπράγκαλα συμπροφορά συμπρωταγνιστής
συμπρωτεύουσα συμπρόεδρος συμπτωματολογία συμπυκνωτής συμπόνια συμπόρευση
συμπύκνωμα συμπύκνωση συμπύκνωσις συμφέρον συμφεροντολογία συμφεροντολόγος
συμφιλίωση συμφιλίωσις συμφοιτήτρια συμφοιτητής συμφορά συμφορά συμφραζόμενα
συμφυρμός συμφυτέλαιο συμφωνία συμφωνητικό συμφωνητικόν συμφόρηση συμφόρησις
συνάδελφος συνάδερφος συνάθροιση συνάθροισις συνάλλαγμα συνάνθρωπος συνάντηση
συνάρθρωση συνάρθρωσις συνάρμοση συνάρμοσις συνάρτηση συνάρτησις συνάρχοντας
συνάφεια συνάχι συνάχωμα συνέγερση συνέδριο συνέδριον συνέκδημος συνέλευση
συνέντευξη συνένωση συνέπεια συνέργεια συνέργια συνέριο συνέταιρος συνέτιση
συνέχεια συνέχιση συνήγορος συνήθεια συνήθειο συνήχηση συνήχησις συνίζηση
συναίνεση συναίνεσις συναίρεση συναίρεσις συναίσθημα συναίσθηση συναίσθησις
συναγερμός συναγρίδα συναγρίς συναγωγή συναγωνίστρια συναγωνισμός συναγωνιστής
συναδέλφωση συναδελφικότης συναδελφικότητα συναδελφοσύνη συναδελφότης
συναθλήτρια συναθλητής συναισθήματος συναισθηγνωστισμός συναισθηματικότης
συναισθηματισμός συναισθησία συναιτιότης συναιτιότητα συνακροάτρια συνακροατής
συναλγία συναλλαγή συναλλαγματική συναλληλία συναλοιφή συνανάπτυξη
συναντίληψη συναξάρι συναξάριον συναξαριστής συναπάντημα συναπάρτισμα συναπτή
συναρίθμηση συναρίθμησις συναρμογή συναρμοδιότητα συναρμολογητής
συναρμολόγημα συναρμολόγηση συναρμολόγησις συναρμοστής συναρπαγή συναρχία
συνασφάλιση συνατουργία συνατουργός συναυλία συναυτοκράτορας συναυτουργία
συναχάκι συνδήλωση συνδαιτυμόνας συνδαιτυμών συνδακτυλία συνδαύλιση
συνδαύλισμα συνδεσιμότητα συνδεσμολογία συνδεσμώτης συνδετήρ συνδετήρας
συνδημότις συνδημότισσα συνδιάλεξη συνδιάλεξις συνδιάσκεψη συνδιάσκεψις
συνδιαλλαγή συνδιαμόρφωση συνδιαφήμιση συνδιαχείριση συνδιδασκαλία
συνδικάτο συνδικάτον συνδικία συνδικαλίστρια συνδικαλισμός συνδικαλιστής
συνδρομή συνδρομήτρια συνδρομητής συνδυασμός συνείδηση συνείδησις συνεγγυήτρια
συνεδρία συνεδρίαση συνεδρίασις συνειδητοποίηση συνειδητότητα συνειδός
συνειρμός συνεισφορά συνεκδοχή συνεκπαίδευση συνεκτίμηση συνεκτικότητα
συνεκφώνηση συνεννόηση συνενοχή συνεξέταση συνεορτασμός συνεπένδυση συνεπαγωγή
συνεπιβάτης συνεπιβάτιδα συνεπιβάτισσα συνεπιβάτρια συνεπιβατισμός συνεργάτης
συνεργάτις συνεργάτισσα συνεργάτρια συνεργία συνεργασία συνεργασιμότητα
συνεργατισμός συνεργείο συνεργισμός συνεργός συνερισιά συνεστίαση συνεταίρος
συνεταιρίστρια συνεταιρισμός συνεταιριστής συνεταιριστικότητα συνετισμός
συνεφαπτομένη συνεχές συνεχίστρια συνεχιστής συνεύρεση συνηγορία συνηλικιώτης
συνημίτονο συνημίτονον συνημμένο συνθέτης συνθέτις συνθέτρια συνθήκη
συνθετήριο συνθετήριον συνθηκολόγηση συνθηκολόγησις συνθηματολογία συνθιασώτης
συνιδιοκτήτης συνιδιοκτήτρια συνιδιοκτησία συνισταμένη συνιστώσα συννέφεια
συννεφιά συννεφόκαμα συννυφάδα συνοίκηση συνοίκησις συνοδίτης συνοδεία
συνοδηγός συνοδοιπορία συνοδοιπόρος συνοδός συνοικέσιο συνοικέσιον συνοικία
συνοικολογία συνολκή συνολοκλήρωση συνολοσυνάρτηση συνομάδωση συνομαδώνομαι
συνομιλία συνομιλητής συνομιλιά συνομολογία συνομολόγηση συνομολόγησις
συνομοταξία συνονθύλευμα συνονθύλευσις συνονόματος συνοπτικότης συνοπτικότητα
συνορίτισσα συνοριοφύλακας συνορισιά συνοστέωση συνουσία συνοφρύωμα συνοφρύωση
συνοχή συνοχεύς συνσεναριογράφος συντάκτης συντάκτις συντάκτρια συντάχτης
συντέκνισσα συντέλεια συντέλεση συντέλεσις συντήρηση συντήρησις συνταίριασμα
συνταγματάρχης συνταγματικότης συνταγματικότητα συνταγματισμός συνταγματολόγος
συνταγογραφία συνταγολογία συνταγολόγιο συνταγολόγιον συντακτικό συντακτικόν
συνταξιδιώτις συνταξιδιώτισσα συνταξιοδότηση συνταξιοδότησις συνταξιούχος
συνταχτικό συνταύτιση συνταύτισις συντεκνία συντεκνιά συντελεστής συντεταγμένη
συντεχνίτης συντεχνίτισσα συντηρητικά συντηρητικότης συντηρητικότητα
συντμημένο συντομία συντομογραφία συντομομορφή συντονίστρια συντονισμός
συντοπίτης συντοπίτισσα συντρίμμι συντριβή συντροφία συντροφιά συντροφικότητα
συντροφοναύτες συντρόφεμα συντρόφευμα συντρόφι συντρόφισσα συντυχία συντυχιά
συντόμευσις συνυπευθυνότητα συνυπηρέτηση συνυπολογισμός συνυποσχετικό
συνυποψήφια συνυποψήφιος συνυφάδα συνωμοσία συνωμοσιολογία συνωμοσιολόγος
συνωμοτισμός συνωμότης συνωμότις συνωμότισσα συνωμότρια συνωνυμία συνωρίδα
συνωστισμός συνύπαρξη συνύπαρξις συνύφανση συνώθηση συνώνυμο συρίγγιο
συριανή συριανός συριγμός συριζαίος συριστικοποίηση συρμή συρμακέσης συρματάκι
συρματοποίηση συρματοποίησις συρματοποιία συρματοποιείο συρματοποιείον
συρματουργία συρματουργείο συρματουργείον συρματουργός συρματόβουρτσα
συρματόσκοινο συρματόσχοινο συρματόσχοινον συρμός συρρίκνωμα συρρίκνωση
συρραπτικό συρραφή συρροή συρτάκι συρτάρι συρτή συρταράκι συρταριέρα συρφετός
συσκευάστρια συσκευή συσκευασία συσκευαστήρι συσκευαστής συσκοτισμός συσκότιση
συσπανσιόν συσπείρωση συσπείρωσις συσπουδάστρια συσπουδαστής συσσίτιο
συσσιτιάρχης συσσυμπάντωση συσσωμάτωμα συσσωμάτωση συσσωμάτωσις συσσωρευτής
συσσώρευσις συστάδα συστάς συστέγαση συστέγασις συσταλτικότητα συστασιώτης
συστηματικότης συστηματικότητα συστηματοποίηση συστηματοποίησις συστοιχία
συστολή συστρατιώτης συστροφή συσφαίρωμα συσφιγκτήρα συσφιγκτήρας συσφικτήρα
συσχέτιση συσχετισμός συφιλιάρα συφιλισμός συφορά συχαρίκια συχνοουρία
συχνοταξιδιώτης συχνοτισμός συχνουρία συχνότητα συχωριανή συχωριανός
συχώρεση συχώριο σφάγιο σφάκα σφάκελο σφάλισμα σφάλμα σφάντζικο σφάξιμο
σφένδαμνος σφένδαμος σφήγκα σφήκα σφήνα σφήνωμα σφήνωση σφήνωσις σφίγγα σφίξη
σφαίρα σφαίριση σφαγάδι σφαγάρι σφαγέας σφαγή σφαγείο σφαγιάτικα σφαγιασμός
σφαδασμός σφαιρίδιο σφαιρίνη σφαιρικότητα σφαιριστήριο σφαιριστική σφαιροβολία
σφακελισμός σφακιανοπιτάκι σφακιανόπιτα σφακομηλιά σφαλάγγι σφαλαγγουδιά
σφαλιάρα σφαλματογραφία σφαλματολογία σφαχτάρι σφαχτό σφελίδα σφενδάμι
σφεντάμι σφεντονιά σφεντόνα σφερδούκλας σφερδούκλι σφερδούλακας σφετερίστρια
σφετεριστής σφηκίσκος σφηκοφωλεά σφηκοφωλιά σφηκωτήρας σφην σφηνάκι σφηνεκτομή
σφηνόλιθος σφηνόπουτσα σφηξ σφιγκτήρ σφιγκτήρας σφιγκτηροτομή σφιγξ
σφιχτοχεριά σφογγοκωλάριος σφοδρότης σφοδρότητα σφολιάτα σφολιατομηχανή
σφοντύλι σφουγγάρι σφουγγάρισμα σφουγγάτο σφουγγαράδικο σφουγγαράς
σφουγγαρόπανο σφουγγοκωλάριος σφούγγιασμα σφράγιση σφράγισις σφράγισμα σφρίγος
σφραγίς σφραγιδοκράτης σφραγιδομάνι σφραγιδοφύλακας σφραγιδοφύλαξ
σφραγιδόλιθος σφραγιστήριο σφραγιστήριον σφριγηλότητα σφυγµοµανόµετρο
σφυγμογράφος σφυγμογραφία σφυγμομέτρηση σφυγμομέτρησις σφυγμόμετρο
σφυγμός σφυράκι σφυρί σφυρίδα σφυρίκτρα σφυρίον σφυρίς σφυρίχτρα σφυρηλάτηση
σφυρηλασία σφυριχτάρι σφυροβολία σφυροβόλος σφυροδακτυλία σφυροδράπανο
σφυροδρέπανον σφυροκάλεμο σφυροκόπημα σφυρό σφόνδυλος σφύξη σφύξις σφύρα
σχάρα σχάση σχάσις σχέδιο σχέδιον σχέση σχήμα σχίζα σχίνος σχίσιμο σχίσμα
σχεδίαση σχεδίασμα σχεδιάγραμμα σχεδιάστρια σχεδιαγράφηση σχεδιασμός
σχεδιαστήριον σχεδιαστής σχεδιογράφημα σχεδιογράφηση σχετικισμός σχετικιστής
σχετικοποίηση σχετικός σχετικότης σχετικότητα σχετισμός σχετλιασμός σχημάτισμα
σχηματισμός σχηματογραφία σχηματοποίηση σχηματοποίησις σχιζοφασία σχιζοφρένεια
σχιζοφρενής σχιζοφρενία σχισμάδα σχισμή σχισματιά σχιστοσωρείτης σχιστόλιθος
σχοινί σχοινίλος σχοινίο σχοινοβάτης σχοινοβάτις σχοινοβάτισσα σχοινοβασία
σχοινοσυντρόφισσα σχοινοσύντροφος σχοινουσιώτης σχολάριος σχολάρχης σχολή
σχολαρχείο σχολαρχείον σχολαστικισμός σχολαστικός σχολαστικότης σχολαστικότητα
σχολειαρούδι σχολειαρόπαιδο σχολειό σχολιάστρια σχολιαρούδι σχολιαρόπαιδο
σχολιαστής σχολικό σχολιογράφος σχόλασμα σχόλη σχόλιο σχόλιον σωβάστικα
σωβινισμός σωβινιστής σωβρακοφανέλα σωθικά σωλήν σωλήνα σωλήνας σωλήνωση
σωληνάκι σωληνάριο σωληνίσκος σωληνοκάβουρας σωληνωτό σωμάτιο σωμασκία
σωματάρχης σωματέμπορας σωματέμπορος σωματίδιο σωματείο σωματεμπορία
σωματιδιογένεση σωματολογία σωματομετρία σωματοποίηση σωματοποίησις
σωματοφυλακή σωματοφύλακας σωματότυπος σωμός σωρεία σωρείτης σωρειτομελανίας
σως σωσίας σωσίβιο σωσμός σωτήρ σωτήρας σωτηρία σωτρόπι σωφρονισμός
σωφρονιστήριο σωφρονιστήριον σωφρονιστής σωφροσύνη σόγια σόδα σόδιασμα σόδιο
σόλα σόλιασμα σόλο σόμα σόμπα σόνα σόου σόου μπίζνες σόου μπιζ σόουμαν σόπατο
σόργος σόφισμα σόφτμπολ σύαξ σύβαση σύγαμπρος σύγγαμβρος σύγγραμμα σύγκαμα
σύγκλεισις σύγκληση σύγκλησις σύγκλητος σύγκλινο σύγκλινον σύγκλιση σύγκλισις
σύγκριμα σύγκριση σύγκρισις σύγκρουση σύγκρυο σύγλινο σύγνεφο σύγχροτρο
σύδενδρο σύδεντρο σύζευγμα σύζευξη σύζυγος σύθαμπο σύκο σύληση σύλλαβος
σύλληψη σύλληψις σύλλογος σύλφη σύμβαση σύμβασις σύμβολο σύμβουλος σύμιος
σύμμειγμα σύμμειξη σύμμειξις σύμπαν σύμπηξη σύμπηξις σύμπλεγμα σύμπλεξη
σύμπνοια σύμπραξη σύμπραξις σύμπτυγμα σύμπτυξη σύμπτυξις σύμπτωμα σύμπτωση
σύμφαση σύμφασις σύμφραση σύμφυρμα σύμφυρση σύμφυση σύμφυσις σύμφωνο σύμφωνον
σύναξη σύναξις σύναψη σύναψις σύνδεση σύνδεσις σύνδεσμος σύνδικος σύνδρομο
σύνεδρος σύνεργο σύνεση σύνευνος σύνθεμα σύνθεση σύνθεσις σύνθετα σύνθετο
σύνθλιψη σύνθλιψις σύνθρονο σύννεφο σύννοια σύνοδος σύνοικος σύνολο σύνολον
σύνορο σύνορον σύνοψη σύνοψις σύνταγμα σύνταξη σύνταξις σύντεκνος σύντεχνος
σύντηξη σύντηξις σύντμηση σύντμησις σύντριμμα σύντριψη σύντροφος σύριγγα
σύριγμα σύριγξ σύριος σύρμα σύρος σύρραξη σύρραξις σύρσιμο σύρτη σύρτης σύρτις
σύσκεψις σύσκιο σύσπαση σύσπασις σύσπαστο σύσπαστον σύσταση σύστασις σύστημα
σύσφιξη σύφιλη σώβρακο σώγαμπρος σώμα σώρευση σώρευσις σώριασμα σώσιμο σώσμα
τ' τάβλα τάβλι τάγισμα τάγιστρο τάγκιασμα τάγκιν τάγκο τάγμα τάιγκα τάιμ άουτ
τάκι-τάκι τάκκος τάκλιν τάκος τάλαντο τάλαρο τάληρο τάλιρο τάμα τάμπλετ τάνκερ
τάνυσις τάνυσμα τάξη τάξιμο τάξις τάξος τάπα τάπερ τάπης τάπητας τάπια τάπωμα
τάραγμα τάραμα τάρανδος τάραχος τάρσωμα τάρτα τάρταρα τάση τάσι τάσις τάσσιμο
τάφος τάφρος τάχος τάχυνση τέθριππο τέθωρας τέιον τέκτονας τέλα τέλειωμα τέλεξ
τέλεφαξ τέλι τέλμα τέλος τέμενος τέμπερα τέμπλο τέμπλον τέμπο τέναγος τένις
τέντα τέντζερης τέντωμα τένων τέρας τέρβιο τέρμα τέρμινο τέρψη τέρψις τέσλα
τέταρτο τέτραρχος τέφρα τέχνασμα τέχνεργο τέχνη τέχνημα τήβεννος τήξη τήραγμα
τίγρη τίγρης τίκι τακ τίλδη τίλιο τίλμα τίμημα τίμηση τίμησις τίναγμα τίντα
τίτανος τίτλος ταΐστρα ταή ταίρι ταίριασμα ταβάνι ταβάνωμα ταβάς ταβέρνα
ταβανόσκουπα ταβατούρι ταβερνάκι ταβερνίτσα ταβερνείο ταβερνείον ταβερνιάρης
ταβερνούλα ταβερσάδα ταβλάκι ταβλάς ταβλαδόρος ταβλομεσάδα ταγάρι ταγέρ ταγή
ταγεράκι ταγιέρ ταγιαδόρος ταγιεράκι ταγκάδα ταγκίλα ταγκαλόγκ ταγκό
ταγματίτης ταγματασφαλίτης ταγός ταινία ταινίαση ταινιόπλεγμα τακ τακάρισμα
τακίμι τακλάς τακουί τακουνάκι τακουνιά τακούνι τακτ τακτική τακτικίστρια
τακτικιστής τακτικό αριθμητικό τακτικότης τακτικότητα τακτισμός τακτοποίηση
ταλάντευσις ταλάντωση ταλάντωσις ταλέντο ταλίμι ταλαγάνι ταλαιπωρία ταλανισμός
ταλαντώτρια ταλατούρι ταλιαδόρος ταλιαριστής ταλιατέλα ταλιμπάμιας ταλιμπανάκι
ταλιμπανισμός ταλιράκι ταλιροφονιάς ταλκ ταμ ταμ ταμάχι ταμίας ταμίευμα
ταμίευσις ταμίλ ταμαρίνδος ταματάμ ταμείο ταμείον ταμειακή μηχανή ταμιευτήρας
ταμιευτήριον ταμούλ ταμπάκης ταμπάκικο ταμπάκο ταμπάκος ταμπάρο ταμπέλα
ταμπακοθήκη ταμπελάκι ταμπεραμέντο ταμπλέτα ταμπλίστας ταμπλίστρια ταμπλό
ταμπονάρισμα ταμπουλέ ταμπουράς ταμπουρέ ταμπουριώτης ταμπού ταμπούρι
ταμπούρο ταμπόν τανάλια τανίνη ταναγραίος τανζανή τανζανικός τανζανός τανκ
τανκς ταννίνη τανξ ταντάλιο ταντέλα ταντούρι τανυστής ταξάκι ταξί ταξίαρχος
ταξίμετρο ταξίμετρον ταξιανθία ταξιαρχία ταξιδάκι ταξιδευτής ταξιδεύτρα
ταξιδιώτης ταξιδιώτις ταξιδιώτισσα ταξιθέτης ταξιθέτηση ταξιθέτησις ταξιθέτις
ταξιθεσία ταξινομία ταξινομητής ταξινόμηση ταξινόμησις ταξινόμος ταξιτζής
ταξιτζού ταξιχώνευση ταξωνυμία ταξωνυμητής ταοϊσμός ταπάκι ταπέτο ταπίδι
ταπείνωση ταπείνωσις ταπεινοσύνη ταπεινοφροσύνη ταπεινότης ταπεινότητα
ταπεράκι ταπετσάρισμα ταπετσέρης ταπετσαρία ταπετσιέρης ταπητοκαθαριστήριο
ταπητουργείο ταπητουργείον ταπητουργός ταράκουλο ταράτσα ταράτσωμα ταρίφα
ταρίχευση ταρίχευσις ταραγμός ταρακούνημα ταραμάς ταραμοκεφτές ταραμοσαλάτα
ταραντίνο ταραντισμός ταραντουλισμός ταραντούλα ταραξάκο ταραξίας ταρατατζούμ
ταρατσούλα ταραχή ταραχτάς ταρζανιά ταριχευτής ταρσανάς ταρσός ταρτάκι ταρτάν
ταρταρινισμός ταρταρούγα ταρτουφισμός ταρτούφος τασάκι τασκεμπάπ τασμανός
τατάς ταταρικά τατζικικά τατζικιστανός τατουάζ τατουέρ ταυ ταυράκι ταυρί
ταυρομάχος ταυρομαχία ταυρόκολλα ταυτισμός ταυτοβουλία ταυτολογία ταυτομερές
ταυτοπάθεια ταυτοποίηση ταυτοπροσωπία ταυτοφωνία ταυτοχρονία ταυτοχρονισμός
ταυτόγραμμο ταυτότητα ταυτώνυμος ταφή ταφλάνι ταφοφοβία ταφτάς ταφόπετρα
ταχίνι ταχεία ταχινόσουπα ταχογράφος ταχτάρισμα ταχτική ταχτοποίηση ταχυβολία
ταχυβόλο ταχυγένεση ταχυγενεσία ταχυγλωσσία ταχυγράφος ταχυγραφία
ταχυδακτυλουργός ταχυδιανομέας ταχυδιανομή ταχυδρομία ταχυδρομείο ταχυδρόμηση
ταχυεργία ταχυκαρδία ταχυλογοπαίγνιο ταχυμεταφορά ταχυμεταφορέας ταχυμετρία
ταχυπαλμία ταχυπιεστήριο ταχυπλοΐα ταχυποδία ταχυπορία ταχυσφυγμία ταχυφαγία
ταχυφημία ταχυφόρτιση ταχυόνιο ταχύ ταχύμετρο ταχύνοια ταχύπλοο ταχύπνοια
ταχύτης ταχύτητα ταψί ταϊλανδικά ταϊλανδός ταϊτιανά ταϊφάς ταύρος ταύτιση ταώς
τείχισμα τείχος τεγίδα τεζάκι τεζάρισμα τεζάχι τεζιάκι τεζιάχι τεθλασμένη
τεινεσμός τειχίο τειχοδομία τειχομαχία τειχοποιία τεκές τεκμήριο τεκμήριον
τεκνατζού τεκνογονία τεκνοθεσία τεκνοποίηση τεκνοποιία τεκνοποιία τεκνό
τεκτονισμός τελάκι τελάλης τελάρο τελέστρια τελίτσα τελίτσες τελαμώνα
τελαράκι τελατίνι τελεία τελείωμα τελείωμα τελείωση τελειοθηρία τελειομανής
τελειοποίηση τελειωμός τελειότης τελειότητα τελειόφοιτος τελεμές τελεολογία
τελεσιδικία τελεσκί τελεστής τελεστικοποίηση τελεσφόρηση τελεσφόρησις
τελετέξτ τελετή τελετουργία τελετουργικό τελευτή τελεφερίκ τελικός τελλούριο
τελοκρατία τελολογία τελούγκου τελούριο τελωνείο τελωνειακός τελωνισμός
τελωνοφύλακας τελωνοφύλαξ τελόφαση τελώνης τελώνιο τεμάχιο τεμάχιον τεμάχισμα
τεμαχισμός τεμενάς τεμνογάστρωση τεμπέλα τεμπέλαρος τεμπέλης τεμπέλιασμα
τεμπελιά τεμπελοδουλειά τεμπελχανάς τεμπελχανείο τεμπελχανειό τεμπελχανιό
τεμπελόσκυλο τεμπεσίρι τενέδιος τενίστας τενίστρια τενεκές τενεκεδάκι
τενεκετζίδικο τενεμπρισμός τενοντίτιδα τενοντομετάθεση τεντζερέδες τεντζερέδια
τεντιμποϊσμός τεντιμπόης τεντούρα τεντόπανο τενόρο τενόρος τεξανός τεπές
τερέβινθος τερέν τερέτισμα τερακότα τεραμυκίνη τερατογένεση τερατογονία
τερατολόγημα τερατολόγος τερατομορφία τερατοπλασία τερατοτοκία τερατουργία
τερατωδία τερεβινθέλαιο τερεβινθίνη τερερέμ τερετισμός τερζής τερηδονισμός
τερηδώς τεριγιάκι τεριλέν τεριρέμ τερλίκι τερμίτης τερματάκι τερματικό
τερματοφύλακας τερματοφύλαξ τερμιτοφωλιά τερμιτόξενα τερνερική τερορισμός
τερπνότητα τερτίπι τερτσέτο τερψιθυμία τεσκερές τεσσάρα τεσσάρες τεσσάρι
τεσσαρακονταετηρίδα τεσσαρακονταετηρίς τεσσαρακοντούτης τεσσαρακοντούτις
τεσσαροχάλης τεσσαροχάλι τεστ τεστοστερόνη τετ α τετ τετ-α-τετ τεταγμένη
τεταρτάκι τεταρτημόριο τεταρτιασμός τετμημένη τετράβηλο τετράγγουρο τετράγκαθο
τετράγναθος τετράγωνο τετράδα τετράδιο τετράδυμα τετράεδρο τετράζωτο
τετράλμπουρο τετράμετρο τετράμηνο τετράμπαρο τετράμπουλο τετράμυρο τετράνευρος
τετράντας τετράνυμφο τετράνυχος τετράξυλο τετράπλευρο τετράποδο τετράπολις
τετράργυρος τετράρμενο τετράρμπουρο τετράρρυγχος τετράρχης τετράς τετράσαρο
τετράστιγμα τετράστιχο τετράστοο τετράστρεμμα τετράφυλλο τετράχειρα τετράχηλο
τετράχορος τετράψιδο τετράωδο τετράωρο τετραέτις τετρααιθυλαμμώνιο
τετρααιθυλομόλυβδος τετρααιθύλιο τετρααντιμόνιο τετρααρσενικό τετραβάγγελο
τετραβορίδιο τετραβοροκάλιο τετραβορολίθιο τετραβορολανθάνιο τετραβορομαγνήσιο
τετραβοροουράνιο τετραβοροπυρίτιο τετραβοροσαμάριο τετραβράγχια
τετραβρωμίδιο τετραβρωμίωση τετραβρωμομεθάνιο τετραβρωμοπαράγωγο τετραβρώμιο
τετραγαμία τετραγερμάνιο τετραγκαθιά τετραγονία τετραγράμματο τετραγυνία
τετραγωνίδιο τετραγωνισμός τετραγώνισμα τετραδιάκι τετραδυμία τετραδυναμία
τετραεδρία τετραεξαμηνία τετραετία τετραετηρίδα τετραετηρίς τετραευαγγέλιο
τετραζένια τετραζίνες τετραζίνια τετραζυγία τετραζόλιο τετραημερία τετραθεΐα
τετρακάταρτο τετρακίνηση τετρακηροπήγιο τετρακοσαριά τετρακυκλίνες τετρακυμία
τετρακόπτερο τετραλίνη τετραλίνιο τετραλογία τετραμέρεια τετραμίνη
τετραμεθυλοβενζόλιο τετραμεθυλομεθάνιο τετραμεθύλιο τετραμερία τετραμηνία
τετραμορφία τετρανάτριο τετρανίτρωση τετρανδρία τετρανιτρομεθάνιο
τετρανυκτία τετραοδία τετραονία τετραορία τετραπάρεση τετραπέρατα
τετραπλασίαση τετραπλασίασις τετραπλασιασμός τετραπλατεία τετραπλεθρία
τετραπλοειδία τετραποδία τετραποδισμός τετραπροπένιο τετραπροπυλένιο
τετραπωλία τετραπόδιο τετραρεία τετραρχία τετρασέλινο τετρασίριο
τετρασπόριο τετραστάδιο τετραστιχία τετραστοιχία τετρασυλλαβία τετρασυστοιχία
τετρατομικότητα τετραφάρμακο τετραφαινυλένιο τετραφαλαγγάρχης τετραφαλαγγία
τετραφθοράφνιο τετραφθορίδιο τετραφθορίωση τετραφθοροαιθάνιο
τετραφθοροβανάδιο τετραφθορογερμάνιο τετραφθοροδιάζωτο τετραφθοροδιβοράνιο
τετραφθοροθείο τετραφθοροθόριο τετραφθορομαγγάνιο τετραφθορομεθάνιο
τετραφθορομόλυβδος τετραφθορονιόβιο τετραφθοροξένο τετραφθοροουράνιο
τετραφθοροπαράγωγο τετραφθοροπλατίνιο τετραφθοροπλουτώνιο
τετραφθοροπυρίτιο τετραφθοροτελλούριο τετραφθοροτιτάνιο τετραφθοροϊρίδιο
τετραφθοροϋδραζίνη τετραφθόριο τετραφωνία τετραφωσφοπαράγωγο τετραφωσφορίωση
τετραφωσφορύλιο τετραφωσφόρος τετραχισμός τετραχλωράνθρακας τετραχλωρίδιο
τετραχλωραιθυλένιο τετραχλωροαιθάνιο τετραχλωροαιθυλένιο τετραχλωροβανάδιο
τετραχλωροζιρκόνιο τετραχλωροκασσίτερος τετραχλωρομεθάνιο
τετραχλωρομόλυβδος τετραχλωροναφθαλίνιο τετραχλωροουράνιο τετραχλωροπαράγωγο
τετραχλωροσελήνιο τετραχλωροτελλούριο τετραχλωροτιτάνιο τετραχλώριο
τετραχρονία τετραχρωμία τετραωδία τετραωνυμία τετραωρία τετραϋδρογόνωση
τετραϋδροκανναβινόλη τετραϋδροναφθαλίνιο τετραϋδροπυράνιο τετραϋδροφουράνιο
τετραώδιο τετραώροφο τετροξείδιο τευτέρι τευτλοκαλλιέργεια τευτλοπαραγωγός
τεφλόν τεφροδοχείο τεφροδόχη τεφροδόχος τεφρομαντεία τεφτέρι τεχνήτιο τεχνίτης
τεχνίτρα τεχνίτρια τεχνική τεχνικός τεχνικότης τεχνικότητα τεχνοβλαστός
τεχνογραφία τεχνοδομή τεχνοκάπηλος τεχνοκαπηλία τεχνοκράτης τεχνοκράτισσα
τεχνοκρατία τεχνοκριτική τεχνολογία τεχνολογιάκιας τεχνολόγος τεχνοτροπία
τεχνουργός τεχνούργημα τεχνούργηση τεχνόσφαιρα τεϊλορισμός τεϊοδόχη τεϊοποσία
τεϊοπότης τεϊόδεντρο τεύτλο τεύχος τζάγκουαρ τζάκα τζάκετ τζάκι τζάμι τζάνερο
τζάρουκας τζένοα τζέντλεμαν τζίβα τζίνι τζίντζερ τζίρος τζίτερ τζίτζικας
τζίτζιφο τζίφος τζίφρα τζαγκάρης τζαζ τζαζ μπαντ τζαμάρα τζαμάς τζαμί τζαμαρία
τζαμιλίκι τζαμιτζής τζαμλίκι τζαμπάζης τζαμπατζής τζαμπατζίδισσα τζαμπατζού
τζαμπούνα τζαμτζής τζαμόπορτα τζαναμπέτισσα τζαναμπετιά τζανεριά τζανταρμάς
τζατζίκι τζατζικάκι τζελατίνα τζερεμές τζερτζελές τζετ τζετ σετ τζι-πι-ές
τζιβαέρι τζιβιτζιλίκι τζιβιτζιλού τζιγέρι τζιγεροσαρμάς τζιζ τζιμάνης τζιμάνι
τζιν τζιντζερέλα τζιντζερόσουπα τζιπ τζιπάκι τζιπάρα τζιριτζάντζουλα
τζιτζί τζιτζίκι τζιτζίνα τζιτζιλόνι τζιτζιμπίρα τζιτζιφιά τζιτζιφιόγκος
τζιχαντιστής τζιώτης τζιώτισσα τζοβαΐρι τζοβαϊρικά τζογαδόρος τζογιά τζουμπές
τζουμπούσι τζουράς τζουτζές τζουτζούκος τζοχανταραίος τζούντο τζούρα
τζόβενο τζόβινο τζόγια τζόγος τζόκεϊ τζόκιν τηγάνι τηγάνισμα τηγανίτα τηγανιά
τηγανόψωμο τηλέγραφος τηλέλεγχος τηλέμετρο τηλέξ τηλέτυπο τηλέφωνο τηλαισθησία
τηλεαγορά τηλεακτινογραφία τηλεανίχνευση τηλεβολοστάσιο τηλεβόας τηλεβόλο
τηλεγράφημα τηλεγραφήτρια τηλεγραφία τηλεγραφείο τηλεγραφητής τηλεγραφόξυλο
τηλεδιάγνωση τηλεδιάσκεψη τηλεδιακυβέρνηση τηλεδιόδιο τηλεειδοποίηση
τηλεθέαση τηλεθέρμανση τηλεθεάτρια τηλεθεαματικότητα τηλεθεατής τηλεκάρτα
τηλεκαθοδήγησις τηλεκαρδιογραφία τηλεκατεύθυνση τηλεκατεύθυνσις
τηλεκινηματογραφία τηλεκινησία τηλεκοντρόλ τηλεκπαίδευση τηλεκριτική
τηλεμάρκετινγκ τηλεμέτρηση τηλεμαγκαζίνο τηλεμαραθώνιος τηλεματική τηλεμαχία
τηλεμεταφορά τηλεμετρία τηλεμηχανική τηλενέργεια τηλεομοιοτυπία
τηλεομοιότυπο τηλεορασάκιας τηλεορασίτσα τηλεορασούλα τηλεπάθεια τηλεπαιχνίδι
τηλεπαρουσιαστής τηλεπειρατεία τηλεπεριοδικό τηλεπερσόνα τηλεπικοινωνία
τηλεπισκόπηση τηλεπληροφορική τηλεργασία τηλεσημία τηλεσκάφος τηλεσκηνοθέτης
τηλεσκηνοθεσία τηλεσκοπία τηλεσκόπιο τηλεστερεοσκοπία τηλεστερεοσκόπιο
τηλεσυνεδρίαση τηλεσυνεργασία τηλεσύνδεση τηλεταινία τηλεταχύμετρο τηλετράπεζα
τηλετύπημα τηλεφακός τηλεφημερίδα τηλεφροντίδα τηλεφωνήτρια τηλεφωνία
τηλεφωνηματάκι τηλεφωνητής τηλεφωνοδότηση τηλεφωτογραφία τηλεφωτοτυπία
τηλεχειρισμός τηλεχειριστήριο τηλεψήφος τηλεψηφοφορία τηλεψυχία τηλεϊατρική
τηλιακός τηλοψία τηνιακός τηρητής τιάρα τιγρόψαρο τιθάσευση τιθάσευσις
τιθασεύτρια τικ τικ τακ τικάλ τικέτο τιλιά τιλτ τιμάρεμα τιμάρι τιμάριθμος
τιμή τιμαλφή τιμαριθμοποίηση τιμαριθμοποίησις τιμαριούχος τιμαριωτισμός
τιμητής τιμιότης τιμιότητα τιμοκατάλογος τιμοκρατία τιμολόγηση τιμολόγησις
τιμονάκι τιμονιά τιμονιέρα τιμονιέρης τιμονιέρισσα τιμωρία τιμωρητικότητα
τιμόνι τιναγμός τιπούκειτος τιράγιο τιράζ τιράντα τιρκουάζ τιρμπάν τιρμπουσόν
τιτάνας τιτάνιο τιτάνωση τιτίβισμα τιτίζης τιτανίτης τιτανομαχία τιτανόλιθος
τιτλομανία τιτλοποίηση τιτλοφόρο τιτουλάριος τιτοϊσμός τμήμα τμήση τμηματάρχης
τμηματεκτομή τμηματοποίηση τοίχιση τοίχος τοίχωμα τογκολέζος τοιουτότητα
τοιχίο τοιχαρχία τοιχοβάτης τοιχογράφηση τοιχογράφος τοιχογραφία τοιχογύρισμα
τοιχοδομία τοιχοδόμηση τοιχοκολλητής τοιχοκόλλημα τοιχοκόλληση τοιχοποιία
τοιχόχαρτο τοκ πίσιν τοκάριθμος τοκάς τοκετός τοκισμός τοκιστής τοκμάκι
τοκογλύφος τοκολόγιο τοκομερίδιο τοκοφορία τοκοχρεολύσιο τοκοχρεωλύσιο
τολ τολμηρότης τολμηρότητα τολμητίας τολουόλιο τολύπη τομάρι τομάτα τομέας
τομίας τομίδιο τοματίνι τοματιά τοματοπολτός τοματοσαλάτα τοματοχυμός
τομεάρχισσα τομεοποίηση τομεύς τομογράφος τομογραφία
τονάζ τονικότης τονικότητα τονισμός τονοσαλάτα τονοσκόπιο τοξίνη τοξίνωση
τοξευτής τοξεύτρα τοξιδερμία τοξικολογία τοξικολόγος τοξικομανία τοξικοφοβία
τοξικότητα τοξιναιμία τοξινοθεραπεία τοξοβολία τοξοπλάσμωση τοξοπλάσμωσις
τοξόπλασμα τοξότης τοξότις τοξότρια τοπάζι τοπάρχης τοπίο τοπαρχία τοπική
τοπικισμός τοπικιστής τοπικότητα τοπιογράφος τοπιογραφία τοπογράφηση
τοπογραφία τοποθέτηση τοποθέτησις τοποθεσία τοποκύτταρο τοπολαλιά τοπολογία
τοπομετρία τοποτηρητής τοποτηρητεία τοποφαγία τοποφιλία τοπούζι τοπωνυμία
τοπόσημο τορίκι τορβάς τορευτής τορεύς τορμίσκος τορνάρισμα τορναδόρος
τορνευτής τορπίλα τορπίλη τορπίλλη τορπιλάκατος τορπιλητής τορπιλισμός
τορπιλλητής τορπιλλισμός τορπιλλοβόλον τορπιλλοσωλήν τορπιλοβόλο τορπιλοπλάνο
τορπιλοφόρο τορός τοστ τοστ-φωλιά τοστάδικο τοστάκι τοστιέρα τοστομπούγατσο
τοτέμ τοτεμισμός τουΐντ τουΐστ τουίτ τουίτερ τουαλέτα τουαλετάρισμα τουβλάκι
τουγκστένιο τουζλούκι τουκάν τουλίπα τουλουμοτύρι τουλουμπατζής τουλουπάνι
τουλούμιασμα τουλούμπα τουλούπα τουλπάνι τουμπάνιασμα τουμπάρισμα τουμπίτσα
τουμπελέκι τουπέ τουπινάμπα τουρ τουράς τουρέλο τουρίστας τουρίστρια τουρβάς
τουρκάκι τουρκάλα τουρκέτης τουρκέτο τουρκετίνα τουρκιά τουρκικά τουρκμενικά
τουρκοκρατία τουρκολαγνεία τουρκολογία τουρκολογιά τουρκολόγος τουρκολόι
τουρκομερίτισσα τουρκοπούλα τουρκοτέκο τουρκουάζ τουρκοφάγος τουρκοφάσουλο
τουρκόγυφτος τουρκόπιασμα τουρκόπουλο τουρκόσπερμα τουρκόσπορος τουρκόφωνος
τουρλού τουρλόπαπας τουρμπάν τουρμπάνι τουρμπές τουρμπίνα τουρμπιγιόν τουρνέ
τουρνουά τουρσί τουρτίτσα τουρτούρισμα τουτού τουφάνι τουφέκι τουφέκισμα
τουφεκίδι τουφεκίστρα τουφεκιά τουφεκιοφόρος τουφεκισμός τουφεξής τοχαρικά
τούβλο τούγια τούλι τούμπα τούμπανο τούμπο τούνδρα τούνελ τούντρα τούρκεμα
τούρκικος τούρκος τούρλα τούρλωμα τούρνα τούρτα τούρτουρο τούφα τράβα τράβαλα
τράβηγμα τράγημα τράγος τράι τράκα τράκο τράκος τράμπα τράνεμα τράνζιτο
τράος τράπεζα τράπουλα τράστο τράτα τράτο τράφικιν τράφικινγκ τράφος τράχηλος
τράχυνσις τρέιλερ τρέκλισμα τρέλα τρέμολο τρέμουλο τρένο τρέξιμο τρέσα τρήμα
τρίαινα τρίγλυφο τρίγλυφον τρίγλυφος τρίγωνο τρίγωνον τρίεδρο τρίηχο τρίηχον
τρίκλισμα τρίκοχο τρίκροτο τρίκροτον τρίκυκλο τρίκυκλον τρίλημμα τρίλια
τρίμερα τρίμετρο τρίμετρον τρίμηνο τρίμμα τρίο τρίοδος τρίορχις τρίπλα
τρίποδο τρίποντο τρίπους τρίπους τρίπτης τρίπτυχο τρίπτυχον τρίστιχο τρίστρατο
τρίτο τρίτος τρίφτης τρίχα τρίχας τρίχες τρίχρονα τρίχωμα τρίχωση τρίχωσις
τρίωρον τραίνο τραβάγια τραβάκα τραβέλι τραβέρσα τραβέρσο τραβατζάρισμα
τραβηξιά τραβηχτική τραβολόγημα τραγάκι τραγάνα τραγάνισμα τραγέλαφος τραγή
τραγίλα τραγιάσκα τραγικοποίηση τραγικότητα τραγισμός τραγογένης τραγοπόδης
τραγουδίστρια τραγουδιστής τραγουδοποιός τραγούδημα τραγούδι τραγούδισμα
τραγωδιογράφος τραγωδοποιός τραγωδός τραγόδερμα τραγόπαπας τραινάρισμα τρακ
τρακαδόρισσα τρακαδόρος τρακατζής τρακατρούκα τρακοσαριά τρακτέρ τρακτέρι
τρακτεριτζής τραμ τραμβάι τραμβαγέρης τραμουντάνα τραμπάκισσα τραμπάκουλας
τραμπάλα τραμπαρίφας τραμπουκάρισμα τραμπουκέτο τραμπουκαρία τραμπουκαριό
τραμπουκοκρατία τραμπούκος τρανζίστορ τρανζιστοράκι τρανς τρανσέξουαλ
τρανσεξουαλικότητα τρανσφοβία τραντές τρανφοβία τρανότητα τραπέζι τραπέζιο
τραπεζάκι τραπεζάρης τραπεζάρισσα τραπεζίτης τραπεζαρία τραπεζαρείο
τραπεζιέρα τραπεζιέρης τραπεζογραμμάτιο τραπεζογραμμάτιον τραπεζοκάθισμα
τραπεζοκόμα τραπεζοκόμος τραπεζομάνδηλον τραπεζομάντηλο τραπεζομάντιλο
τραπεζομεσίτης τραπεζοσοβιετία τραπεζοϋπάλληλος τραπουλόχαρτο τρασέζ τρασέρ
τρατάρης τρατάρισμα τραταμέντο τραυλισμός τραυλότης τραυλότητα τραυματίας
τραυματιοφορέας τραυματιοφορεύς τραυματισμός τραυματολογία τραυματολόγος
τραχανάς τραχανολαχανόσουπα τραχανόσουπα τραχεία τραχειίτιδα τραχειοβρογχίτιδα
τραχειοσκόπηση τραχειοστομία τραχειοτομή τραχειοτομία τραχηλίτιδα τραχηλιά
τραχυδερμία τραχύτης τραχύτητα τραύλισμα τραύμα τρεκάς τρελάδικο τρελάρα
τρελέγκω τρελαμάρα τρελογιατρός τρελοκαμπέρω τρελοκατάσταση τρελοκομείο
τρελοπαντιέρα τρελοπαρέα τρελόπαιδο τρελός τρελόχαρτο τρεμεντίνα τρεμιθιά
τρεμούλα τρεμούλιασμα τρεμόπαιγμα τρενάκι τρενάρισμα τρενοδηγός τρενοποδήλατο
τρεπονημάτωση τρεπονημάτωσις τρεπόνημα τρεχάλα τρεχάματα τρεχαλητό τρεχαντήρι
τριάδα τριάρα τριάρι τριήμερα τριήμερο τριήμερον τριήραρχος τριήρης τριαγμός
τριαδικότητα τριακονταετία τριακονταετηρίδα τριακονταετηρίς τριακοντούτης
τριακοσιομέδιμνος τριαμίνη τριανδρία τριαντάδα τριαντάρι τριαντάφυλλο
τριανταένα τριανταμία τριανταριά τριανταφυλλάκι τριανταφυλλί τριανταφυλλιά
τριανταφυλλόξιδο τριαρχία τριαταγωνιστής τριβάς τριβέας τριβέλι τριβέλισμα
τριβίδα τριβαδισμός τριβείο τριβεύς τριβοφωταύγεια τριβόλι τριβόλισμα
τριγαμία τριγλί τριγλυκερίδιο τριγλώχινα τριγμός τριγυρίστρα τριγωνάκι
τριγωνομέτρηση τριγωνομέτρησις τριγωνομετρία τριγύρισμα τριγύρω τριετία
τριετηρίς τριεψιλίτης τριζόνι τριημερία τριημιτόνιο τριηραρχία τρικ τρικάζ
τρικέζα τρικέρης τρικέρι τρικήριον τρικαντό τρικατάληκτο τρικλοποδιά τρικολόρ
τρικυκλατζής τρικυμία τρικυμιά τρικό τρικύμισμα τριλογία τριμήνι τριμηνία
τριμορφισμός τρινιτροτολουόλη τριοδίτης τριολέτο τριοξείδιο τριπάκι τριπλέτα
τριπλασιασμός τριπλουνίστας τριπλούν τριπλωπία τριπλότυπο τριπλότυπον
τριποδιώτης τριποδιώτισσα τριποντάς τριρίσι τρισάγιο τρισάγιον τρισεκατομμύριο
τρισκόταδο τρισταυρία τριταγωνίστρια τριτανακοπή τριτεγγυήτρια τριτεγγυητής
τριτεγγύησις τριτενέργεια τριτεξάδελφος τριτεξαδέλφη τριτημόριον τριτόκλιτο
τριφαινυλένιο τριφωνία τριφωσφορυλίωση τριφωσφορύλιο τριφύλλι τριχάρα τριχίας
τριχίασις τριχίτσα τριχιά τριχλωρίδιο τριχομονάδα τριχομονάς τριχοτιλλομανία
τριχοτσίμπιδο τριχοτόμηση τριχοτόμησις τριχοφάγος τριχοφυΐα τριχοφυτία
τριχρωμία τριχόπτωση τριχόπτωσις τριχόφυτο τριψιάνα τριψιλίτης τριωδία
τριόδι τριόδια τριώδιο τριώνυμο τριώνυμον τριώροφο τροβάς τροβαδούρος τροκάνα
τρολ τρολάρισμα τρολές τρολιά τρολλ τρομάρα τρομοδέμα τρομοκράτης τρομοκράτηση
τρομοκράτισσα τρομοκρατία τρομπάρισμα τρομπέτα τρομπετίστας τρομπονίστας
τροπάρι τροπάριο τροπάριον τροπή τροπαράκι τροπικοποίηση τροπικότητα τροπισμός
τροπονίνη τροποποίηση τροποποίησις τροπωτήρ τροπωτήρα τροπόσφαιρα τροτέζα
τροτσκισμός τροτσκιστής τρουβάς τρουλίσκος τρουμπέτα τροφή τροφαλλαγή τροφεία
τροφοδοσία τροφοδοτικό τροφοδότης τροφοδότηση τροφοδότησις τροφοδότρια
τροφοκρίτης τροφολογία τροφοπενία τροφοσυλλέκτης τροφοτροπισμός τροφός
τροχίλος τροχίσκος τροχαία τροχαίος τροχαδάκι τροχαλία τροχασμός τροχείο
τροχιά τροχιακό τροχιογέφυρα τροχιογράφος τροχιοδείκτης τροχιοδείχτης
τροχιστήριον τροχιστής τροχιστικά τροχιτζής τροχιόδρομος τροχοβίλα τροχοδίοδος
τροχοεμποδιστήρας τροχονόμισσα τροχονόμος τροχοπέδη τροχοπέδηση τροχοπέδησις
τροχοπέδιλον τροχοπεδητής τροχοπεδιλοδρομία τροχοποιός τροχοτεχνίτης τροχοφόρο
τροχόδρομος τροχός τροχός τροχόσπιτο τροϊκανός τρούλα τρούλος τρούπα τρούφα
τρυγία τρυγητής τρυγητός τρυγιά τρυγλοδυτισμός τρυγονάκι τρυγονάκια
τρυγόνα τρυγόνι τρυκ τρυπάνι τρυπάνισμα τρυπίτσα τρυπαλάκι τρυπανισμός
τρυπητό τρυπογάζι τρυποκάρυδο τρυπούλα τρυπτοφάνη τρυσμός τρυφή τρυφεράδα
τρυφερολόγημα τρυφερότης τρυφερότητα τρυφερότητες τρυφηλότης τρυφηλότητα
τρωγάλια τρωγλοδύτης τρωγλοδύτισσα τρωκτικό τρόικα τρόκι τρόλεϊ τρόμαγμα
τρόμπα τρόμπα μαρίνα τρόπαιο τρόπαιον τρόπιδα τρόπις τρόπος τρόφιμα τρόφιμο
τρόχαλο τρόχαλος τρόχιλος τρόχισμα τρόχος τρύγημα τρύγηση τρύγησις τρύγος
τρύπανον τρύπημα τρύπωμα τρώας τρώγλη τρώες τρώσις τσάγαλο τσάι τσάκα τσάκιση
τσάκνο τσάκωμα τσάμι τσάμικο τσάμικος τσάμπουρο τσάντα τσάπα τσάπερο τσάπινγκ
τσάρεβιτς τσάρκα τσάρλεστον τσάρος τσάρτερ τσάσκα τσάταλο τσάτισμα τσάτσα
τσάφκα τσάχαλο τσέλιγκας τσέλο τσέμπαλο τσέπη τσέπωμα τσέργα τσέρι τσέρκι
τσέτουλα τσέτουλας τσέχα τσέχικα τσέχος τσίγκος τσίκλα τσίκνα τσίκνισμα
τσίλια τσίμπημα τσίμπλα τσίμπλιασμα τσίνισμα τσίνορα τσίνορο τσίνουρα τσίνουρο
τσίπουρο τσίριγμα τσίρισμα τσίρκο τσίρκουλο τσίρλα τσίρλισμα τσίρος τσίσα
τσίτι τσίτωμα τσίφτης τσίφτισσα τσίχλα τσα-τσα-τσά τσαΐρι τσαέρα τσαγάκι
τσαγερό τσαγιέρα τσαγιερό τσαγκάρης τσαγκάρικο τσαγκαράδικο τσαγκαροδευτέρα
τσαγκρούνισμα τσακ τσακάλι τσακίδια τσακίρ τσακίρης τσακίσματα τσακίστρα
τσακμάκι τσακμακόπετρα τσακνάκι τσακουμάκι τσακωμός τσαλάκωμα τσαλί τσαλίμι
τσαλαβούτημα τσαλαβούτι τσαλακωγραφία τσαλαπάτημα τσαλαπετεινός τσαλιμάκι
τσαμασίρια τσαμπάκι τσαμπάς τσαμπί τσαμπουκάς τσαμπουκαλής τσαμπουκαλίκι
τσαμπουνιέρης τσαμπουράκι τσαμπούνα τσαμπούνημα τσαμπούνισμα τσαμόρο τσανάκα
τσανακαλιώτης τσανακογλείφτης τσαντάκι τσαντάκιας τσαντίλα τσαντίλας τσαντίρι
τσαντόρ τσαουλί τσαουλιά τσαούσα τσαούσης τσαούσω τσαπέλα τσαπί τσαπαρί
τσαπερδόνα τσαπράζι τσαπραζολόγος τσαρίνα τσαρδάκι τσαρδί τσαρισμός τσαρλατάνα
τσαρλατανιά τσαρλατανισμός τσαρουχάδικο τσαρουχάς τσαρούχι τσαρσί τσατάλι
τσατίλα τσατίλας τσατμάς τσατσάρα τσατσοπαναγιά τσαχπινιά τσαχπινογαργαλιάρης
τσεβρές τσεγιέν τσεκ τσεκ απ τσεκάπ τσεκάρισμα τσεκίνι τσεκουλατούρα
τσεκουριά τσεκούρι τσεκούρωμα τσελίκι τσελίστας τσελεμεντές τσελεμπής
τσεμπέρι τσεμπαλίστας τσεντέσιμα τσεπάκι τσερβέλο τσερόκι τσεσμές τσετσένος
τσεχικά τσεχοσλοβάκος τσεύδισμα τσηρώτο τσι τσιάφκα τσιακκούιν τσιαμπάς τσιβί
τσιγαράδικο τσιγαράκι τσιγαρίδες τσιγαριλίκι τσιγαροθήκη τσιγαρούμπα
τσιγαρόχαρτο τσιγγάνα τσιγγάνικα τσιγγάνος τσιγγανάκι τσιγγανοπεχλιβάνης
τσιγκέλι τσιγκογράφος τσιγκογραφία τσιγκολελέτα τσιγκουνιά τσιγκούναρος
τσικνιάς τσικουδιά τσικρίκι τσικό τσιλίκα τσιλίκι τσιλημπούρδημα
τσιληπούρδημα τσιληπούρδισμα τσιλιαδόρος τσιλιβήθρα τσιλιμπουρδιάρης τσιμέντο
τσιμεντάδικο τσιμεντάκι τσιμεντάρισμα τσιμεντάς τσιμεντένεση τσιμενταυλάκι
τσιμεντοένεση τσιμεντοβιομηχανία τσιμεντοκονία τσιμεντοσανίδα τσιμεντόλιθος
τσιμινιέρα τσιμουδιά τσιμούχα τσιμπίδα τσιμπίδι τσιμπηματάκι τσιμπηματιά
τσιμπιδάκι τσιμπολόγημα τσιμπουκάκι τσιμπουκλής τσιμπουκλού τσιμπούκι
τσιμπούρι τσιμπούσι τσιντσιλά τσιπ τσιπάκι τσιπουράκι τσιπουρίτσα
τσιπουρομεζές τσιπούρα τσιπροκατάνυξη τσιπρομεζές τσιπροφονιάς τσιράκι τσιρίδα
τσιρίσι τσιριγώτης τσιριμόνια τσιριχτό τσιρλητό τσιρλιό τσιρτσιπλάκης τσιρότο
τσιτάκι τσιτάτο τσιτάχ τσιτακισμός τσιτσέκι τσιτσί τσιτσίρισμα τσιτσιμπίρα
τσιφλικάς τσιφλικούχος τσιφουτιά τσιφούτα τσιφούτης τσιφούτισσα τσιφτές
τσιχλίτσα τσιχλοποταμίδα τσιχλόφουσκα τσιόφτα τσογλάνι τσογλανάκι τσογλαναράς
τσοκ τσοκαρία τσολιάς τσομπάνης τσοντάρισμα τσοπάνης τσοπάνισσα τσοπάνος
τσοπανοπούλα τσοπανόπουλο τσοπανόσκυλο τσορβάς τσορμπατζής τσουάνα τσουβάλι
τσουβαλάκι τσουβαλιά τσουβασικά τσουγκράνα τσουγκράνισμα τσουγκρανιά τσουκ
τσουκάλι τσουκάνι τσουκαλάδικο τσουκαλάκι τσουκαλάς τσουκαλιά τσουκνίδα
τσουλάκι τσουλήθρα τσουλί τσουλίτσα τσουλούφι τσουμπλέκι τσουμπρίτσα τσουνάμι
τσουράπα τσουράπι τσουράπια τσουράπω τσουρέκι τσουρομάδημα τσουρούλι
τσουτσέκι τσουτσουνόβεργα τσουτσουρλίγκα τσουτσού τσουτσούνα τσουτσούνι
τσοχανταραίος τσούγκρισμα τσούλα τσούλι τσούξιμο τσούπα τσούπρα τσούρα τσούρμο
τσυρ τσυρά τσόγκα τσόγλανος τσόκαρο τσόκι τσόλι τσόντα τσόπστικ τσότρα τσόφλι
τταβάς τυλιγάδι τυλιγάδιασμα τυλικτήρας τυλιχτάρι τυλιχτήρας τυμβωρυχία
τυμπάνισμα τυμπάνωση τυμπανίστρια τυμπανίτιδα τυμπανιέρα τυμπανισμός
τυμπανοκρουσία τυμπανοκρούστης τυνήσια τυνήσιος τυπάκος τυπάς τυπικάρης
τυπικό τυπικόν τυπικότης τυπικότητα τυποβαφία τυπογράφος τυπογραφία
τυπογραφείον τυπογραφικό τυποκλοπία τυποκλόπος τυποκρατία τυπολάτρης
τυπολάτρισσα τυπολατρία τυπολογία τυπομάχος τυποποίηση τυποποίησις
τυποσκόπιο τυπωθήτω τυπωτής τυράγνια τυράγνισμα τυράδικο τυράκι τυράννισμα
τυρέμπορος τυρί τυρίλα τυρίνη τυραννία τυραννίδα τυραννίσκος τυραννοκτονία
τυραννόσαυρος τυρεμπόριο τυρεμπόριον τυριέρα τυρναβίτης τυροβούτυρο τυροβόλι
τυροδοχείο τυροδόχη τυροκαυτερή τυροκομία τυροκομείο τυροκομείον τυροκροκέτα
τυρομαντεία τυροπιτάδικο τυροπιτάκι τυροπιτάς τυροπωλείο τυροπώλης τυροσίνη
τυρόβολο τυρόγαλα τυρόγαλο τυρόγαλον τυρόπηγμα τυρόπιτα τυρός τυρόσουπα
τυτώ η λευκή τυφέκιον τυφεκήθρα τυφεκιοφόρος τυφεκισμός τυφλίνος τυφλίτης
τυφλοκομείο τυφλοπόντικας τυφλοσούρτης τυφλόμυγα τυφλότητα τυφώνας τυχαίο
τυχαιότητας τυχεράκιας τυχερό τυχερός τυχευρεσία τυχηροπαιξία τυχηρός τυχισμός
τυχοδιώκτης τυχοδιώκτις τυχοδιώκτρια τυχοδιώχτης τυχοδιώχτρια τυχοπαιξία τόγα
τόκα τόκος τόλμη τόλμημα τόμαχοκ τόμος τόμπολα τόννος τόνωση τόνωσις τόξεμα
τόξευση τόξο τόπακας τόπι τόπλες τόπος τόρευμα τόρευση τόρμος τόρνεμα τόρνευση
τόρνος τόφος τόφου τύλιγμα τύλιξη τύλιξις τύλος τύλωμα τύμβος τύμπανο τύπισσα
τύπωμα τύπωση τύπωσις τύραννος τύρβη τύρφη τύφη τύφλα τύφλωση τύφος τύφωση
τύψη τύψις τώρα υάκινθος υάλωμα υάρδα υαλικά υαλικό υαλοβάμβακας υαλοβερνίκωμα
υαλοβολή υαλοβολείο υαλογράφημα υαλογράφος υαλογραφία υαλοειδεκτομή
υαλοκατασκευή υαλομέταξα υαλοπέτασμα υαλοπίνακας υαλοπίναξ υαλοποίηση
υαλοπωλείο υαλοπωλείον υαλοπώλης υαλοστάσιο υαλοστάσιον υαλοσφαιρίδιο
υαλοτεχνία υαλοτεχνική υαλουργία υαλουργείο υαλουργείον υαλουργός
υαλοφυσητής υαλούργημα υαλωτό υαλόκοκκος υαλόλιθος υαλόπαγος υαλόπλασμα
υαλότουβλο υαλόχαρτον υβρίδιο υβρίδιον υβρίστρια υβρεολογία υβρεολόγιο
υβρεοφοβία υβριδισμός υβριδοποίηση υβριδοποίησις υβριστής υγεία υγειά
υγειονολογία υγειονολόγος υγειονομία υγειονομείο υγειονομικό υγειονομικός
υγιεινή υγιεινολογία υγιεινολόγος υγιός υγραέριο υγραεριοφόρο υγραντήρας
υγροβιότοπος υγρογράφος υγρολογία υγρομετρία υγρομόνωση υγροποίηση υγροσκοπία
υγροσκόπιο υγροστάτης υγροταξία υγροτροπισμός υγρό υγρόμετρο υγρόπισσα
υγρότοπος υδατάνθρακας υδατάνθραξ υδαταέριο υδαταγωγός υδαταποθήκη
υδατογράφος υδατογραφία υδατοδεξαμενή υδατοδρόμιο υδατοκαθαρισμός
υδατοκομία υδατολογία υδατομέτρηση υδατομετρία υδατοπέδιο υδατοπνεύμονας
υδατοπρομήθεια υδατορρεύμα υδατοσκοπία υδατοστεγανότητα υδατοστρόβιλος
υδατοσφαίριση υδατοσφαιριστής υδατοφράκτης υδατοφράχτης υδατόμετρο υδατόπτωση
υδατόσημο υδατόστρωμα υδατόσφαιρα υδράργυρος υδρία υδρίδιο υδραία υδραίος
υδραγωγός υδραζίνη υδραιμία υδραντλία υδραργυρίαση υδραργυραλοιφή υδραργύρωμα
υδρατμός υδραυλική υδραυλικός υδραύλακα υδρείο υδροβιολογία υδροβιότοπος
υδρογέλη υδρογέφυρα υδρογεννήτρια υδρογεωλογία υδρογνώμων υδρογονάνθρακας
υδρογονοπυρόλυση υδρογονοσταγονίδιο υδρογραφία υδρογόνο υδρογόνωση υδροδείκτης
υδροδιάλυση υδροδοχείο υδροδυναμική υδροδυναμικότητα υδροδότηση
υδροθήκη υδροθεραπεία υδροθεραπευτήριο υδροθώρακας υδροκήλη υδροκαθαρισμός
υδροκεφαλία υδροκεφαλικός υδροκεφαλισμός υδροκινητήρας υδροκλιματολογία
υδροκρίτης υδροκυάνιο υδροκύστωμα υδρολήπτης υδρολίπανση υδρολίσθηση
υδροληψία υδρολισθητήρας υδρολογία υδρολυσία υδρολόγος υδρομάστευση
υδρομέδουσα υδρομέτρηση υδρομαντεία υδρομασάζ υδρομεταλλουργία υδρομετρία
υδρομηχανική υδρονομέας υδρονομή υδρονομείο υδροξίδιο υδροξείδιο υδροξύλιο
υδροπλάνο υδροπληξία υδροπονία υδροποσία υδροπτέρυγο υδρορηγμάτωση υδρορροή
υδρορωγμάτωση υδροσκοπία υδροσκόπος υδροστάθμη υδροστάσιο υδροστάτης
υδροστρόβιλος υδροσυλλογή υδροσωλήνας υδροταμιευτήρας υδροτεχνία υδροτεχνική
υδροτριβή υδροτροπισμός υδροτροχός υδροφιλία υδροφοβία υδροφορία υδροφορικός
υδροφράχτης υδροφόιλ υδροφόρα υδροφόρο υδροχλωρίδιο υδροχλώριο υδροχρωμάτισμα
υδροχρωματιστής υδροχόη υδροψύκτης υδροϊώδιο υδρωνυμία υδρωνύμιο υδρωπικία
υδρόγειος υδρόζωα υδρόθειο υδρόλυση υδρόμελι υδρόμελο υδρόμετρο υδρόμυλος
υδρόρνις υδρόσφαιρα υδρόφυτα υδρόφυτο υδρόφωνο υδρόχρωμα υδρόψυξη υεμένιος
υιοθέτηση υιοθεσία υιός υλίστρια υλακή υλικοκατασκευαστική υλικό υλικότητα
υλισμός υλιστής υλοδοξία υλοενέργεια υλοζωία υλοζωίστρια υλοζωισμός υλοζωιστής
υλοποίηση υλοτομία υλοτόμηση υλοτόμος υμέναιος υμένας υμενίδιο υμενοπλαστική
υμενόπτερα υμνήτρια υμνητής υμνογράφος υμνογραφία υμνολογία υμνολόγηση
υμνολόγιον υμνολόγος υμνωδία υμνωδός υνί υνίον υπάκουος υπάλληλος υπάνθρωπος
υπάντησις υπάρχοντα υπέδαφος υπένδυση υπέρβαρο υπέρβαση υπέρβασις υπέρεισμα
υπέρθεση υπέρθεσις υπέρθημα υπέρθυρο υπέρθυρον υπέρμαχος υπέρπτηση υπέρταση
υπήκοος υπίατρος υπίλαρχος υπαγωγή υπαγόρευση υπαινιγμός υπαισθησία υπαιτιότης
υπακοή υπακτικό υπαλλαγή υπαλληλάκος υπαλληλία υπαλληλίκι υπαλληλίσκος
υπαμοιβή υπανάπτυξη υπανάπτυξις υπαναχώρηση υπαναχώρησις υπανδρεία
υπαρξίστρια υπαρξισμός υπαρξιστής υπαρχηγία υπαρχηγός υπασπιστήριο
υπασπιστής υπαστυνόμος υπασφάλιση υπαταίος υπατεία υπεγγυότητα υπεγγύηση
υπεζωκώς υπεκμίσθωση υπεκφυγή υπεμνήμονας υπενδύτης υπενθύμιση υπενθύμισις
υπενοικίασις υπενοικιάστρια υπενοικιαστής υπενωμοτάρχης υπεξάρθρημα υπεξαίρεση
υπεξαγωγή υπεξαιρέτης υπεξουσιότης υπεξουσιότητα υπεράνθρωπος υπεράσπιση
υπερέκθεση υπερέκκριση υπερέκκρισις υπερέκπτωση υπερέκταση υπερένταση
υπερήλικας υπερήλικος υπερήρωας υπερίδρωση υπερίδρωσις υπερίσχυση υπερίσχυσις
υπεραγωγιμότητα υπεραερισμός υπεραθλητής υπεραιμία υπεραιμοσφαιρία
υπεραισθητό υπεραισθητότητα υπερακόντιση υπεραλίευση υπεραλιεία υπερανάληψη
υπεραναμονή υπεραναπλήρωση υπεραντικείμενο υπεραντιστάθμιση υπεραξία
υπεραπασχόλησις υπεραπλούστευση υπεραπόσβεση υπεραρμογή υπερασπίστρια
υπερασφάλιση υπερασφάλισις υπεραυτοκίνητο υπεραφθονία υπεραύξηση υπεραύξησις
υπερβασία υπερβατικότητα υπερβιταμίνωση υπερβιταμίνωσις υπερβολή υπερβόσκηση
υπεργλυκαιμία υπεργλυκαιμικός υπεργολάβος υπεργολαβία υπερδέσμευση
υπερδιάστημα υπερδιέγερση υπερδιέγερσις υπερδιήθηση υπερδιασπορέας
υπερδιεγερσιμότητα υπερδομή υπερδύναμη υπερεγώ υπερεθνικιστής υπερεθνικότητα
υπερεκτίμηση υπερεκτίμησις υπερεκχείλιση υπερεκχείλισις υπερενθουσιασμός
υπερεπάρκεια υπερεπένδυση υπερεπίπεδο υπερεργασία υπερευαισθησία υπερεφαρμογή
υπερηρωίδα υπερηφάνεια υπερηχογράφημα υπερηχογράφος υπερηχογραφία
υπερηχοκαρδιογραφία υπερθέαμα υπερθέρμανση υπερθεμάτιση υπερθεμάτισις
υπερθεματιστής υπερθερμία υπερθυμία υπερθυρεοειδισμός υπεριδρωσία υπερικέλαιο
υπερκέραση υπερκέρασις υπερκέρδος υπερκαλλιέργεια υπερκατανάλωση
υπερκατασκευή υπερκείμενο υπερκεράτωση υπερκορεσμός υπερκοστολόγηση υπερκράτος
υπερκόπωσις υπερλίπωση υπερλίπωσις υπερλειτουργία υπερλιπιδαιμία
υπερμετρωπία υπερμικρόβιο υπερμνήμων υπερμνησία υπερμόλυνση υπερμόχλευση
υπερνίκησις υπερομάδωση υπερομιλών υπερομοταξία υπεροξείδιο υπεροξείδιον
υπερορία υπεροργανισμός υπερουσιότης υπερουσιότητα υπεροχή υπεροψία υπερπέραν
υπερπήδησις υπερπανσέληνος υπερπαραγωγή υπερπαραθυρεοειδισμός υπερπαστερίωση
υπερπατριώτης υπερπλήρωση υπερπλήρωσις υπερπλασία υπερπληθυσμός
υπερπολυτέλεια υπερπροβολή υπερπροσπάθεια υπερπροστασία υπερπροστατευτισμός
υπερρεαλίστρια υπερρεαλισμός υπερρεαλιστής υπερσίτιση υπερσίτισις υπερσιτισμός
υπερστήριξη υπερστροφή υπερσυγκέντρωση υπερσυμμετρία υπερσυμπάντωση
υπερσυνέπεια υπερσυντέλικος υπερσυνταγογράφηση υπερσωματίδιο υπερσύνδεση
υπερσύντοφος υπερσύντροφος υπερτάξη υπερτέρηση υπερτίμημα υπερτίμηση
υπερτασικός υπερτιμολόγηση υπερτονία υπερτονισμός υπερτρίχωση υπερτρίχωσις
υπερτροφία υπερτροφοδότης υπερτόνιση υπερτύπος υπερυπνία υπερυπολογιστής
υπερυπουργός υπερφαγία υπερφαλάγγιση υπερφεγγάρι υπερφιλελευθερισμός
υπερφυσική υπερφυσικό υπερφόρτιση υπερφόρτισις υπερφόρτωση υπερφόρτωσις
υπερχείλισις υπερχειλιστής υπερχλωρυδρία υπερχορδή υπερχρέωση υπερχρονισμός
υπερψήφιση υπερψήφισις υπερωκεάνιο υπερωρία υπερωρίμανση υπερωρίμανσις
υπερόπτης υπερόπτις υπερόπτισσα υπερύψωση υπερύψωσις υπερώα υπερώνυμο υπερώο
υπευθυνότης υπευθυνότητα υπηκοότης υπηκοότητα υπηρέτης υπηρέτηση υπηρέτησις
υπηρεσία υπηρετριούλα υπνάκος υπνίατρος υπναράς υπναρού υπνηλία υπνοβάτης
υπνοβάτισσα υπνοβασία υπνοβότανο υπνοδωμάτιο υπνοδωμάτιον υπνοθάλαμος
υπνοθεραπευτής υπνοθεραπεύτρια υπνολαλιά υπνολόγος υπνοπερίοδος υπνοφαντασία
υπνοφοβία υπνωτήριο υπνωτήριον υπνωτίστρια υπνωτικά υπνωτικός υπνωτισμός
υπνόσακος υπνώτιση υπνώτισις υποέκθεση υποέργο υποαπασχόληση υποατομικότητα
υποβάσταξη υποβίβαση υποβίβασις υποβιβασμός υποβιταμίνωση υποβιταμίνωσις
υποβλητικότητα υποβοήθηση υποβολέας υποβολή υποβολείο υποβολείον υποβολεύς
υποβρύχιον υπογάστριο υπογάστριον υπογένειο υπογένειον υπογαλακτία υπογείωση
υπογεννητικότητα υπογλυκαιμία υπογλυκαιμική υπογλυχαιμία υπογοναδισμός
υπογράμμιση υπογράμμισις υπογραμμή υπογραμμός υπογραφή υποδήλωση υποδήλωσις
υποδαυλιστής υποδαύλιση υποδαύλισις υποδαύλισμα υποδεκάμετρο υποδεκάμετρον
υποδεκανεύς υποδετήριον υποδηματοκαθαριστής υποδηματοποιία υποδηματοποιείο
υποδηματοποιός υποδηματοπωλείο υποδηματοπωλείον υποδηματοπώλης υποδιαίρεση
υποδιαστολή υποδιευθυντής υποδιευθύντρια υποδιεύθυνση υποδιεύθυνσις υποδικία
υποδιοίκηση υποδιοίκησις υποδιοικήτρια υποδιοικητής υποδομή υποδοχέας υποδοχή
υποδούλωση υποδούλωσις υποδόση υποείδος υποεκμετάλλευση υποεκπροσώπηση
υποενότητα υποεπένδυση υποεπιτροπή υποεργολάβος υποζύγιο υποζύγιον υποθάλαμος
υποθήκευση υποθήκευσις υποθήκη υποθεμέλιος υποθεμέλιος υποθεματοφύλακας
υποθηκοφυλάκιο υποθηκοφυλακείο υποθηκοφυλακείον υποθηκοφύλακας υποθηκοφύλαξ
υποκάμισο υποκίνηση υποκίνησις υποκαλιαιμία υποκαλλιέργεια υποκαπνισμός
υποκατάστασις υποκατάστατο υποκατάστημα υποκατανάλωση υποκατανάλωσις
υποκατηγορία υποκείμενο υποκείμενον υποκειμενικότης υποκειμενικότητα
υποκελευστής υποκινήτρια υποκινησία υποκινητής υποκλάση υποκλοπέας υποκλοπή
υποκορισμός υποκοριστικό υποκοριστικόν υποκουλτούρα υποκρίτρια υποκρισία
υποκριτική υποκριτικότης υποκριτικότητα υποκτηνίατρος υποκόμης υποκόμισσα
υπολειτουργία υπολογίστρια υπολογισιμότητα υπολογισμός υπολογιστής υπολοχαγός
υπομήτρα υπομίσθωση υπομίσθωσις υπομειδίαμα υπομητρώο υπομηχανικός υπομισθωτής
υπομνημαστιστής υπομνηματισμός υπομοίραρχος υπομονάδα υπομονή υπομονετικότητα
υπομόχλευσις υπομόχλιο υπομόχλιον υποναύαρχος υπονομευτής υπονομεύτρια
υπονόμευση υπονόμευσις υποξείδιο υποοικογένεια υποομάδα υποπίεση
υποπαραχώρηση υποπερίοδος υποπλασία υποπλοίαρχος υποπολιτισμός υποπολλαπλάσιο
υποπρακτορείο υποπρακτορείον υποπρολεταριάτο υποπροξενείο υποπροξενείον
υποπροϊόν υποπρόγραμμα υποπρόξενος υποπτέραρχος υποπόδιο υπορουτίνα υποσέλιδο
υποσήμανση υποσίτιση υποσαρκοφάγο υποσαχάριος υποσημείωση υποσημείωσις
υποσιτισμός υποσκέλιση υποσκέλισις υποσκίαση υποσκίασις υποσκίασμα υποσκαφή
υποσμία υποσμηνίας υποσμηναγός υποσπαδίας υποστάθμη υποστάτης υποστέγασμα
υποστήριξη υποστήριξις υποσταθμός υποστασιοποίηση υποστατικό υποστατικόν
υποστηρίκτρια υποστηρίχτρια υποστηρικτής υποστηριχτής υποστιγμή υποστολή
υποστροφή υποστύλωμα υποστύλωση υποσυμπάντωση υποσυνείδητο υποσυνείδητον
υποσχετικό υποσχετικόν υποσύμπαν υποσύνολο υποσύστημα υποτάξη υποτέλεια
υποτίμηση υποτίμησις υποταγή υποταγματάρχης υποτακτική υποτακτικός
υποταμείο υποταχτική υποτείνουσα υποτελής υποτιμολόγηση υποτιτλισμός υποτονία
υποτραχήλιο υποτραχήλιον υποτριγμός υποτροπή υποτροπίαση υποτροπιασμός
υποτύπωση υπουλότης υπουλότητα υπουρίδα υπουρίς υπουργία υπουργίνα υπουργείο
υπουργοποίηση υπουργός υποφαινόμενο υποφορά υποφρούραρχος υποφόρτωση υποχείριο
υποχονδριακός υποχοντρία υποχρέωση υποχρέωσις υποχρεωτικότητα υποχρεωτικώς
υποχρωμία υποχωρητικότητα υποχώρηση υποχώρησις υποψία υποψηφιότης υποψηφιότητα
υπούργημα υπτίασις υπτιασμός υπωνυμία υπωνυμοποίηση υπόβαθρο υπόβαθρον υπόγειο
υπόγειος υπόδειγμα υπόδειξη υπόδειξις υπόδερμα υπόδεσις υπόδημα υπόδηση
υπόδικας υπόζωμα υπόηχος υπόθαλψη υπόθαλψις υπόθεμα υπόθεση υπόθεσις υπόθετο
υπόκαυστο υπόκεντρο υπόκλιση υπόκλισις υπόκοσμος υπόκριση υπόκρουση υπόκρυψις
υπόληψη υπόληψις υπόλοιπο υπόλοιπον υπόμνημα υπόμνηση υπόμνησις υπόνοια
υπόραχη υπόρραμμα υπόσαθρος υπόσκαψη υπόσταση υπόστασις υπόστεγο υπόστεγον
υπόσχεση υπόσχεσις υπόταξη υπόταξις υπόταση υπότιτλος υπόφραγμα υπόφυση
υπώνυμο υπώρεια υστέρα υστέρημα υστέρηση υστερία υστεραλγία υστερεκτομή
υστεροβουλία υστερολογία υστεροπτωσία υστεροτοκία υστεροφημία υστερόγραφο
υστερόπονοι υττέρβιο υφάδι υφάκι υφάντρα υφάντρια υφέν υφή υφήλιος υφαίρεση
υφαλμύρωση υφαλοδείκτης υφαλοδείχτης υφαλοκρηπίδα υφαλοκρηπίς υφαλοχρωματισμός
υφαντήριο υφαντήριον υφαντής υφαντική υφαντουργία υφαντουργείο υφαντουργείον
υφαρπαγή υφασματέμπορος υφασματεκτύπωση υφασματοσκόπιο υφασματοτυπία υφηγήτρια
υφηγητής υφιστάμενος υφολογία υφομοταξία υφυπουργείο υφυπουργείον υφυπουργός
υψίπεδο υψίπεδον υψίρρυθμος υψίστρωμα υψίφωνος υψηλοτάτη υψηλοφροσύνη
υψηλότης υψηλότητα υψικάμινος υψισωρείτης υψιφραγμός υψομέτρηση υψομετρία
υψόμετρο υψόμετρον φ1 φάβα φάγαινα φάγναλο φάγουσα φάγρος φάγωμα φάδι φάδο
φάκελο φάκελος φάκνα φάλαγγα φάλαγγα φάλαγγας φάλαινα φάλαρα φάλι φάλτσο
φάνταγμα φάνταξη φάντασμα φάντες φάντης φάντο φάουλ φάουσα φάπα φάρα φάρδεμα
φάρμα φάρμακο φάρος φάρσα φάρσωμα φάρυγγας φάσα φάσγανο φάση φάσκελο φάσκιωμα
φάτα μοργκάνα φάτνη φάτνωμα φάτνωση φάτνωσις φάτουα φάτσα φέγγος φέγγρισμα
φέλιασμα φέλπα φέξη φέξιμο φέουδο φέρετρο φέριγκ φέριμποτ φέρινγκ φέρμελη
φέρσιμο φέσι φέστα φέτα φέτας φέττα φήμη φίδι φίκος φίλαθλος φίλεμα φίλη
φίλιωμα φίλντισι φίλος φίλτρανση φίλτρο φίμωμα φίμωση φίμωσις φίμωτρο φίμωτρον
φίρμα φίστουλα φίτζι φίτζι χίντι φα φαΐ φαβιανισμός φαβισμός φαβορί φαβορίτα
φαβοριτισμός φαγάδικο φαγάκι φαγάνα φαγάς φαγέδαινα φαγέσωρας φαγί φαγγρί
φαγητό φαγητόν φαγιάνς φαγιάντσα φαγκρί φαγκότο φαγοκυττάρωση φαγοκυττάρωσις
φαγοκύττωση φαγοκύτωση φαγοπότι φαγούρα φαγωμάρα φαγωμός φαγόπυρο φαγώσιμα
φαγᾶς φαδίστα φαδίστας φαεινότης φαεινότητα φαιδρολογία φαιδρολόγημα
φαιλόνιο φαινοθειαζίνες φαινομενικότητα φαινομενισμός φαινομενογραφία
φαινομενολογία φαινομηρίδα φαινυλαλανίνη φαινυλκετονουρία φαινόγραμμα φαινόλη
φαινότυπος φαιοχρωμοκύττωμα φακέλωμα φακές φακή φακίδα φακίρης φακίρισσα
φακελίσκος φακελοκρατία φακελοποιία φακελοποιείο φακελοποιός φακιόλι φακλάνα
φακοσαλάτα φακοσκλήρωση φακοσκόπιο φακόμετρο φακός φακόσουπα φαλάγγι φαλάκρα
φαλάκρωμα φαλάκρωση φαλάκρωσις φαλάφελ φαλίρισμα φαλαγγάρχης φαλαγγίτης
φαλαινάκι φαλαιναλιευτικό φαλαινοθήρας φαλαινοθηρία φαλαινοθηρικό
φαλακροκόρακας φαλακρότητα φαλανστήριο φαλαρίδα φαλαρόποδας φαληριώτης
φαλκίδευση φαλκίδευσις φαλλί φαλλίατρος φαλλαϊτός φαλλοθήκη φαλλοθηκάρι
φαλλοκράτης φαλλοκρατία φαλλός φαλλόφλασκο φαλλῖτις φαλτσάρισμα φαλτσέτα
φαμ φατάλ φαμέγιος φαμίλια φαμελίτης φαμελίτισσα φαμελιά φαμελιάρης φαμιλιά
φαμπρικάντης φαμφαρόνος φαν φανάρι φανέλα φανέρωμα φανέρωση φανανάπτης
φαναράς φαναριτζής φαναριτζίδικο φαναριώτης φαναριώτισσα φαναρτζής
φαναρτζοδουλειά φανατισμός φανελάδικο φανελάκι φανελλάδικο φανελλοποιία
φανελλοποιός φανελοποιία φανελοποιείο φανελοποιός φανερωτής φανκ φανοκόρος
φανοποιός φανοστάτης φαντάρος φανταγμός φανταξιά φανταράκι φανταρία φαντασία
φαντασιακό φαντασιοκοπία φαντασιοκόπημα φαντασιοπληξία φαντασμαγορία
φαντεζίστας φαντομάς φανφάρα φανφαρονισμός φανφαρόνα φανφαρόνος φανός φαξ
φαράκλα φαράσι φαρέτρα φαρί φαρίνα φαρακλός φαρδομάνικο φαρδύπλωρο φαρισαίος
φαρμάκι φαρμάκωμα φαρμακέμπορος φαρμακίατρος φαρμακίλα φαρμακαποθήκη φαρμακεία
φαρμακεμπορία φαρμακεμπόριο φαρμακευτής φαρμακευτική φαρμακεύτρια
φαρμακοβιομηχανία φαρμακογνωσία φαρμακοδιέγερση φαρμακοδυναμική
φαρμακοθεραπεία φαρμακοκινητική φαρμακοληψία φαρμακολογία φαρμακολύτρια
φαρμακομούνα φαρμακοποιία φαρμακοποιός φαρμακοποσία φαρμακοτέχνης
φαρμακοτεχνική φαρμακοτρίφτης φαρμακοτριβείο φαρμακοφοβία φαρμακοφορείο
φαρμακοχημεία φαρμακόγλωσσα φαρμασονία φαρμασόνος φαρμπαλάς φαροδείκτης
φαρσέρ φαρσί φαρσοκωμωδία φαρυγγίτιδα φαρυγγίτις φαρυγγισμός
φαρυγγορραγία φαρυγγοσκόπιο φαρυγγοτομία φαρυγγωδυνία φαρφάλες φαρφάλω
φαρόπλοιο φασίνα φασίολος φασίστας φασίστρια φασαμέν φασαρία φασαρίας
φασιανός φασισμός φασιστάκι φασιστής φασισταράς φασισταριό φασιστοειδές
φασκέλωμα φασκελιά φασκιά φασκομηλιά φασκωλόμυς φασκόμηλο φασματογράφημα
φασματογραφία φασματοηλιογράφος φασματοηλιοσκόπιο φασματομετρία φασματοσκοπία
φασματοφωτόμετρο φασματόγραμμα φασματόμετρο φασολάδα φασολάκι φασολάκια
φασονατζής φασουλάδα φασουλάκια φασουλής φασουλιά φασουλοταβάς φασούλι
φαστ-φουντ φαστίδιο φαστφουντάδικο φαστφούντ φασόλι φασόλια φασόν φαταλίστρια
φαταλιστής φαταούλας φατνίο φατνίον φατούρα φατρία φατριασμός φατριαστής
φατσούλα φαυλοκράτης φαυλοκρατία φαυλοκόλακας φαυλότητα φαφλατάρισμα φαφλατάς
φαφλατού φαφούτα φαφούτης φαφούτισσα φεβρουαριανά φεγγάρι φεγγάριασμα
φεγγίτης φεγγαράδα φεγγαράκι φεγγαροβραδιά φεγγαρόπετρα φεγγαρόφωτο φεγγοβολή
φεγγοβόλημα φειδωλία φειδώ φελάφελ φελάχα φελάχος φελέκι φελί φελιζόλ φελλίνη
φελλοτάπητας φελλόδρυς φελλός φελούκα φελόνι φεμινίστρια φεμινισμός φεμινιστής
φενάκη φενάκιση φενακισμός φενακιστής φεντεραλισμός φεντεραλιστής φεντόρα
φεουδαλισμός φεουδαρχία φεουδαρχισμός φεουδοποίηση φερέφωνο φερέφωνον
φερεγγυότητα φερετζές φερετροποιείο φερετροποιείον φερετροποιός φεριμπότ
φερμιγένεση φερμιογένεση φερμιοταύτιση φερμιταύτιση φερμιόνιο φερμουάρ φερνή
φεροϊκά φερτάκιας φερωνυμία φεσάκι φεσατζής φεστιβάλ φεστόνι φετίχ φετβάς
φετιχισμός φετιχιστής φετιχολάτρης φετιχολάτρις φετιχολάτρισσα φετιχολατρία
φετφάς φευγάλα φευγάτισμα φευγιό φηγός φηκάρι φημολογία φθάσιμο φθήνια φθίση
φθαλοκυαννίνη φθείρα φθειρ φθειρίαση φθινοπώριασμα φθινόπωρο φθινόπωρον
φθισιατρείον φθογγογραφία φθογγολογία φθογγόγραμμα φθογγόσημο φθογγόσημον
φθορίαση φθορίτης φθορίωση φθορισμός φθόγγος φθόνος φθόριο φθόριον φι φιάλη
φιέστα φιαλίδιο φιαλοδόχη φιαλοδόχος φιαλοθήκη φιαλοποιείο φιανκέτο φιγουρίνι
φιγουρατζού φιγούρα φιδάκι φιδές φιδοβότανο φιδοπουκάμισο φιδοτόμαρο
φιδότρυπα φιδόχορτο φιζίκ φιλάκι φιλέ φιλέλληνας φιλέρι φιλές φιλέτο φιλί
φιλαλήθεια φιλαλληλία φιλαναγνωσία φιλαναγνώστης φιλαναγνώστρια φιλανδικά
φιλαποδημία φιλαράκι φιλαράκος φιλαρέσκεια φιλαργυρία φιλαρμονική φιλαρχία
φιλειρηνίστρια φιλειρηνικότητα φιλειρηνισμός φιλειρηνιστής φιλελευθερία
φιλελληνισμός φιλενάδα φιλεναδίτσα φιλεναδούλα φιλεραστία φιλεργία
φιλετάκι φιλευσπλαγχνία φιλευσπλαχνία φιληδονία φιληκοΐα φιλιέρα φιλιατρό
φιλικός φιλικότητα φιλιπίνος φιλιπινέζος φιλιππινέζικα
φιλιστρίνι φιλιστόκα φιλιόκβε φιλιότσο φιλλανδός φιλλυρέα φιλμ φιλμάρισμα
φιλοβασιλισμός φιλογυνία φιλογύνης φιλοδοξία φιλοδώρημα φιλοζωία φιλοζωική
φιλοκέρδεια φιλοκαλία φιλοκτημοσύνη φιλολογία φιλολογίνα φιλομάθεια φιλομουσία
φιλονεϊστής φιλονικία φιλονομία φιλοξενία φιλοξενούμενος φιλοπατρία
φιλοπονία φιλοποσία φιλοπραγμοσύνη φιλοπρωτία φιλοπότης φιλοπότις φιλοσοφία
φιλοσοφικότητα φιλοστοργία φιλοσόφημα φιλοσόφηση φιλοτέλεια φιλοτέχνημα
φιλοτίμηση φιλοτίμησις φιλοτεκνία φιλοτελίστρια φιλοτελισμός φιλοτελιστής
φιλοτιμία φιλοτομαρίστρια φιλοτομαρισμός φιλοτομαριστής φιλοφοβία φιλοφροσύνη
φιλοφρόνηση φιλοφρόνησις φιλοχρηματία φιλοψυχία φιλτράρισμα φιλυποψία
φιλωτίτισσα φιλόλογος φιλόνια φιλόσοφος φιλότεχνος φιλότης φιλότιμο φιλύρα
φινέτσα φινίρισμα φιναλίστ φινεστρίνι φινιστρίνι φινλανδικά φινλανδοποίηση
φιντάνι φιντανάκι φιντεϊσμός φινόκιο φιξάκι φιξάρισμα φιξατέρ φιογκάκι φιορίνι
φιούμπα φιρίκι φιρικιά φιρμάνι φις φισέκι φισεκλίκι φιστίκι φιστίκωμα φιστικάς
φιστικιά φιστικοβούτυρο φιστικοπώλης φιτίλι φιτζιανός φιτιλάτο φιτιλιά φιόγκος
φιόρε φιόρντ φιόρο φκιασίδι φκιασίδωμα φκυασίδι φλάμπουρο φλάντζα φλάουτο
φλάσκα φλέβα φλέγμα φλέμα φλίπερ φλίσι φλαμένκο φλαμίνγκο φλαμανδικά φλαμουριά
φλαουτίστα φλαουτίστας φλαουτίστρια φλαούνα φλαπ φλαπερόνι φλας φλας μπακ
φλασιά φλασκάκι φλασκί φλασκιά φλεβίτιδα φλεβίτις φλεβορραγία φλεβοτομία
φλεβόκομβος φλεγμονή φλεξογραφία φλερέ φλερτ φλερτάκι φλερτάρισμα φλερόβιο
φληνάφημα φλησκούνι φλιά φλιντζάνι φλιντζανάκι φλιπεράκι φλιπεράκια φλισκούνι
φλιτάρισμα φλιτζάνα φλιτζάνι φλιτζανάκι φλοίδα φλοίσβισμα φλοίσβος φλογέρα
φλογερότητα φλογισμός φλογιστόν φλογοβόλο φλογοβόλον φλογοκρύπτης φλογοσωλήνας
φλοιός φλοκάτα φλοκάτη φλοκωτή φλοξ φλοτέρ φλοτεράκι φλουοροαγγειογραφία
φλούδα φλούδι φλούφλης φλυαρία φλυκταίνωση φλυκταίνωσις φλυτζάνι φλωράτζα
φλωρινιώτης φλόγα φλόγισμα φλόγιστρο φλόγωμα φλόγωση φλόκα φλόκι φλόκιασμα
φλόκος φλόμιασμα φλόμος φλόμωμα φλόρι φλύκταινα φλύσχης φλώρι φλώρος φο μπιζού
φοίνιξ φοίτηση φοίτησις φοβέρα φοβέρισμα φοβία φοβισμός φοδράρισμα φοινίκι
φοινικέλαιο φοινικίδα φοινικιά φοινικόδασος φοινικόδενδρον φοινικόδεντρο
φοινικών φοινικώνας φοιτήτρια φοιτητάκος φοιτητής φοιτηταριό φοιτητοπατέρας
φοιτητόκοσμος φολίδα φολίς φολεγανδρίτης φολκλορισμός φολκλόρ φον ντε τεν
φονεύς φονιάς φονικό φονξιοναλισμός φοντάν φοντί φονταμενταλισμός
φοντράρισμα φοξ τεριέ φορ-πικ φορά φοράδα φορέας φορατζής φορβάς φορβή φορείο
φορεσιά φοριαμός φορμά φορμάικα φορμάκι φορμάρισμα φορμάτ φορμίτσα φορμαέλλα
φορμαλδεΰδη φορμαλισμός φορμαλιστής φορμούλα φορμόλη φοροαπαλλαγή φοροαποφυγή
φοροδιαφυγή φοροεισπράκτορας φοροεκκρεμότητα φοροελάφρυνση φοροελεγκτής
φοροκλέπτης φοροκλοπή φορολαίλαπα φορολογία φορολοταρία φορολόγηση φορομπήχτης
φοροοφειλέτρια φοροσαφάρι φοροσυνάχτης φοροτέχνης φοροτεχνικός φοροφαγάς
φοροφειλέτρια φοροφυγάδας φοροφυγάς φορτάμαξα φορτέτσα φορτίο φορτίον
φορτηγάκι φορτηγίδα φορτηγατζής φορτηγιδοφόρο φορτηγοναυτιλία φορτηγό
φορτιστής φορτοεκφορτωτής φορτοεκφόρτωση φορτοεκφόρτωσις φορτοθυρίδα
φορτσάδος φορτσάρισμα φορτσέρι φορτωτήρ φορτωτήρα φορτωτήρας φορτωτής
φορόσημο φορόσημον φουά γκρα φουαγέ φουαγιέ φουγάρο φουζάριο φουκαράκος
φουκαρατζίκος φουκαρού φουκού φουλ φουλάρι φουμάρισμα φουμαδόρισσα φουμαδόρος
φουντάνα φουντάρισμα φουντίτσα φουντουκέλαιο φουντουκιά φουντούκι φουράνιο
φουρκέτα φουρνάκι φουρνάρης φουρνάρικο φουρνάρισσα φουρνέλο φουρναριό φουρνιά
φουρνόξυλο φουρνόφτυαρο φουρούσι φουρτούνα φουρό φουρόγατα φουρόγατος φουσάτο
φουσκάλιασμα φουσκί φουσκίτσα φουσκαλίδα φουσκοδεντριά φουσκοθαλασσιά
φουσκωμάρα φουσκωμός φουσκωτό φουσκωτός φουστάνι φουστίτσα φουστανάκι
φουστανέλλα φουστανελάς φουστανελοφόρος φουτμπολίστας φουτμπόλ φουτουρίστρια
φουτουριστής φουφού φουφούλα φουχτιά φούβα φούγκα φούλι φούμα φούμαρα φούμαρο
φούμος φούντα φούντι φούντο φούντος φούντωμα φούντωση φούξια φούρια φούρκα
φούρναρης φούρνισμα φούρνος φούσκα φούσκισμα φούσκος φούσκωμα φούσκωση φούστα
φούχτα φούχτωμα φράγκιο φράγκο φράγμα φράκο φράκταλ φράκτης φράντζα φράξια
φράξο φράξος φράουλα φράπα φράση φράσις φράχτης φρέαρ φρέζα φρένα φρένες
φρένο φρέντο φρέον φρέσκο φρίζα φρίκη φρίμασμα φραγή φραγγέλιο φραγγέλλωσις
φραγγέλωση φραγκάκι φραγκάτος φραγκοδίφραγκα φραγκοκάστελο φραγκοκκλησιά
φραγκοκρατία φραγκολεβαντίνα φραγκολεβαντίνικα φραγκολεβαντίνος φραγκοναξιώτης
φραγκοπαπαδιά φραγκοράφτης φραγκοραφτάδικο φραγκοστάφυλο φραγκοσταφυλέλαιο
φραγκοσυκιά φραγκοσυριανή φραγκοσυριανός φραγκόκλησα φραγκόκοτα φραγκόπαπας
φραγκόφτυαρο φραγκόφωνος φραγματοθέτις φραγμός φρακάρισμα φρακοφορεμένος
φρακτό φραμασονία φραμασόνος φραμπαλάς φραμπουάζ φραντζολάκι φραντζολίτσα
φραξιονισμός φραξιονιστής φραουλέλαιο φραουλίτσα φραουλιά φραπέ φραπές
φραπεδιά φραπεδούμπα φραπελιά φραπόγαλο φρασεολογία φρασεολόγιο φρασεολόγιον
φρεάτιο φρεάτιον φρεατίς φρεατοτύμπανο φρεατωρύχος φρεγάδα φρεγάδιο φρεγάτα
φρεζάρισμα φρεζαδόρος φρενάρισμα φρενίτιδα φρενίτις φρεναδόρος φρεναπάτη
φρενοκομείο φρενοκομείον φρενολογία φρενολόγος φρενοπάθεια φρενοπαθολογία
φρεσκάρισμα φρην φριζάρισμα φριζικά φρικίαση φρικίασις φρικίασμα φρικαλεότης
φρικασέ φρικιάρης φρικιό φρικωδία φριμαγμός φριουλανικά φριτέζα φριτούρα
φροκάλισμα φροκαλίδι φροκαλιά φρονηματισμός φρονιμάδα φρονιμίτης φρονιμότης
φροντίδα φροντίς φροντιστήριο φροντιστήριον φροντιστής φρου φρου φρουί γκλασέ
φρουκτόζη φρουρά φρουραρχείο φρουραρχείον φρουρός φρουτάκι φρουτάκια
φρουταρία φρουτεμπόριο φρουτιέρα φρουτοθεραπεία φρουτονερόκοκκος
φρουτοποτό φρουτοσαλάτα φρουτοφαγία φρουτοχυμός φρουτόδεντρο φρουτόψωμο
φροϋδισμός φροϋδιστής φρούμασμα φρούραρχος φρούρηση φρούριο φρούριον φρούτο
φρυγάνισμα φρυγανιά φρυγανιέρα φρυγικά φρυγική φρυγμός φρυδάς φρυδού φρυκτωρία
φρόνημα φρόνηση φρόνησις φρύγανο φρύγανον φρύγας φρύδι φρύνος φτάρμισμα
φτάσιμο φτέρη φτέριασμα φτέρνα φτέρνισμα φτέρωμα φτήνια φταίξιμο φταίχτης
φταρμός φτειασίδι φτελιά φτερνιά φτερνιστήρι φτερνοκόπημα φτεροκόπημα φτερού
φτερούγισμα φτερωτή φτερό φτηνοδουλειά φτηνομάγαζο φτηνοπράματα φτηνόπραμα
φτιάξιμο φτιάσιμο φτιαξιά φτιασίδι φτιασίδωμα φτιαστικά φτιαχτικά φτυάρι
φτυαράκι φτυαριά φτυσιά φτυσιματικά φτωχαδάκι φτωχικό φτωχογειτονιά
φτωχοκόριτσο φτωχολογιά φτωχολόι φτωχομάγαζο φτωχομάνα φτωχομαχαλάς
φτωχοπλυσταριό φτωχοποίηση φτωχοπρόδρομος φτωχοφαγία φτωχοφαμελίτης
φτωχοφαμελιά φτωχόπαιδο φτωχόσπιτο φτύμα φτύσιμο φτύσμα φτώχεια φτώχεμα φτώχια
φυγάδευση φυγάδευσις φυγάς φυγή φυγοδικία φυγοκέντρηση φυγοκέντριση
φυγοκεντρωτής φυγομαχία φυγοπονία φυγοστρατία φυγόδικη φυγόδικος φυγόκοσμος
φυλάκα φυλάκιο φυλάκιση φυλάκισις φυλέτης φυλή φυλακή φυλακίς φυλακτήρας
φυλαχτάρι φυλαχτό φυλετικότης φυλετικότητα φυλετισμός φυλλάδα φυλλάδιο
φυλλάριον φυλλαράκι φυλλοβολή φυλλοβολία φυλλοβόλημα φυλλοκάρδι φυλλοκάρδια
φυλλομέτρημα φυλλομέτρηση φυλλοξέρα φυλλοξήρα φυλλορρόημα φυλλοταξία φυλλουριά
φυλλόρροια φυλογένεια φυλογένεση φυλογένεσις φυλογονία φυλομετάβαση φυμάτιο
φυματίνη φυματίωση φυματίωσις φυματιολογία φυματιολόγος φυντάνι φυραματοποιείο
φυσέκι φυσίατρος φυσίγγι φυσίγγιο φυσίγγιον φυσαλίδα φυσαλλίς φυσαρμόνικα
φυσεκλίκι φυσερό φυσηξιά φυσητήρ φυσητήρας φυσιατρική φυσιγγιοθήκη φυσική
φυσικοθεραπευτής φυσικοθεραπεύτρια φυσικομαθηματικός φυσικοπυρηνικός
φυσικού φυσικό φυσικός φυσικότης φυσικότητα φυσιμονισμός φυσιογνωμία
φυσιογνωμική φυσιογνωμιστής φυσιογνωσία φυσιογνώστης φυσιογνώστρια φυσιογράφος
φυσιοδίφης φυσιοθεραπεία φυσιοθεραπευτής φυσιοθεραπεύτρια φυσιοκράτης
φυσιολάτρης φυσιολάτρις φυσιολάτρισσα φυσιολατρία φυσιολογία φυσιολογία
φυσιομετρία φυσιοπαθολογία φυσοκάλαμο φυσομάνημα φυσομανητό φυσούνα φυτάνη
φυτεία φυτευτήρι φυτευτής φυτεύτρα φυτοβένθος φυτοβιβλιογραφία φυτοβιολογία
φυτογεωγραφία φυτογραφία φυτοζωία φυτοθεραπεία φυτοκοινωνία φυτοκομία
φυτοκομείον φυτοκόμος φυτολογία φυτολόγιο φυτολόγιον φυτολόγος φυτοπίλημα
φυτοπαθολόγος φυτοπαράσιτο φυτοπαράσιτον φυτοπλαγκτόν φυτοτεχνία φυτοτοξίνη
φυτοφάρμακον φυτοφαγία φυτοφράχτης φυτοϊολογία φυτοϋγεία φυτωνύμιο φυτό
φυτόλιθος φυτόν φυτόφθορα φυτόχωμα φυτόψειρα φυτώριο φυτώριον φωβισμός φωλίτης
φωλεά φωλεός φωλιά φωμοταινία φωνάκλα φωνάρα φωνή φωνήεν φωνίτσα
φωναγγειογραφία φωναγωγός φωναράς φωνασθένεια φωνασκία φωνασκός φωνασκός
φωνενδοσκόπηση φωνενδοσκόπιο φωνηεντισμός φωνητικά φωνητική φωνιατρική
φωνογράφηση φωνογράφος φωνογραφία φωνοκαρδιογράφημα φωνοκαρδιογράφος
φωνοληψία φωνολογία φωνομίμηση φωνομετρία φωνομιλητική φωνομιμητική φωνομοντάζ
φωνοσκόπιο φωνοσκόπιον φωνοσπασμία φωνοταινία φωνοφοβία φωνούλα φωνωδία
φωνόγραφος φωνόλιθος φωνόμετρο φωνόμετρον φωνόνιο φωρατής φωριαμός φως φωστήρ
φωσφάτωση φωσφατίνη φωσφογύψος φωσφορίωση φωσφορισμός φωσφοροσκόπιο
φωσφορύλιο φωσφόρισμα φωσφόρος φωτάκι φωτίκια φωτίνο φωτίτσα φωταέριο
φωταγωγός φωταγώγηση φωταγώγησις φωτακουστική φωταψία φωταύγεια φωτεινότης
φωτερό φωτιά φωτισμός φωτιστικό φωτο φίνις φωτοακουστική φωτοακρόαση
φωτοαντίγραφον φωτοαντιγραφικό φωτοβιολογία φωτοβολή φωτοβολία φωτοβολίδα
φωτοβόλημα φωτογένεια φωτογήρανση φωτογεωλογία φωτογονία φωτογράφημα
φωτογράφησις φωτογράφιση φωτογράφος φωτογραμμετρία φωτογραμμομετρία φωτογραφία
φωτογραφείον φωτογραφική φωτογραφομετρία φωτοδίκτυο φωτοδίοδος φωτοδότης
φωτοδότρα φωτοειδησεογραφία φωτοεξάχνωση φωτοευαισθησία φωτοηλεκτρισμός
φωτοθερμοθεραπεία φωτοκατάλυση φωτοκόπια φωτοκύτταρο φωτοκύτταρον φωτομετέωρο
φωτομετρία φωτομικρογραφία φωτομοντάζ φωτομοντέλο φωτονεφέλη φωτονική
φωτοπαγίς φωτοπεριοδισμός φωτοπλανήτης φωτοπολλαπλασιαστής φωτορεπορτάζ
φωτορομάντζο φωτοσβέστης φωτοσημαντήρας φωτοσκίαση φωτοσκίασις φωτοσκόπιο
φωτοστέφανος φωτοστοιχειοθεσία φωτοσφαίρα φωτοσύνθεση φωτοσύνθεσις φωτοταξία
φωτοτηλεγραφία φωτοτροπισμός φωτοτσιγκογράφος φωτοτσιγκογραφία φωτοτυπία
φωτοφοβία φωτοφοβικός φωτοφράκτης φωτοφωταύγεια φωτοχαλκοτυία φωτοχαρακτική
φωτοχρωμία φωτοχυσία φωτοϋποδοχέας φωτόλουτρο φωτόλουτρον φωτόλυση φωτόλυσις
φωτόμετρον φωτόνιο φωτόνιον φωτόσφαιρα φωτόφωνο φωτόφωνον φόβητρο φόβος φόδρα
φόλα φόνισσα φόνος φόντα φόντο φόντρα φόξτροτ φόουλι φόρα φόρεμα φόρμα
φόρμιγξ φόρμουλα φόρος φόρουμ φόρτε φόρτι φόρτιση φόρτισις φόρτος φόρτσα
φόρτωση φόρτωσις φύκι φύκος φύλαγμα φύλακας φύλακτρα φύλαξ φύλαξη φύλαρχος
φύλλον φύλλωμα φύλο φύλον φύμα φύρα φύραμα φύση φύσημα φύσιγγα φύσιγξ φύσις
φύτευμα φύτευση φύτουλας φύτρα φύτρο φύτρωμα φώκια φώλι φώλιασμα φώλος φώναγμα
φώραση φώρασις φώσφορο φώσφορος φώτιση φώτισμα φῶς χάβαρο χάβρα χάδεμα χάδι
χάζι χάιδεμα χάιδι χάκα χάκερ χάλαβρο χάλαζα χάλαρο χάλαση χάλασμα χάλι
χάλκευση χάλκωμα χάλοουιν χάλυβας χάμουρα χάμπουργκερ χάμστερ χάνδαξ χάνδρα
χάνης χάνι χάννος χάνος χάντικαπ χάντμπολ χάντρα χάντρισμα χάντρωμα χάος χάουζ
χάπατο χάπενινγκ χάπι χάπι εντ χάραγμα χάρακας χάραμα χάραξ χάραξη χάρβαλο
χάρις χάρισμα χάρμα χάροντας χάρος χάρτα χάρτης χάρτωμα χάση χάσια χάσιμο
χάσκας χάσκι χάσμα χάσμημα χάσταγκ χάχαμα χάχανο χάχας χάψη χάψιμο χέδρωπας
χένα χέρα χέρι χέριασμα χέρσωμα χέρσωση χέρσωσις χέσιμο χέστης χέστρα χήμωση
χήρα χήρος χήτη χίμαιρα χίμετλον χίντι χίος χίπης χίπιντι χοπ χίπις χίπισσα
χαΐνης χαΐρι χαέρι χαίτη χαβάγια χαβάνι χαβάς χαβέτα χαβέττα χαβαδάκι χαβαλές
χαβαλετζού χαβανέζικα χαβανόχερο χαβαρόνι χαβασίτης χαβιάρι χαβιαροσαλάτα
χαβούζα χαγάνος χαγανάτο χαγιάτι χαδούσα χαζίρεμα χαζίρι χαζαμάρα χαζενές
χαζνές χαζογκόμενα χαζοκουβέντα χαζοκούτι χαζολόγημα χαζομάρα χαζομαμά
χαζομπαμπάς χαζούλιακας χαιρέτισμα χαιρεκακία χαιρετίσματα χαιρετισμός
χακί χαλάζι χαλάζιο χαλάκι χαλάουα χαλάρωμα χαλάρωση χαλάρωσις χαλάστρα χαλέπα
χαλί χαλίκι χαλίκωμα χαλίκωση χαλίκωσις χαλίνωσις χαλίφης χαλαζίας
χαλαζοβρόχι χαλαζόκοκκος χαλαζόπτωση χαλαρότης χαλαρότητα χαλασιά χαλασμός
χαλβάδιασμα χαλβάς χαλβαδοπιτατζής χαλβαδοποιία χαλβαδοποιείο χαλβαδοποιός
χαλβαδόριζα χαλβατζής χαλβατζίδικο χαλεπάκι χαλικάκι χαλικοδόμος χαλικοθηρίο
χαλικόστρωση χαλικόστρωσις χαλικόχωμα χαλινάρι χαλινάρωμα χαλιναγώγηση
χαλινωτήρας χαλινός χαλιφάτο χαλκάρματος χαλκάς χαλκήτης χαλκαδάκι χαλκείο
χαλκευτής χαλκεύς χαλκιάς χαλκιδαίος χαλκιδικιώτης χαλκιδιώτης χαλκογράφημα
χαλκογραφία χαλκοειδής χαλκομανία χαλκονικέλιο χαλκοπλάστης χαλκοπλαστική
χαλκοπωλείον χαλκοπώλης χαλκοτυπία χαλκοτύμπανο χαλκοτύπος χαλκουργία
χαλκουργική χαλκουργός χαλκοχυτική χαλκούς χαλκωδία χαλκωματάδικο χαλκωματάς
χαλκωρύχος χαλκός χαλκότονα χαλλούμι χαλουμόσουπα χαλυβδοσωλήνας χαλυβδοταινία
χαλυβοβιομηχανία χαλυβοποίηση χαλυβοποιείο χαλυβουργία χαλυβουργείο χαλύβδωμα
χαμάδα χαμάλης χαμάμ χαμάμι χαμέρπεια χαμήλωμα χαμίνι χαμαίμηλον χαμαίφυτον
χαμαιλέοντας χαμαιτυπείο χαμαλίκα χαμαλίκι χαμαλιάτικα χαμαλοδουλειά χαμαμτζής
χαμηλοβλεπούσα χαμηλοσυνταξιούχος χαμοβούνι χαμογέλασμα χαμογέλιο χαμοδράκι
χαμοθεός χαμοκέλα χαμοκέρασο χαμοκερασιά χαμολούλουδο χαμολόγι χαμολόι
χαμομηλέλαιο χαμομηλιά χαμομηλόλαδο χαμοπέρδικα χαμουθράκι χαμούλης χαμούρα
χαμούρης χαμπάρι χαμπάριασμα χαμπέρι χαμπουργκεράδικο χαμσίνι χαμστεράκι
χαμόγι χαμόδεντρο χαμόδρακας χαμόι χαμόκλαδα χαμόκλαδο χαμόμηλο χαμός
χαν χανάτο χαναανίτης χαναναίος χανιτζής χανιώτης χανουμάκι χανούμισσα χαντάκι
χαντίθ χαντζάρα χαντζάρας χαντζάρι χαντζής χαντοκάδικο χαντοκάς χαντούμης
χαντόκι χαολογία χαπάκι χαπιάρισμα χαρά χαράδρα χαράκι χαράκτης χαράκτρια
χαράτσι χαράτσωμα χαρέμι χαραγή χαραγματιά χαραδριός χαρακίρι χαρακιά
χαρακτηρισμός χαρακτηριστικό χαρακτηρολογία χαρακτική χαρακτικό χαραμάδα
χαραματιά χαραμοφάης χαραμοφάισσα χαραυγή χαραχτήρας χαριεντισμός χαριστής
χαριτολόγημα χαριτωμενιά χαρμάνα χαρμάνης χαρμάνι χαρμάνιασμα χαρμολύπη
χαρμοσύνη χαρογράφηση χαροκόπι χαροκόπος χαροπάλεμα χαροποίηση χαροπούλι
χαρουπιά χαρουπόμελο χαρουπόψωμο χαρούδια χαρούπι χαρτάκι χαρτέμπορος χαρτί
χαρταϊτός χαρτεμπόριο χαρτζιλίκι χαρτζιλίκωμα χαρτζιλικάκι χαρτικά
χαρτοβασίλειον χαρτοβιομήχανος χαρτοβιομηχανία χαρτογιακάς χαρτογράφηση
χαρτογράφος χαρτογραφία χαρτοδέσιμο χαρτοδέτης χαρτοδέτηση χαρτοδέτησις
χαρτοθέτης χαρτοθήκη χαρτοκάλαθος χαρτοκιβώτιο χαρτοκλέπτης χαρτοκλέφτης
χαρτοκοπτική χαρτοκόπτης χαρτολόγος χαρτομάζα χαρτομάνι χαρτομάντης
χαρτομάντισσα χαρτομανία χαρτομαντεία χαρτονόμισμα χαρτοπαίγνιο χαρτοπαίγνιον
χαρτοπαίκτρια χαρτοπαίχτης χαρτοπαίχτρα χαρτοπαιξία χαρτοπετσέτα
χαρτοπετσετούλα χαρτοποιία χαρτοποιός χαρτοπολτός χαρτοπωλείο χαρτοπωλείον
χαρτοπόντικας χαρτοπώλης χαρτορίχτρα χαρτοσήμανση χαρτοσήμανσις χαρτοσακούλα
χαρτοτεχνία χαρτοφυλάκιο χαρτοφυλάκιον χαρτοφύλακας χαρτοφύλαξ χαρτού χαρτούρα
χαρτόδεμα χαρτόδεση χαρτόλιθος χαρτόμουτρο χαρτόνι χαρτόσακος χαρτόσημο
χαρχάλα χαρχάλεμα χαρχάλι χαρχάλω χαρόντισσα χασάπης χασάπικο χασάπικος
χασές χασίκλα χασίκλας χασίς χασίσι χασίσωμα χασαπάκι χασαπιό χασαποσέρβικος
χασαπόπαιδο χασαπόσκυλο χασαπόχαρτο χασικλής χασικλού χασισάκι χασισοβολώνας
χασισοποτείο χασισοπότης χασισοφυτεία χασισόδενδρο χασκαρίσματα χασμάδα
χασμούρημα χασμωδία χασοδίκης χασομέρης χασομέρι χασομέρισσα χασοφεγγαριά
χαστουκιά χαστούκι χαστούκισμα χατίρι χατζ χατζής χατιράκι χατλάρης
χαυλιόδους χαυνότης χαυνότητα χαφιές χαφιεδισμός χαχάμης χαχάνισμα χαχαλιά
χαχαμητό χαχανητό χαχόλος χαψιά χαϊβάνι χαϊδευτικό χαϊδοκώλης χαϊδολόγημα
χαϊκουργός χαϊκού χαϊμαλί χαύνωμα χαύνωση χαύνωσις χείλι χείλος χείλωμα
χείρα χεγγελιανισμός χεζάς χεζού χειλάκι χειλάς χειλαράς χειλαρού χειλεόφωνα
χειλόφωνα χειμάδι χειμαδιό χειμερία χειμωνανθός χειμωνιά χειμωνικό χειμών
χειμώνιασμα χειρ χειράγρα χειράμαξα χειρίδα χειρίς χειρίστρια χειραγωγία
χειραγώγηση χειραγώγησις χειραλικότητα χειραμάξι χειραμαξίδιο χειραντλία
χειραφέτησις χειραφεσία χειραψία χειρισμός χειριστήριο χειριστήριον χειριστής
χειροδάχτυλο χειροδιαλογή χειροδικία χειροδρέπανο χειροθερμαστής χειροθεσία
χειροκαλλιέργεια χειροκροτητής χειροκρόταλο χειροκρότημα χειροκρότηση
χειρολαβή χειρομάλαξη χειρομάλαξις χειρομάντης χειρομάντισσα χειρομαλάκτης
χειρομαντεία χειρομορφία χειρονομία χειροπάλη χειροπέδα χειροπέδη χειροπρίονο
χειροπτερολογία χειροσφαίριση χειροσφαίρισις χειροτέρευση χειροτέρευσις
χειροτέχνημα χειροτέχνης χειροτεχνία χειροτεχνείο χειροτεχνείον χειροτεχνεῖον
χειροτόνηση χειροτόνησις χειρουργείο χειρουργείον χειρουργική χειρουργός
χειροφωλιά χειροφύλακας χειρούργηση χειρούργος χειρόβολο χειρόγραφο χειρόκτιο
χειρόμυλος χειρόπτερα χειρόφρενο χειρώνακτας χειρώναξ χελιδονοφωλιά
χελιδόνα χελιδόνι χελιδόνισμα χελιδών χελωνάκι χελωνάστρακο χελωνίτσα
χελωνοκαύκαλο χελωνόσουπα χελώνα χελώνη χελώνι χελώνιον χεράκι χερέρο χεριά
χεροβολιά χερομάχημα χερομάχος χεροπάλαμο χερουβίμ χερουβείμ χερουβικό
χερουλάκι χερουλάς χερουλάτης χερούκλα χερούκλωμα χερούλι χερσάδα χερσοτόπι
χερσότοπος χερόβολο χερόμπολο χερόμυλος χερόψαρο χηβάδα χηβάς χηλή χηλόποδα
χημεία χημείο χημείον χημειοεμβολισμός χημειοθεραπεία χημειομετρία
χημειοτακτισμός χημειοταξινομία χημειοτροπισμός χημειοφωταύγεια
χημειόταξη χημικοθεραπεία χημικό στοιχείο χημικός χημισμός χημιφωταύγεια
χηνάρης χηνάρι χηνοβοσκός χηνοτροφία χηνοτροφείο χηνοτροφείον χηνοτρόφος
χηρεία χηρειά χηρεμός χθαμαλότης χθαμαλότητα χθες χθων χι χιασμός χιαστό
χιλίαρχος χιλιάδα χιλιάρα χιλιάρικο χιλιαναθεματισμένος χιλιανός χιλιαρχία
χιλιαστής χιλιετία χιλιετηρίδα χιλιογραμμόμετρο χιλιογραμμόμετρον
χιλιοδεύτερο χιλιομέτρηση χιλιομέτρησις χιλιομετρητής χιλιομετροδείκτης
χιλιοστημόριο χιλιοστημόριον χιλιοστογραμμάριο χιλιοστό χιλιοστόγραμμο
χιλιοστόλιτρο χιλιοστόμετρο χιλιοστόν χιλιοχρονίτης χιλιοχρονίτισσα
χιλιόγραμμον χιλιόδραχμο χιλιόμετρο χιλιόμετρον χιμέρι χιμαιροκυνηγός
χιμπατζής χινόπωρο χιονάκι χιονάνθρωπος χιονίστρα χιονιά χιονιάς χιονιστής
χιονοβολία χιονοβόλημα χιονοδρομία χιονοδρομικό χιονοδρόμιο χιονοδρόμος
χιονομπαλιά χιονονιφάδα χιονονιφάς χιονοπέδιλο χιονοπέδιλον χιονοπόλεμος
χιονοστιβάς χιονοστρόβιλος χιονοχαλάζι χιονόβροχο χιονόμετρο χιονόμπαλα
χιονόπτωση χιονόσφαιρα χιουμορίστας χιουμορίστρια χιουμοριστής χιουμουρτζής
χιπ χοπ χιπισμός χιτζάμπ χιτλερισμός χιτωνοφόρο χιτών χιτώνας χιτώνιο χιτώνιον
χιόνισμα χιών χιώτης χιώτισσα χλέμπουρας χλίδα χλαίνα χλαίνη χλαλοή χλαμύδα
χλανίδα χλαπάκιασμα χλαπάτσα χλαπαταγή χλατσί χλατσιά χλεμπάγια χλεμπόνα
χλευαστής χλεχλές χλεύασμα χλεύη χλιαρότης χλιαρότητα χλιδή χλιμίντρισμα
χλοοκοπή χλοοτάπητας χλωμάδα χλωράδα χλωρίδα χλωρίδιο χλωρίνη χλωρίωση
χλωρασιά χλωρεξιδίνη χλωρομεθάνιο χλωροπαραφίνη χλωροτύρι χλωροφόρμιο
χλωροφύλλη χλωρότητα χλόασμα χλόη χλόμιασμα χλώμιασμα χλώριο χλώριον χλώρωση
χμερ χνάρι χνουδάκι χνούδι χνούδιασμα χνότο χνώτο χοάνη χοή χοίνικας χοίρος
χοιράδωση χοιρίδιο χοιρίδιον χοιρίνη χοιραδισμός χοιροβοσκός χοιρομέρι
χοιροστάσιο χοιροστάσιον χοιροτροφία χοιροτροφείο χοιροτροφείον χοιροτρόφος
χολ χολέρα χολή χολαγγειογραφία χολαγγειοπαγκρεατογραφία χολαγωγός χολαιμία
χοληστερίνη χοληστερόλη χολοκυστίτιδα χολοκυστίτις χολοκυστεκτομή
χολολιθίαση χολολιθίασις χολόλιθος χονδρέμπορος χονδρεκτομία χονδρεμπόριο
χονδριχθύες χονδροκύτταρο χονδρομεταμόσχευση χονδροπάθεια χονδροποιός
χοντράδα χοντράδι χοντράνθρωπος χοντράνθωπος χοντρέλα χοντρέλας χοντρέμπορος
χοντρογούρουνο χοντρογυναίκα χοντροδουλειά χοντροδούλεμα χοντροκεφαλιά
χοντρομαλάκας χορήγημα χορήγηση χορδή χορδίστρια χορδιστής χορεία χορείος
χορευταράς χορευταρού χορευτός χορεύτρια χορηγήτρια χορηγία χορηγητής χορηγός
χορογράφημα χορογράφος χορογραφία χοροδιδάσκαλος χοροδιδασκαλία
χοροδιδασκαλείον χοροεσπερίδα χοροεσπερίς χοροθέατρο χοροπήδημα χοροπηδητό
χοροστάσιο χοροστασία χορούλης χορτάρι χορτάριασμα χορταποθήκη χορταράκι
χορτασιά χορτασμός χορτονομή χορτοπαγίδα χορτοφάγος χορτοφαγία χορτόπιτα
χορωδία χορωδιακό χορωδός χορόδραμα χορός χοσάφι χοτ σποτ χουβαρντάς
χουβαρντού χουγιατό χουγιαχτό χουζουρλής χουζουρλού χουζούρεμα χουζούρης
χουλιάρα χουλιάρι χουλιαράκι χουλιαριά χουλιαρόπαπια χουλιγκάνος
χουμανισμός χουνέρι χουνί χουντίτης χουρμάς χουρμαδιά χουρχούδα χους χουσμέτι
χουχουλόγιωργας χουχουριστής χουχούλιασμα χουχούλισμα χοχλάδι χοχλάκιασμα
χοχλίδι χοχλιός χούγιασμα χούι χούλα χουπ χούλιγκαν χούμα χούμος χούνη χούνη
χούρχουρη χούφτα χούφταλο χούφτιασμα χούφτωμα χράμι χρένο χρέος χρέπι χρέωμα
χρέωσις χρήμα χρήματα χρήση χρήσις χρήστης χρίση χρίσις χρίσμα χραμάκι χρεία
χρεμετισμός χρεοκόπος χρεολύσιον χρεοπίστωση χρεοστάσιον χρεωκοπία χρεωλυσία
χρεωστάσιο χρεωφειλέτης χρεόγραφο χρεώβαρο χρεώγραφο χρεώλυτρο χρεώστης
χρηματαποστολή χρηματισμός χρηματιστήριο χρηματιστήριον χρηματιστής
χρηματοδότης χρηματοδότηση χρηματοδότρια χρηματοκιβώτιο χρηματοκιβώτιον
χρηματοκρατία χρηματολάτρης χρηματολαγνεία χρηματολογία χρηματομεσίτης
χρηματοροή χρηματοφυλάκιο χρηματοφυλάκιον χρηματόγραφο χρηματόγραφον
χρησιδάνειο χρησιδάνειον χρησικτησία χρησιμοθήρας χρησιμοθηρία χρησιμοκρατία
χρησιμοποίησις χρησιμότης χρησιμότητα χρησμοδοσία χρησμοδότημα χρησμοδότης
χρησμολόγιο χρησμολόγιον χρησμός χρηστήριο χρηστικότης χρηστικότητα
χρηστομάθεια χρηστότης χρηστότητα χρηστώνυμο χριστιανή χριστιανισμός
χριστιανομάχος χριστιανοσοσιαλισμός χριστιανοσοσιαλιστής χριστιανοσύνη
χριστιανόπουλο χριστιανός χριστολογία χριστοπαναγία χριστοπαναγιά χριστοσημαία
χριστόπιτα χριστόψαρο χριστόψωμο χροιά χρονάκια χροναξία χρονιά χρονικογράφος
χρονισμός χρονοαναμεταδότης χρονοαπόσταση χρονοβιολογία χρονογράφημα
χρονογραφία χρονοδείκτης χρονοδιάγραμμα χρονοδιακόπτης χρονοδιατροφή
χρονοεπίδομα χρονοθυρίδα χρονοκαθυστέρηση χρονοκρύσταλλος χρονολογία
χρονολόγησις χρονολόγιο χρονομέτρης χρονομέτρηση χρονομέτρησις χρονομίσθωση
χρονομετρία χρονομετρητική χρονομηχανή χρονοντούλαπο χρονοπαγίδα
χρονοπρογραμματισμός χρονορρύθμιση χρονοταξία χρονοτριβή χρονοχρέωση
χρυσάνθεμο χρυσάφι χρυσή χρυσίο χρυσαλλίδα χρυσαλοιφή χρυσαυγή χρυσαυγίτης
χρυσηλασία χρυσικά χρυσικός χρυσοθήρας χρυσοθηρία χρυσοκάνθαρος χρυσοκέντημα
χρυσοκεντήτρια χρυσοκεντητής χρυσοκονδυλιά χρυσοκοντυλιά χρυσομάλλα
χρυσομαλλούσα χρυσομπάμπουρας χρυσομυκίνη χρυσοποικιλτής χρυσοσκάθαρο
χρυσοχέρης χρυσοχοΐα χρυσοχοία χρυσοχοείο χρυσοχοείον χρυσοχόος χρυσωρυχείο
χρυσωτής χρυσόβεργα χρυσόβιβλος χρυσόβουλο χρυσόκολλα χρυσόλιθος χρυσόμυγα
χρυσός χρυσόσκονη χρυσότουβλο χρυσόψαρο χρωμάτισμα χρωμάτων χρωμάτωση
χρωμίτης χρωματική χρωματικότης χρωματικότητα χρωματισμός χρωματοβιομηχανία
χρωματοπήλης χρωματοποιία χρωματοποιείο χρωματοποιείον χρωματοποιός
χρωματοπώλης χρωματοσκοπία χρωματοσκόπιο χρωματοσκόπιον χρωματουργία
χρωματουργείον χρωματουργός χρωματοφιλία χρωματόσωμα χρωμιοχάλυβας χρωμογράφος
χρωμοδυναμοκβάντωση χρωμοκλώνος χρωμολιθογραφία χρωμομαγνητισμός χρωμοσφαιρίνη
χρωμοτυπογραφία χρωμοφάν χρωμοφορτίο χρωμοφωτογραφία χρωμοφωτοτυπία χρωμοφόρος
χρωμόκλωνος χρωμόκοκκοι χρωμόκοκκος χρωμόσφαιρα χρωμόσωμα χρωστήρ χρωστήρας
χρωστούμενα χρόνια χρόνιασμα χρόνος χρύσωμα χρύσωση χρώμα χρώμιο χρώμιον χρώση
χρῖσμα χτένα χτένι χτένισμα χτήμα χτήνος χτίριο χτίση χτίσιμο χτίσμα χτίστης
χταπόδι χτηματίας χτικιό χτιστικά χτυπηματάκι χτυπητήρι χτυποκάρδι χτύπημα
χυδαιολογία χυδαιολόγημα χυδαιολόγος χυδαιότητα χυδαϊσμός χυδαϊστής χυλοπίτα
χυλόπιτα χυλός χυμαδιό χυμευτής χυμευτική χυμοποίηση χυμός χυσαυγίτης χυτήριο
χυτοσίδηρος χυτρισμός χωλότητα χωματίλα χωματερή χωματισμός χωματοδεξαμενή
χωματουργός χωματόδρομος χωνάκι χωνί χωνίον χωνευτήρας χωνευτήρι χωνευτήριο
χωράφι χωρίζοντες χωρίο χωρίστρα χωραΐτης χωρατάς χωρατατζής χωρατό χωραϊτισσα
χωρητικότητα χωριάτα χωριάτης χωριάτικα χωριάτικη χωριάτισσα χωριανή χωριανός
χωριατάκος χωριατιά χωριατομάνι χωριατοπούλα χωριατοσύνη χωριατοφάσουλο
χωριατόπουλο χωριατόσπιτο χωρική χωρικός χωριουδάκι χωρισιά χωρισμός χωριό
χωρογραφία χωροδεσποτεία χωροδεσπότης χωροδιαστολή χωροεπέκταση χωροεπίσκοπος
χωρομέτρηση χωρομετρία χωρονομία χωροστάθμη χωροστάθμηση χωροστοιχείο
χωροσχάση χωροτάκτης χωροταξία χωροφυλακή χωροφυλακίνα χωροφύλακας χωροχρόνος
χωσιά χόακας χόβερκραφτ χόβολη χόκεϊ χόλιασμα χόλιγουντ χόλος χόμπι χόμπιτ
χόντρεμα χόντρος χόρδισμα χόριο χόριον χόρτα χόρταση χόρτασμα χόρτο χόρτον
χότζας χόχλος χύλωμα χύλωση χύμευση χύση χύσι χύσιμο χύτευση χύτης χύτρα
χώμα χώνεμα χώνευση χώνεψη χώρα χώρισμα χώρος χώρος αποσκευών χώση χώσιμο
ψάθα ψάθη ψάθος ψάθωμα ψάκωμα ψάλσιμο ψάλτης ψάλτρα ψάλτρια ψάμαθος ψάμμος
ψάρακας ψάρακλας ψάρεμα ψάρι ψάρος ψάρωμα ψέκασμα ψέκτης ψέλιο ψέλλιο ψέλλισμα
ψήγμα ψήκτρα ψήκτρα ψήλος ψήλωμα ψήσιμο ψήστης ψήφιση ψήφισμα ψήφος ψίαθος
ψίδιασμα ψίθυρος ψίκι ψίλωση ψίλωσις ψίχα ψίχαλο ψίχουλο ψαθάδικο ψαθάκι ψαθάς
ψαθοποιείο ψαθοποιός ψαθοχώρι ψακή ψακί ψαλίδα ψαλίδι ψαλίδισμα ψαλίδωμα ψαλίς
ψαλιδιά ψαλιδισμός ψαλιδόγλωσσος ψαλιδόγναθος ψαλμουδιά ψαλμωδία ψαλμωδός
ψαλτήρι ψαλτήριο ψαλτικά ψαμμίαση ψαμμίτης ψαμμόλιθος ψαρά ψαράδικο ψαράκι
ψαρίλα ψαραγκάθι ψαραγορά ψαρανεμούριο ψαρευτική ψαριά ψαριανός ψαρική ψαρικό
ψαροκάικο ψαροκάλαθο ψαροκέφαλο ψαροκασέλα ψαροκεφαλή ψαροκόκαλο ψαροκόκκαλο
ψαρολίμανο ψαρομάλλης ψαρομάχαιρο ψαρομανάβης ψαρομανάβικο ψαρονέφρι
ψαροπάζαρο ψαροπούλα ψαροπούλι ψαροταβέρνα ψαροτουφεκάς ψαροτούφεκο ψαροτόπι
ψαροφαγία ψαροχώρι ψαρού ψαρούκλα ψαρόβαρκα ψαρόκολλα ψαρόλαδο ψαρόνι
ψαρότοπος ψαρότρατα ψατζή ψαχνιώτης ψαχνό ψαχούλεμα ψαύση ψείρα ψείρας
ψείρισμα ψεγάδι ψεγάδιασμα ψειρής ψειραλοιφή ψειρού ψεκάδες ψεκασμός
ψελλισμός ψελλότητα ψεματάκι ψευδάνθρακας ψευδάργυρος ψευδάρθρωση ψευδάριθμος
ψευδαδάμαντας ψευδαδάμας ψευδαισθησία ψευδαπόστολος ψευδαργύρωση
ψευδετυμολόγηση ψευδισμός ψευδοάνοια ψευδοανεύρυσμα ψευδοαρμονία
ψευδοδίλημμα ψευδοεπιστήμη ψευδοθόρυβος ψευδοκανονικότητα ψευδοκενό
ψευδοκράτος ψευδοκύηση ψευδοκώδικας ψευδολέξη ψευδολογία ψευδολόγημα
ψευδομάρτυρας ψευδομάρτυς ψευδομαρξίστρια ψευδομαρξιστής ψευδομαρτυρία
ψευδομνήμη ψευδομονάδα ψευδομοτίβο ψευδοπάτωμα ψευδοπατριωτισμός
ψευδοπλάτανος ψευδοπληροφορία ψευδοπροσωπία ψευδοπροσωπεία ψευδοπροφήτης
ψευδοπρόσωπος ψευδορήμα ψευδορκία ψευδοροφή ψευδορρημοσύνη ψευδοσοφία
ψευδοσυσχέτιση ψευδοσωμάτιο ψευδοσύνοδος ψευδοσύνολο ψευδοτρόπιδα ψευδοχαλάζι
ψευδόθεος ψευδόκενο ψευδόσοφος ψευδότιλος ψευδότοιχος ψευδώνυμο ψευτάκος
ψευταράς ψευταρού ψευτιά ψευτογιατρός ψευτοδεδομένο ψευτοδουλειά ψευτοθεά
ψευτοκουλτουριάρα ψευτοκουλτουριάρης ψευτοκουλτούρα ψευτοκουτσαβάκης
ψευτολόγος ψευτομάρτυρας ψευτομέντιουμ ψευτομαγκιά ψευτομαρξίστρια
ψευτονταής ψευτοπάτωμα ψευτοπαλικαράς ψευτοπαλικαρού ψευτοπαλληκαράς
ψευτοφιλία ψευτοφυλλάδα ψευτρού ψευτόμαγκας ψευτόσουπα ψεύδισμα ψεύδος
ψεύτης ψεύτισμα ψεύτρα ψηλάφηση ψηλάφιση ψηλάφισμα ψηλέας ψηλαρμένισμα
ψηλομύτα ψηλωσιά ψησταριά ψηστιέρα ψηστικά ψητοπωλείο ψητό ψηφάριθμος ψηφί
ψηφίο ψηφαλάκι ψηφιδογράφος ψηφιδογραφία ψηφιδοθέτης ψηφιδοθέτηση
ψηφιδωτό ψηφιονευροπλαστικότητα ψηφιοποίηση ψηφιοποιητής ψηφιοσκόπιο
ψηφοδέλτιο ψηφοδόχος ψηφοθέτημα ψηφοθέτης ψηφοθέτηση ψηφοθήρας ψηφοθηρία
ψηφολέκτρια ψηφολογία ψηφοφορία ψηφοφόρος ψι ψιάντρα ψιαθοπλόκος ψιθυρισμός
ψιθύρισμα ψιλά ψιλή ψιλικά ψιλικατζής ψιλικατζίδικο ψιλικατζού ψιλικοκό
ψιλοβρόχι ψιλοδουλειά ψιλοδούλεμα ψιλοκοσκίνισμα ψιλοκυβίνη ψιλολογία
ψιλολόι ψιλοπράγματα ψιλοπράματα ψιλορώτημα ψιλόβροχο ψιμάρι ψιμυθίτης
ψιμυθιολόγος ψιμύθιο ψιττάκωση ψιττακίαση ψιττακισμός ψιττακός ψιχάλα
ψιχίο ψιχαλίδα ψιχαλητό ψιψίνα ψιψίρισμα ψοφίμι ψοφολόγημα ψοφόκρυο ψυγείο
ψυγειοκαταψύκτης ψυκτήρ ψυκτήρας ψυκτικό ψυκτικός ψυττάλεια ψυχάκι ψυχάκιας
ψυχάρι ψυχή ψυχίατρος ψυχαγωγία ψυχαγωγός ψυχαγώγημα ψυχανάγκασμα ψυχανάλυση
ψυχαναλυτής ψυχαναλύτρια ψυχανθή ψυχαρικός ψυχαρισμός ψυχαριστής ψυχασθένεια
ψυχεδελισμός ψυχιατρείο ψυχιατρική ψυχικό ψυχισμός ψυχοβγάλτης ψυχοβγάλτρα
ψυχοβιολογισμός ψυχοβιολόγος ψυχογένεια ψυχογένεση ψυχογιός ψυχογλωσσολογία
ψυχογράφηση ψυχογράφος ψυχογραφία ψυχοδυναμία ψυχοδυναμισμός ψυχοθεραπεία
ψυχοθεραπεύτρια ψυχοκοινωνιολογία ψυχοκρατία ψυχοκτονία ψυχοκόρη ψυχολάτρης
ψυχολατρία ψυχολογία ψυχολογισμός ψυχολόγημα ψυχολόγος ψυχομάνα ψυχομάχημα
ψυχομαχητό ψυχομετρία ψυχομηχανική ψυχονεύρωση ψυχοπάθεια ψυχοπαίδα ψυχοπαίδι
ψυχοπατέρας ψυχοπλάκωμα ψυχοπλάκωση ψυχοπομπός ψυχοπόνια ψυχορράγημα
ψυχοστασία ψυχοσωματική ψυχοσύνθεση ψυχοσύσταση ψυχοσώστης ψυχοσώστρα
ψυχοτεχνική ψυχοφάρμακα ψυχοφάρμακο ψυχοφαρμακολογία ψυχοφυσική ψυχοφυσιολογία
ψυχοχάρτι ψυχοχειρουργική ψυχούδι ψυχούλα ψυχραιμία ψυχρηλασία ψυχρολουσία
ψυχρόμετρο ψυχρότης ψυχρότητα ψυχρόφιλος ψυχωτικός ψυχόγραμμα ψυχόδραμα
ψυχόρμητο ψυχός ψωλή ψωλαράς ψωλαρπάχτρα ψωλαρπάχτρας ψωλαϊτός ψωλορούφι ψωλού
ψωμάδικο ψωμάκι ψωμάκια ψωμάς ψωμί ψωματάρης ψωμιέρα ψωμοζήτης ψωμοζήτουλας
ψωμομαντίλα ψωμοπάτης ψωμοτύρι ψωμοφάγισσα ψωμοφάγος ψωμοφαγία ψωμοφαγού
ψωμόνερο ψωνάρα ψωνιστήρι ψωνιστής ψωνιστηρατζού ψωρίαση ψωρίλας ψωρίλος
ψωροπερηφάνια ψωροφύτης ψόα ψόγος ψόφος ψύκτης ψύκτρα ψύλλιασμα ψύλλισμα
ψύλλος ψύξη ψύχος ψύχρα ψύχρανση ψύχωμα ψύχωση ψώμα ψώμωμα ψώνι ψώνια ψώνιο
ψώρα ψώριασμα ωάριο ωαγωγός ωδή ωδίνα ωδίνες ωδείο ωδική ωθητής ωκεανογράφος
ωκεανογραφικό ωκεανολογία ωκεανολόγος ωκεανοπλοΐα ωκεανούλης ωκεανός ωκυποδία
ωλένη ωμέγα ωμαλγία ωμοπλάτη ωμοπλατοσκοπία ωμοπλινθοδομή ωμοφαγία ωμοφόριο
ωμότητα ωογένεση ωογονία ωοθήκη ωοθηκίτιδα ωοθηκεκτομή ωοθυλάκιο ωολεύκωμα
ωορρηξία ωοσκοπία ωοσκόπιο ωοτοκία ωράριο ωράριον ωρίμανση ωρίμαση ωρίμασμα
ωραιολεξία ωραιοπάθεια ωραιοποίηση ωραιοτέχνημα ωραιότητα ωρείο ωρειάριος
ωριοσύνη ωροδείκτης ωροδείχτης ωρολογάς ωρολογία ωρολογοποιία ωρολογοποιείο
ωρολόγιο ωρολόγος ωρομέτρηση ωρομίσθια ωρομίσθιο ωρομίσθιος ωροσήμανση
ωροσκόπιο ωροσκόπος ωρούλα ωρυγή ωρωπιώτης ωσμογράφος ωσμοσκόπιο ωσμωτικότητα
ωτίτης ωτίτιδα ωτίτις ωτακουστής ωταλγία ωτασπίδα ωτοασπίδα ωτογλυφίδα
ωτοκαθαριστής ωτολογία ωτολόγος ωτομικροσκόπηση ωτοπλαστική
ωτορινολαρυγγολόγος ωτοσκλήρυνση ωτοσκλήρωση ωτοσκοπία ωτοσκόπηση ωτοσκόπιο
ωτοτοξικότητα ωτόρροια ωφέλεια ωφέλημα ωφελιμίστρια ωφελιμισμός ωφελιμιστής
ωφελιμοκρατία ωφελιμότης ωφελιμότητα ωχαδερφισμός ωχρατοξίνη ωχρινοτροπίνη
ωχρότητα ωόλιθος ωόν ωόσφαιρα όαση όβολο όγδοο όγκος όγκωμα όδευμα όδευση
όζα όζαινα όζη όζον όζος όκιο όλβος όλεθρος όλισβος όλμιο όλμος όλον όμβρος
όμικρον όμιλος όμμα όμποε όμπυασμα όμπυο όμφαξ όναγρος όναρ όνειδος όνειρο
όνος όνυμα όνυχας όξος όξυνση όξυνσις όπερα όπιο όπιον όπισθεν όπλιση όπλο
όπτησις όπτιμουμ όραμα όραση όρασις όργανο όργητα όργιο όργωμα όρεξη όρεξις
όρθωση όριο όρισμα όρκιση όρκισις όρκος όρμημα όρμιση όρμισις όρμος όρνεο
όρνιασμα όρνιθα όρνιο όρνις όροφος όρυγμα όρυζα όρυξη όρυξις όρχηση όρχησις
όρχος όσκαρ όσμιο όσμωση όσπριο όστια όστρακο όστρια όσφρηση όσφρησις όσχεο
όφεος όφης όφις όφσετ όχεντρα όχημα όχθη όχθος όχληση όχλησις όχλος όχτος
όψη όψον ύαινα ύαλος ύβος ύβρη ύβρις ύβωμα ύβωσις ύγρανση ύδατος ύδνον
ύδραρθρος ύδρευση ύδρωμα ύδρωπας ύδρωψ ύδωρ ύελος ύλη ύμνηση ύμνος ύπαιθρο
ύπαιθρος ύπαρξη ύπαρξις ύπαρχος ύπατος ύπερος ύπνος ύπνωση ύπνωσις ύποπτος
ύσσωπος ύστερο ύτριο ύφαλα ύφαλος ύφανση ύφανσις ύφασμα ύφεση ύφος ύψη ύψιλον
ύψωμα ύψωση ύψωσις ώα ώθηση ώκιμον ώμος ώνια ώρα ώρες ώση ώσμωση ώτος ο σκωψ
ἀβλεψία ἀγκύλη ἀγνάντιο ἀγυιά ἀετόπουλον ἀκίς ἀκουμπῶ ἀκρίβεια ἀκρόπολις
ἀναδιάταξις ἀναμόχλευσις ἀνασασμός ἀνδράποδον ἀντιστοίχησις ἀπάγκειο ἀπαρτία
ἀστραπή ἀχλύς ἄβαξ ἄγαλμα ἄνεσις ἅρπαξ ἐγκαινίασις ἐμβόλιον ἐμπίς ἐνδρομίς
ἐντευκτήριον ἐντόσθια ἐξοικείωσις ἐξοχή ἐξωκκλήσιον ἐπίσκεψις ἐπίσχεστρον
ἐρωτίς ἑρμηνεία ἔκθλιψις ἔκτισις ἔκτρωμα ἔπαλξις ἱππάρχας ἱππάρχης ἴς ἵππαρχος
ὑστερικός ὕστερον ὠάριον ὠοθήκη ὠοθηκῖτις ὠοθυλάκιον ὠορρηξία ὠοσκόπιον
""".split()
)
| 74.782809 | 83 | 0.891277 |
af61144cafa31634a588377087286c807627d153 | 25,146 | py | Python | tools/cardiff/check.py | gerhardqux/edeploy | f24225e54011e3852fac3a8a44bd9f74d728f4fb | [
"Apache-2.0"
] | null | null | null | tools/cardiff/check.py | gerhardqux/edeploy | f24225e54011e3852fac3a8a44bd9f74d728f4fb | [
"Apache-2.0"
] | null | null | null | tools/cardiff/check.py | gerhardqux/edeploy | f24225e54011e3852fac3a8a44bd9f74d728f4fb | [
"Apache-2.0"
] | null | null | null | import re
import compare_sets
import utils
import numpy
from pandas import *
import perf_cpu_tables
def search_item(systems, unique_id, item, regexp, exclude_list=[], include_list=[], override_list=[]):
sets = {}
for system in systems:
sets[system[unique_id]] = set()
current_set = sets[system[unique_id]]
for stuff in system[item]:
m = re.match(regexp, stuff[1])
if m:
shall_be_added = False
# If we have an include_list, only those shall be used
# So everything is exclude by default
if len(include_list) > 0:
shall_be_excluded = True
else:
shall_be_excluded = False
for include in include_list:
if include in stuff[2]:
# If something is part of the include list
# It is no more excluded
shall_be_excluded = False
for exclude in exclude_list:
if exclude in stuff[2]:
shall_be_excluded = True
for override in override_list:
if override in stuff[2]:
shall_be_added = True
if (shall_be_excluded is False) or (shall_be_added is True):
current_set.add(stuff)
return sets
def physical_hpa_disks(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "disk", "(\d+)I:(\d+):(\d+)", ['current_temperature_(c)', 'maximum_temperature_(c)', 'serial_number'])
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "Physical Disks (HP Controllers)")
return groups
def physical_megaraid_disks(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "pdisk", "disk(\d+)", ['Wwn', 'SasAddress', 'DriveTemperature'])
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "Physical Disks (Megaraid Controllers)")
return groups
def logical_disks(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "disk", "[a-z]d(\S+)", ['simultaneous', 'standalone', 'id', 'serial_number', 'SMART/'], [], ['when_failed', 'vendor', 'product', 'health'])
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "Logical Disks")
return groups
def ahci(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "ahci", ".*")
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "AHCI Controller")
return groups
def ipmi(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "ipmi", "(?!(.*Temp$|.*RPM$)).*", ['mac-address', 'ip-address'])
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "IPMI SDR")
return groups
def compute_deviance_percentage(item, df):
# If we have a single item
# checking the variance is useless
if df[item].count() == 1:
return 0
return (df[item].std() / df[item].mean() * 100)
def print_detail(detail_options, details, df, matched_category):
if ((utils.print_level & utils.Levels.DETAIL) != utils.Levels.DETAIL):
return
if len(df.loc[details]) > 0:
print
print "%-34s: %-8s: %s" % (matched_category[0], utils.Levels.message[utils.print_level], detail_options['item'])
print df.loc[details]
def prepare_detail(detail_options, group_number, category, item, details, matched_category_to_save):
if ((utils.print_level & utils.Levels.DETAIL) != utils.Levels.DETAIL):
return
matched_group = ''
matched_category = ''
matched_item = ''
if (detail_options['group'] == str(group_number)):
matched_group = str(group_number)
elif (re.search(detail_options['group'], str(group_number)) is not None):
matched_group = re.search(detail_options['group'], str(group_number)).group()
if (detail_options['category'] in category):
matched_category = category
elif (re.search(detail_options['category'], category) is not None):
matched_category = re.search(detail_options['category'], category).group()
if (detail_options['item'] in item):
matched_item = item
elif (re.search(detail_options['item'], item) is not None):
matched_item = re.search(detail_options['item'], item).group()
if (len(matched_group) > 0) and (len(matched_category) > 0) and (len(matched_item) > 0):
details.append(matched_item)
if matched_category not in matched_category_to_save:
matched_category_to_save.append(matched_category)
return matched_category
return ""
def network_perf(systems, unique_id, group_number, detail_options, rampup_value=0, current_dir=""):
have_net_data = False
sets = search_item(systems, unique_id, "network", "(.*)", [], [])
modes = ['bandwidth', 'requests_per_sec']
for mode in modes:
results = {}
for system in sets:
net = []
series = []
global_perf = 0.0
for perf in sets[system]:
if (perf[1] == mode):
if not perf[1] in net:
net.append(perf[1])
global_perf = global_perf + float(perf[3])
series.append(global_perf)
results[system] = Series(series, index=net)
df = DataFrame(results)
details = []
matched_category = []
for net in df.transpose().columns:
if have_net_data is False:
print
print "Group %d : Checking network disks perf" % group_number
have_net_data = True
consistent = []
curious = []
unstable = []
# How much the variance could be far from the average (in %)
tolerance_max = 15
tolerance_min = 2
print_perf(tolerance_min, tolerance_max, df.transpose()[net], df, mode, net, consistent, curious, unstable, rampup_value, current_dir)
if mode == 'bandwidth':
unit = "MB/sec"
else:
unit = "RRQ/sec"
prepare_detail(detail_options, group_number, mode, net, details, matched_category)
print_summary("%-30s %s" % (mode, net), consistent, "consistent", unit, df)
print_summary("%-30s %s" % (mode, net), curious, "curious", unit, df)
print_summary("%-30s %s" % (mode, net), unstable, "unstable", unit, df)
print_detail(detail_options, details, df, matched_category)
def logical_disks_perf(systems, unique_id, group_number, detail_options, rampup_value=0, current_dir=""):
have_disk_data = False
sets = search_item(systems, unique_id, "disk", "[a-z]d(\S+)", [], ['simultaneous', 'standalone'])
modes = []
# Searching for modes ran in this benchmark
for system in sets:
for perf in sets[system]:
if perf[2] not in modes:
modes.append(perf[2])
if len(modes) == 0:
return
for mode in modes:
results = {}
for system in sets:
disks = []
series = []
for perf in sets[system]:
if (perf[2] == mode):
if not perf[1] in disks:
disks.append(perf[1])
series.append(int(perf[3]))
results[system] = Series(series, index=disks)
df = DataFrame(results)
details = []
matched_category = []
for disk in df.transpose().columns:
if have_disk_data is False:
print
print "Group %d : Checking logical disks perf" % group_number
have_disk_data = True
consistent = []
curious = []
unstable = []
# How much the variance could be far from the average (in %)
tolerance_max = 10
tolerance_min = 2
# In random mode, the variance could be higher as
# we cannot insure the distribution pattern was similar
if "rand" in mode:
tolerance_min = 5
tolerance_max = 15
print_perf(tolerance_min, tolerance_max, df.transpose()[disk], df, mode, disk, consistent, curious, unstable, rampup_value, current_dir)
prepare_detail(detail_options, group_number, mode, disk, details, matched_category)
print_summary("%-30s %s" % (mode, disk), consistent, "consistent", "IOps", df)
print_summary("%-30s %s" % (mode, disk), curious, "curious", "IOps", df)
print_summary("%-30s %s" % (mode, disk), unstable, "unstable", "IOps", df)
print_detail(detail_options, details, df, matched_category)
def hpa(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "hpa", "(.*)", ['cache_serial_number', 'serial_number'])
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "HPA Controller")
return groups
def megaraid(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "megaraid", "(.*)", ['SerialNo', 'SasAddress', 'ControllerTemperature', 'VendorSpecific', 'RocTemperature'])
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "Megaraid Controller")
return groups
def systems(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "system", "(.*)", ['serial', 'uuid'])
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "System")
return groups
def firmware(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "firmware", "(.*)")
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "Firmware")
return groups
def memory_timing(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "memory", "DDR(.*)")
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "Memory Timing(RAM)")
return groups
def memory_banks(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "memory", "bank(.*)", ['serial'])
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "Memory Banks(RAM)")
return groups
def network_interfaces(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "network", "(.*)", ['serial', 'ipv4'])
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "Network Interfaces")
return groups
def cpu(global_params, systems, unique_id):
sets = search_item(systems, unique_id, "cpu", "(.*)", ['bogomips', 'loops_per_sec', 'bandwidth', 'cache_size', '/temperature'])
groups = compare_sets.compare(sets)
compare_sets.print_groups(global_params, groups, "Processors")
return groups
def print_perf(tolerance_min, tolerance_max, item, df, mode, title, consistent=None, curious=None, unstable=None, rampup_value=0, current_dir=""):
# Tolerance_min represents the min where variance shall be considered (in %)
# Tolerance_max represents the maximum that variance represent regarding the average (in %)
variance_group = item.std()
mean_group = item.mean()
sum_group = item.sum()
min_group = mean_group - 2*variance_group
max_group = mean_group + 2*variance_group
utils.do_print(mode, utils.Levels.INFO, "%-12s : Group performance : min=%8.2f, mean=%8.2f, max=%8.2f, stddev=%8.2f", title, item.min(), mean_group, item.max(), variance_group)
variance_tolerance = compute_deviance_percentage(title, df.transpose())
if (rampup_value > 0) and (current_dir):
utils.write_gnuplot_file(current_dir+"/deviance.plot", rampup_value, variance_group)
utils.write_gnuplot_file(current_dir+"/deviance_percentage.plot", rampup_value, variance_tolerance)
utils.write_gnuplot_file(current_dir+"/mean.plot", rampup_value, mean_group)
utils.write_gnuplot_file(current_dir+"/sum.plot", rampup_value, sum_group)
if (variance_tolerance > tolerance_max):
utils.do_print(mode, utils.Levels.ERROR, "%-12s : Group's variance is too important : %7.2f%% of %7.2f whereas limit is set to %3.2f%%", title, variance_tolerance, mean_group, tolerance_max)
utils.do_print(mode, utils.Levels.ERROR, "%-12s : Group performance : UNSTABLE", title)
for host in df.columns:
if host not in curious:
unstable.append(host)
else:
curious_performance = False
for host in df.columns:
if (("loops_per_sec") in mode) or ("bogomips" in mode):
mean_host = df[host][title].mean()
else:
mean_host = df[host].mean()
# If the variance is very low, don't try to find the black sheep
if (variance_tolerance > tolerance_min):
if (mean_host > max_group):
curious_performance = True
utils.do_print(mode, utils.Levels.WARNING, "%-12s : %s : Curious overperformance %7.2f : min_allow_group = %.2f, mean_group = %.2f max_allow_group = %.2f", title, host, mean_host, min_group, mean_group, max_group)
if host not in curious:
curious.append(host)
if host in consistent:
consistent.remove(host)
elif (mean_host < min_group):
curious_performance = True
utils.do_print(mode, utils.Levels.WARNING, "%-12s : %s : Curious underperformance %7.2f : min_allow_group = %.2f, mean_group = %.2f max_allow_group = %.2f", title, host, mean_host, min_group, mean_group, max_group)
if host not in curious:
curious.append(host)
if host in consistent:
consistent.remove(host)
else:
if (host not in consistent) and (host not in curious):
consistent.append(host)
else:
if (host not in consistent) and (host not in curious):
consistent.append(host)
unit = " "
if "Effi." in title:
unit = "%"
if curious_performance is False:
utils.do_print(mode, utils.Levels.INFO, "%-12s : Group performance = %7.2f %s : CONSISTENT", title, mean_group, unit)
else:
utils.do_print(mode, utils.Levels.WARNING, "%-12s : Group performance = %7.2f %s : SUSPICIOUS", title, mean_group, unit)
def print_summary(mode, array, array_name, unit, df, item_value=None):
if (utils.print_level & utils.Levels.SUMMARY) and (len(array) > 0):
result = []
before = ""
after = ""
RED = "\033[1;31m"
ORANGE = "\033[1;33m"
WHITE = "\033[1;m"
GREEN = "\033[1;32m"
for host in array:
result.append(df[host].sum())
if "unstable" in array_name:
before = RED
after = WHITE
if "curious" in array_name:
before = ORANGE
after = WHITE
mean = numpy.mean(result)
perf_status = ""
if array_name == "consistent":
if item_value is not None:
if mode == "loops_per_sec" or mode == "bogomips":
min_cpu_perf = perf_cpu_tables.get_cpu_min_perf(mode, item_value)
if min_cpu_perf == 0:
perf_status = ": " + ORANGE + "NO PERF ENTRY IN DB" + WHITE + " for " + item_value
elif (mean >= min_cpu_perf):
perf_status = ": " + GREEN + "PERF OK" + WHITE
else:
perf_status = ": " + RED + "PERF FAIL" + WHITE + " as min perf should have been : " + str(min_cpu_perf)
utils.do_print(mode, utils.Levels.SUMMARY, "%3d %s%-10s%s hosts with %8.2f %-4s as average value and %8.2f standard deviation %s", len(array), before, array_name, after, mean, unit, numpy.std(result), perf_status)
def cpu_perf(systems, unique_id, group_number, detail_options, rampup_value=0, current_dir=""):
have_cpu_data = False
host_cpu_list = search_item(systems, unique_id, "cpu", "(.*)", [], ['product'])
host_cpu_number = search_item(systems, unique_id, "cpu", "(.*logical.*)", [], ['number'])
core_counts = 1
for host in host_cpu_number:
for item in host_cpu_number[host]:
core_counts = item[3]
break
cpu_type = ''
for host in host_cpu_list:
for item in host_cpu_list[host]:
cpu_type = item[3]
break
modes = ['bogomips', 'loops_per_sec']
sets = search_item(systems, unique_id, "cpu", "(.*)", [], modes)
global_perf = dict()
for mode in modes:
results = {}
for system in sets:
cpu = []
series = []
found_data = False
for perf in sets[system]:
if (perf[2] == mode):
# We shall split individual cpu benchmarking from the global one
if ("_" in perf[1]):
if (not perf[1] in cpu):
cpu.append(perf[1])
series.append(float(perf[3]))
found_data = True
elif "loops_per_sec" in mode:
global_perf[system] = float(perf[3])
found_data = True
if found_data is True:
# If no series are populated, it means that a single "All CPU" run was done
# If so, let's create a single run value
if not series:
series.append(global_perf[system])
cpu.append("logical")
results[system] = Series(series, index=cpu)
# No need to continue if no CPU data in this benchmark
if not results:
continue
df = DataFrame(results)
consistent = []
curious = []
unstable = []
details = []
matched_category = []
for cpu in df.transpose().columns:
if have_cpu_data is False:
print
print "Group %d : Checking CPU perf" % group_number
have_cpu_data = True
print_perf(2, 7, df.transpose()[cpu], df, mode, cpu, consistent, curious, unstable, rampup_value, current_dir)
prepare_detail(detail_options, group_number, mode, cpu, details, matched_category)
print_detail(detail_options, details, df, matched_category)
print_summary(mode, consistent, "consistent", "", df, cpu_type)
print_summary(mode, curious, "curious", "", df)
print_summary(mode, unstable, "unstable", "", df)
if mode == "loops_per_sec":
efficiency = {}
mode_text = 'CPU Effi.'
consistent = []
curious = []
unstable = []
details = []
matched_category = []
for system in sets:
host_efficiency_full_load = []
host_perf = df[system].sum() * (int(core_counts) / df[system].count())
host_efficiency_full_load.append(global_perf[system] / host_perf * 100)
efficiency[system] = Series(host_efficiency_full_load, index=[mode_text])
cpu_eff = DataFrame(efficiency)
print_perf(1, 2, cpu_eff.transpose()[mode_text], cpu_eff, mode, mode_text, consistent, curious, unstable)
prepare_detail(detail_options, group_number, mode, mode_text, details, matched_category)
print_detail(detail_options, details, cpu_eff, matched_category)
print_summary("CPU Efficiency", consistent, "consistent", '%', cpu_eff)
print_summary("CPU Efficiency", curious, "curious", '%', cpu_eff)
print_summary("CPU Efficiency", unstable, "unstable", '%', cpu_eff)
def memory_perf(systems, unique_id, group_number, detail_options, rampup_value=0, current_dir=""):
have_memory_data = False
modes = ['1K', '4K', '1M', '16M', '128M', '256M', '1G', '2G']
sets = search_item(systems, unique_id, "cpu", "(.*)", [], modes)
for mode in modes:
real_mode = "Memory benchmark %s" % mode
results = {}
threaded_perf = dict()
forked_perf = dict()
for system in sets:
memory = []
series = []
found_data = ""
threaded_perf[system] = 0
forked_perf[system] = 0
for perf in sets[system]:
if (mode in perf[2]):
# We shall split individual cpu benchmarking from the global one
if ("logical_" in perf[1]) and (("bandwidth_%s" % mode) in perf[2]):
if (not perf[1] in memory):
memory.append(perf[1])
series.append(float(perf[3]))
elif ("threaded_bandwidth_%s" % mode) in perf[2]:
threaded_perf[system] = float(perf[3])
found_data = float(perf[3])
elif ("forked_bandwidth_%s" % mode) in perf[2]:
forked_perf[system] = float(perf[3])
found_data = float(perf[3])
if found_data:
# If no series are populated, it means that a single "All CPU" run was done
# If so, let's create a single run value
if not series:
series.append(found_data)
memory.append("logical")
results[system] = Series(series, index=memory)
# No need to continue if no Memory data in this benchmark
if not results:
continue
consistent = []
curious = []
unstable = []
details = []
matched_category = ''
df = DataFrame(results)
for memory in df.transpose().columns:
if have_memory_data is False:
print
print "Group %d : Checking Memory perf" % group_number
have_memory_data = True
print_perf(1, 7, df.transpose()[memory], df, real_mode, memory, consistent, curious, unstable, rampup_value, current_dir)
matched_category = []
prepare_detail(detail_options, group_number, mode, memory, details, matched_category)
print_detail(detail_options, details, df, matched_category)
print_summary(mode, consistent, "consistent", "MB/s", df)
print_summary(mode, curious, "curious", "MB/s", df)
print_summary(mode, unstable, "unstable", "MB/s", df)
for bench_type in ["threaded", "forked"]:
efficiency = {}
have_forked_or_threaded = False
if ("threaded" in bench_type):
mode_text = "Thread effi."
else:
mode_text = "Forked Effi."
for system in sets:
host_efficiency_full_load = []
host_perf = df[system].sum()
if (host_perf > 0) and (threaded_perf[system] > 0) and (forked_perf[system] > 0):
have_forked_or_threaded = True
if ("threaded" in bench_type):
host_efficiency_full_load.append(threaded_perf[system] / host_perf * 100)
else:
host_efficiency_full_load.append(forked_perf[system] / host_perf * 100)
efficiency[system] = Series(host_efficiency_full_load, index=[mode_text])
details = []
memory_eff = DataFrame(efficiency)
if have_forked_or_threaded is True:
consistent = []
curious = []
unstable = []
for memory in memory_eff.transpose().columns:
print_perf(2, 10, memory_eff.transpose()[memory], memory_eff, real_mode, memory, consistent, curious, unstable)
matched_category = []
prepare_detail(detail_options, group_number, mode, memory, details, matched_category)
# Let's pad if its a thread or forked effi in addition of the block size
if matched_category:
matched_category[0] += " " + mode_text
print_detail(detail_options, details, memory_eff, matched_category)
print_summary(mode + " " + mode_text, consistent, "consistent", "%", memory_eff)
print_summary(mode + " " + mode_text, curious, "curious", "%", memory_eff)
print_summary(mode + " " + mode_text, unstable, "unstable", "%", memory_eff)
else:
utils.do_print(real_mode, utils.Levels.WARNING, "%-12s : Benchmark not run on this group", mode_text)
| 42.83816 | 234 | 0.587688 |
8c29c63f8bbd1b6fa72461e323f869109e2c1624 | 548 | py | Python | jbupower/jbupower/wsgi.py | arc-menace/JBU-Solar-Power-Mobile-App | 95cb97e273260e2f9ce0e0c492d60bff4008839c | [
"MIT"
] | null | null | null | jbupower/jbupower/wsgi.py | arc-menace/JBU-Solar-Power-Mobile-App | 95cb97e273260e2f9ce0e0c492d60bff4008839c | [
"MIT"
] | null | null | null | jbupower/jbupower/wsgi.py | arc-menace/JBU-Solar-Power-Mobile-App | 95cb97e273260e2f9ce0e0c492d60bff4008839c | [
"MIT"
] | null | null | null | """
WSGI config for jbupower project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.0/howto/deployment/wsgi/
"""
import os
import sys
from django.core.wsgi import get_wsgi_application
sys.path.append('/home/ubuntu/EE-3503-01-Final-Project/jbupower')
sys.path.append('/home/ubuntu/EE-3503-01-Final-Project/jbupower/jbupower')
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'jbupower.settings')
application = get_wsgi_application()
| 23.826087 | 78 | 0.781022 |
4ee70b67b2414a8cb44adaa6e324e36d30889bc7 | 1,684 | py | Python | modify_annotations_txt.py | wenzhenmiao/KITTI_to_tfrecords | febb7ab1948c827a0c9071ba0d1d1a859ce9a47c | [
"Apache-2.0"
] | 1 | 2020-03-09T19:23:02.000Z | 2020-03-09T19:23:02.000Z | modify_annotations_txt.py | wenzhenmiao/KITTI_to_tfrecords | febb7ab1948c827a0c9071ba0d1d1a859ce9a47c | [
"Apache-2.0"
] | null | null | null | modify_annotations_txt.py | wenzhenmiao/KITTI_to_tfrecords | febb7ab1948c827a0c9071ba0d1d1a859ce9a47c | [
"Apache-2.0"
] | null | null | null | #nnotations_txt.py
import glob
import string
txt_list = glob.glob('./Labels/*.txt')
def show_category(txt_list):
category_list= []
for item in txt_list:
try:
with open(item) as tdf:
for each_line in tdf:
labeldata = each_line.strip().split(' ')
category_list.append(labeldata[0])
except IOError as ioerr:
print('File error:'+str(ioerr))
print(set(category_list))
def merge(line):
each_line=''
for i in range(len(line)):
if i!= (len(line)-1):
each_line=each_line+line[i]+' '
else:
each_line=each_line+line[i]
each_line=each_line+'\n'
return (each_line)
print('before modify categories are:\n')
show_category(txt_list)
for item in txt_list:
new_txt=[]
try:
with open(item, 'r') as r_tdf:
for each_line in r_tdf:
labeldata = each_line.strip().split(' ')
if labeldata[0] in ['Truck','Van','Tram']:
labeldata[0] = labeldata[0].replace(labeldata[0],'Car')
if labeldata[0] == 'Person_sitting':
labeldata[0] = labeldata[0].replace(labeldata[0],'Pedestrian')
if labeldata[0] == 'DontCare':
continue
if labeldata[0] == 'Misc':
continue
new_txt.append(merge(labeldata))
with open(item,'w+') as w_tdf:
for temp in new_txt:
w_tdf.write(temp)
except IOError as ioerr:
print('File error:'+str(ioerr))
print('\nafter modify categories are:\n')
show_category(txt_list)
| 31.185185 | 82 | 0.543943 |
deb60520fad27cc2768d450f1ff2ec483b1a08b0 | 7,071 | py | Python | src/trw/layers/convs.py | civodlu/trw | b9a1cf045f61d6df9c65c014ef63b4048972dcdc | [
"MIT"
] | 3 | 2019-07-04T01:20:41.000Z | 2020-01-27T02:36:12.000Z | src/trw/layers/convs.py | civodlu/trw | b9a1cf045f61d6df9c65c014ef63b4048972dcdc | [
"MIT"
] | null | null | null | src/trw/layers/convs.py | civodlu/trw | b9a1cf045f61d6df9c65c014ef63b4048972dcdc | [
"MIT"
] | 2 | 2020-10-19T13:46:06.000Z | 2021-12-27T02:18:10.000Z | import collections
import copy
from numbers import Number
import torch
from ..basic_typing import Activation, ConvKernels, ConvStrides, PoolingSizes, Paddings, IntListList
from .utils import div_shape
from .blocks import BlockConvNormActivation, BlockPool, ConvBlockType
from .layer_config import default_layer_config, NormType, LayerConfig
import torch.nn as nn
from typing import Union, Dict, Sequence, Optional, List
from ..utils import flatten
class ModuleWithIntermediate:
"""
Represent a module with intermediate results
"""
def forward_with_intermediate(self, x: torch.Tensor, **kwargs) -> Sequence[torch.Tensor]:
raise NotImplementedError()
class ConvsBase(nn.Module, ModuleWithIntermediate):
def __init__(
self,
dimensionality: int,
input_channels: int,
*,
channels: Sequence[int],
convolution_kernels: ConvKernels = 5,
strides: ConvStrides = 1,
pooling_size: Optional[PoolingSizes] = 2,
convolution_repeats: Union[int, Sequence[int], IntListList] = 1,
activation: Optional[Activation] = nn.ReLU,
padding: Paddings = 'same',
with_flatten: bool = False,
dropout_probability: Optional[float] = None,
norm_type: Optional[NormType] = None,
norm_kwargs: Dict = {},
pool_kwargs: Dict = {},
activation_kwargs: Dict = {},
last_layer_is_output: bool = False,
conv_block_fn: ConvBlockType = BlockConvNormActivation,
config: LayerConfig = default_layer_config(dimensionality=None)):
"""
Args:
dimensionality: the dimension of the CNN (2 for 2D or 3 for 3D)
input_channels: the number of input channels
channels: the number of channels for each convolutional layer
convolution_kernels: for each convolution group, the kernel of the convolution
strides: for each convolution group, the stride of the convolution
pooling_size: the pooling size to be inserted after each convolution group
convolution_repeats: the number of repeats of a convolution. ``1`` means no repeat.
activation: the activation function
with_flatten: if True, the last output will be flattened
norm_kwargs: additional arguments to be used for the normalization layer
padding: 'same' will add padding so that convolution output as the same size as input
last_layer_is_output: if True, the last convolution will NOT have activation, dropout, batch norm, LRN
dropout_probability: dropout probability
"""
super().__init__()
# update the configuration locally
config = copy.copy(config)
if norm_type is not None:
config.norm_type = norm_type
if activation is not None:
config.activation = activation
config.set_dim(dimensionality)
config.pool_kwargs = {**pool_kwargs, **config.pool_kwargs}
config.norm_kwargs = {**norm_kwargs, **config.norm_kwargs}
config.activation_kwargs = {**activation_kwargs, **config.activation_kwargs}
self.dimensionality = dimensionality
# normalize the arguments
nb_convs = len(channels)
if not isinstance(convolution_kernels, collections.Sequence):
convolution_kernels = [convolution_kernels] * nb_convs
if not isinstance(strides, collections.Sequence):
assert isinstance(strides, int) or (isinstance(strides, tuple) and isinstance(strides[0], int)), \
'stride must be a number or a tuple!'
strides = [strides] * nb_convs # type: ignore
if not isinstance(pooling_size, collections.Sequence) and pooling_size is not None:
pooling_size = [pooling_size] * nb_convs
if isinstance(convolution_repeats, int):
convolution_repeats = [convolution_repeats] * nb_convs
if isinstance(padding, int):
padding = [padding] * nb_convs
elif isinstance(padding, str):
pass
else:
assert len(padding) == nb_convs
assert nb_convs == len(convolution_kernels), 'must be specified for each convolutional layer'
assert nb_convs == len(strides), 'must be specified for each convolutional layer'
assert pooling_size is None or nb_convs == len(pooling_size), 'must be specified for each convolutional layer'
assert nb_convs == len(convolution_repeats)
assert isinstance(convolution_repeats, collections.Sequence)
self.with_flatten = with_flatten
layers = nn.ModuleList()
prev = input_channels
for n in range(len(channels)):
is_last_layer = (n + 1) == len(channels)
current = channels[n]
if padding == 'same':
p = div_shape(convolution_kernels[n], 2)
else:
assert not isinstance(padding, str)
p = padding[n] # type: ignore
ops = []
nb_repeats = convolution_repeats[n]
assert isinstance(nb_repeats, int)
for r in range(nb_repeats):
is_last_repetition = (r + 1) == nb_repeats
if is_last_repetition:
stride = strides[n]
else:
stride = 1
if last_layer_is_output and is_last_layer and is_last_repetition:
# Last layer layer should not have dropout/normalization/activation
config.activation = None
config.norm = None
config.dropout = None
ops.append(conv_block_fn(config, prev, current, kernel_size=convolution_kernels[n], padding=p, stride=stride)) # type: ignore
prev = current
if pooling_size is not None:
ops.append(BlockPool(config, kernel_size=pooling_size[n]))
if not is_last_layer or not last_layer_is_output:
if dropout_probability is not None and config.dropout is not None:
ops.append(config.dropout(p=dropout_probability, **config.dropout_kwargs))
layers.append(nn.Sequential(*ops))
self.layers = layers
def forward_simple(self, x: torch.Tensor) -> torch.Tensor:
for layer in self.layers:
x = layer(x)
if self.with_flatten:
x = flatten(x)
return x
def forward_with_intermediate(self, x: torch.Tensor, **kwargs) -> List[torch.Tensor]:
assert len(kwargs) == 0, f'unsupported arguments={kwargs}'
assert len(x.shape) == self.dimensionality + 2, \
f'Expecting a tensor (batch and channel included) of dim={self.dimensionality + 2}, got={len(x.shape)}'
r = []
for layer in self.layers:
x = layer(x)
r.append(x)
return r
def forward(self, x):
return self.forward_simple(x)
| 41.594118 | 142 | 0.6282 |
225024b78913c6a207ecb440904e04f9ecd6eb6a | 3,048 | py | Python | authors/apps/articles/migrations/0001_initial.py | andela/ah-backend-tabs | c94704175ecd531f69dbcb6523a8183c2f4bd77f | [
"BSD-3-Clause"
] | null | null | null | authors/apps/articles/migrations/0001_initial.py | andela/ah-backend-tabs | c94704175ecd531f69dbcb6523a8183c2f4bd77f | [
"BSD-3-Clause"
] | 48 | 2018-07-24T14:04:53.000Z | 2022-03-11T23:26:49.000Z | authors/apps/articles/migrations/0001_initial.py | andela/ah-backend-tabs | c94704175ecd531f69dbcb6523a8183c2f4bd77f | [
"BSD-3-Clause"
] | 3 | 2018-07-26T17:01:44.000Z | 2018-09-11T07:49:12.000Z | # Generated by Django 2.0.7 on 2018-09-21 11:33
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Article',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('title', models.CharField(max_length=500)),
('description', models.TextField()),
('slug', models.SlugField(blank=True, max_length=255)),
('body', models.TextField()),
('created_at', models.DateTimeField(editable=False)),
('updated_at', models.DateTimeField(blank=True, null=True)),
('favorited', models.BooleanField(default=False)),
('favoritesCount', models.IntegerField(default=0)),
('rating', models.PositiveIntegerField(blank=True, editable=False, null=True)),
('likesCount', models.IntegerField(default=0)),
('dislikesCount', models.IntegerField(default=0)),
('image', models.TextField(blank=True, null=True)),
('viewsCount', models.IntegerField(default=0)),
],
options={
'ordering': ('-created_at',),
},
),
migrations.CreateModel(
name='Comment',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('body', models.TextField()),
('created_at', models.DateTimeField(auto_now=True)),
('updated_at', models.DateTimeField(auto_now_add=True, null=True)),
],
options={
'ordering': ('-created_at',),
},
),
migrations.CreateModel(
name='Rating',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('amount', models.PositiveIntegerField(choices=[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)])),
],
options={
'ordering': ('-amount',),
},
),
migrations.CreateModel(
name='TextComment',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('selected', models.TextField()),
('body', models.TextField()),
('created_at', models.DateTimeField(auto_now=True)),
('updated_at', models.DateTimeField(auto_now_add=True, null=True)),
('article', models.ForeignKey(blank=True, on_delete=django.db.models.deletion.CASCADE, related_name='user_text_comments', to='articles.Article')),
],
options={
'ordering': ('-created_at',),
},
),
]
| 41.189189 | 162 | 0.534121 |
9bd3c49ea97d8c2935c70e5f4d84d3b7ec823488 | 12,861 | py | Python | google-cloud-sdk/lib/googlecloudsdk/third_party/appengine/api/datastore_entities.py | bopopescu/Social-Lite | ee05d6a7431c36ff582c8d6b58bb20a8c5f550bf | [
"Apache-2.0"
] | 2 | 2019-11-10T09:17:07.000Z | 2019-12-18T13:44:08.000Z | google-cloud-sdk/lib/googlecloudsdk/third_party/appengine/api/datastore_entities.py | bopopescu/Social-Lite | ee05d6a7431c36ff582c8d6b58bb20a8c5f550bf | [
"Apache-2.0"
] | 4 | 2020-07-21T12:51:46.000Z | 2022-01-22T10:29:25.000Z | google-cloud-sdk/lib/googlecloudsdk/third_party/appengine/api/datastore_entities.py | bopopescu/Social-Lite | ee05d6a7431c36ff582c8d6b58bb20a8c5f550bf | [
"Apache-2.0"
] | 1 | 2020-07-25T01:40:19.000Z | 2020-07-25T01:40:19.000Z | #
# Copyright 2006 Google LLC.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Classes for common kinds, including Contact, Message, and Event.
Most of these kinds are based on the gd namespace "kinds" from GData:
https://developers.google.com/gdata/docs/1.0/elements
"""
# WARNING: This file is externally viewable by our users. All comments from
# this file will be stripped. The docstrings will NOT. Do not put sensitive
# information in docstrings. If you must communicate internal information in
# this source file, please place them in comments only.
# TODO(user): rename this file datastore_kinds.py
from __future__ import absolute_import
from __future__ import unicode_literals
from xml.sax import saxutils
from googlecloudsdk.third_party.appengine.datastore import datastore_pb
from googlecloudsdk.third_party.appengine.api import datastore
from googlecloudsdk.third_party.appengine.api import datastore_errors
from googlecloudsdk.third_party.appengine.api import datastore_types
from googlecloudsdk.third_party.appengine._internal import six_subset
class GdKind(datastore.Entity):
""" A base class for gd namespace kinds.
This class contains common logic for all gd namespace kinds. For example,
this class translates datastore (app id, kind, key) tuples to tag:
URIs appropriate for use in <key> tags.
"""
HEADER = """<entry xmlns:gd='http://schemas.google.com/g/2005'>
<category scheme='http://schemas.google.com/g/2005#kind'
term='http://schemas.google.com/g/2005#%s' />"""
FOOTER = """
</entry>"""
_kind_properties = set()
_contact_properties = set()
def __init__(self, kind, title, kind_properties, contact_properties=[]):
""" Ctor.
title is the name of this particular entity, e.g. Bob Jones or Mom's
Birthday Party.
kind_properties is a list of property names that should be included in
this entity's XML encoding as first-class XML elements, instead of
<property> elements. 'title' and 'content' are added to kind_properties
automatically, and may not appear in contact_properties.
contact_properties is a list of property names that are Keys that point to
Contact entities, and should be included in this entity's XML encoding as
<gd:who> elements. If a property name is included in both kind_properties
and contact_properties, it is treated as a Contact property.
Args:
kind: string
title: string
kind_properties: list of strings
contact_properties: list of string
"""
datastore.Entity.__init__(self, kind)
if not isinstance(title, six_subset.string_types):
raise datastore_errors.BadValueError(
'Expected a string for title; received %s (a %s).' %
(title, datastore_types.typename(title)))
self['title'] = title
self['content'] = ''
# automatic properties (like title and content) can't be contact properties
self._contact_properties = set(contact_properties)
assert not self._contact_properties.intersection(list(self.keys()))
self._kind_properties = set(kind_properties) - self._contact_properties
self._kind_properties.add('title')
self._kind_properties.add('content')
def _KindPropertiesToXml(self):
""" Convert the properties that are part of this gd kind to XML. For
testability, the XML elements in the output are sorted alphabetically
by property name.
Returns:
string # the XML representation of the gd kind properties
"""
properties = self._kind_properties.intersection(set(self.keys()))
xml = ''
for prop in sorted(properties):
prop_xml = saxutils.quoteattr(prop)[1:-1] # strip the enclosing quotes
value = self[prop]
has_toxml = (hasattr(value, 'ToXml') or
isinstance(value, list) and hasattr(value[0], 'ToXml'))
for val in self._XmlEscapeValues(prop):
# _XmlEscapeValues() puts XML tags around the property values
# *if they have a ToXml() method*. if not, it leaves them unchanged.
if has_toxml:
xml += '\n %s' % val
else:
xml += '\n <%s>%s</%s>' % (prop_xml, val, prop_xml)
return xml
def _ContactPropertiesToXml(self):
""" Convert this kind's Contact properties kind to XML. For testability,
the XML elements in the output are sorted alphabetically by property name.
Returns:
string # the XML representation of the Contact properties
"""
properties = self._contact_properties.intersection(set(self.keys()))
xml = ''
for prop in sorted(properties):
values = self[prop]
if not isinstance(values, list):
values = [values]
for value in values:
assert isinstance(value, datastore_types.Key)
xml += """
<gd:who rel="http://schemas.google.com/g/2005#%s.%s>
<gd:entryLink href="%s" />
</gd:who>""" % (self.kind().lower(), prop, value.ToTagUri())
return xml
def _LeftoverPropertiesToXml(self):
""" Convert all of this entity's properties that *aren't* part of this gd
kind to XML.
Returns:
string # the XML representation of the leftover properties
"""
leftovers = set(self.keys())
leftovers -= self._kind_properties
leftovers -= self._contact_properties
if leftovers:
return '\n ' + '\n '.join(self._PropertiesToXml(leftovers))
else:
return ''
def ToXml(self):
""" Returns an XML representation of this entity, as a string.
"""
xml = GdKind.HEADER % self.kind().lower() # lower case
xml += self._KindPropertiesToXml()
xml += self._ContactPropertiesToXml()
xml += self._LeftoverPropertiesToXml()
xml += GdKind.FOOTER
return xml
class Message(GdKind):
"""A message, such as an email, a discussion group posting, or a comment.
Includes the message title, contents, participants, and other properties.
This is the gd Message kind. See:
https://developers.google.com/gdata/docs/1.0/elements#gdMessageKind
These properties are meaningful. They are all optional.
property name property type meaning
-------------------------------------
title string message subject
content string message body
from Contact* sender
to Contact* primary recipient
cc Contact* CC recipient
bcc Contact* BCC recipient
reply-to Contact* intended recipient of replies
link Link* attachment
category Category* tag or label associated with this message
geoPt GeoPt* geographic location the message was posted from
rating Rating* message rating, as defined by the application
* means this property may be repeated.
The Contact properties should be Keys of Contact entities. They are
represented in the XML encoding as linked <gd:who> elements.
"""
KIND_PROPERTIES = ['title', 'content', 'link', 'category', 'geoPt', 'rating']
CONTACT_PROPERTIES = ['from', 'to', 'cc', 'bcc', 'reply-to']
def __init__(self, title, kind='Message'):
GdKind.__init__(self, kind, title, Message.KIND_PROPERTIES,
Message.CONTACT_PROPERTIES)
class Event(GdKind):
"""A calendar event.
Includes the event title, description, location, organizer, start and end
time, and other details.
This is the gd Event kind. See:
https://developers.google.com/gdata/docs/1.0/elements#gdEventKind
These properties are meaningful. They are all optional.
property name property type meaning
-------------------------------------
title string event name
content string event description
author string the organizer's name
where string* human-readable location (not a GeoPt)
startTime timestamp start time
endTime timestamp end time
eventStatus string one of the Event.Status values
link Link* page with more information
category Category* tag or label associated with this event
attendee Contact* attendees and other related people
* means this property may be repeated.
The Contact properties should be Keys of Contact entities. They are
represented in the XML encoding as linked <gd:who> elements.
"""
KIND_PROPERTIES = ['title', 'content', 'author', 'where', 'startTime',
'endTime', 'eventStatus', 'link', 'category']
CONTACT_PROPERTIES = ['attendee']
class Status: # an enum
CONFIRMED = 'confirmed'
TENTATIVE = 'tentative'
CANCELED = 'canceled'
def __init__(self, title, kind='Event'):
GdKind.__init__(self, kind, title, Event.KIND_PROPERTIES,
Event.CONTACT_PROPERTIES)
def ToXml(self):
""" Override GdKind.ToXml() to special-case author, gd:where, gd:when, and
gd:eventStatus.
"""
xml = GdKind.HEADER % self.kind().lower() # lower case
self._kind_properties = set(Contact.KIND_PROPERTIES)
xml += self._KindPropertiesToXml()
# author becomes <author><name>
if 'author' in self:
xml += """
<author><name>%s</name></author>""" % self['author']
# eventStatus becomes gd:eventStatus
if 'eventStatus' in self:
xml += """
<gd:eventStatus value="http://schemas.google.com/g/2005#event.%s" />""" % (
self['eventStatus'])
# where becomes gd:where
if 'where' in self:
lines = ['<gd:where valueString="%s" />' % val
for val in self._XmlEscapeValues('where')]
xml += '\n ' + '\n '.join(lines)
# startTime and endTime become gd:when
iso_format = '%Y-%m-%dT%H:%M:%S'
xml += '\n <gd:when'
for key in ['startTime', 'endTime']:
if key in self:
xml += ' %s="%s"' % (key, self[key].isoformat())
xml += ' />'
self._kind_properties.update(['author', 'where', 'startTime', 'endTime',
'eventStatus'])
xml += self._ContactPropertiesToXml()
xml += self._LeftoverPropertiesToXml()
xml += GdKind.FOOTER
return xml
class Contact(GdKind):
"""A contact: a person, a venue such as a club or a restaurant, or an
organization.
This is the gd Contact kind. See:
https://developers.google.com/gdata/docs/1.0/elements#gdContactKind
Most of the information about the contact is in the <gd:contactSection>
element; see the reference section for that element for details.
These properties are meaningful. They are all optional.
property name property type meaning
-------------------------------------
title string contact's name
content string notes
email Email* email address
geoPt GeoPt* geographic location
im IM* IM address
phoneNumber Phonenumber* phone number
postalAddress PostalAddress* mailing address
link Link* link to more information
category Category* tag or label associated with this contact
* means this property may be repeated.
"""
CONTACT_SECTION_HEADER = """
<gd:contactSection>"""
CONTACT_SECTION_FOOTER = """
</gd:contactSection>"""
# properties that go in top-level entry element
KIND_PROPERTIES = ['title', 'content', 'link', 'category']
# properties that go in gd:contactSection element
CONTACT_SECTION_PROPERTIES = ['email', 'geoPt', 'im', 'phoneNumber',
'postalAddress']
def __init__(self, title, kind='Contact'):
GdKind.__init__(self, kind, title, Contact.KIND_PROPERTIES)
def ToXml(self):
""" Override GdKind.ToXml() to put some properties inside a
gd:contactSection.
"""
xml = GdKind.HEADER % self.kind().lower() # lower case
# put the kind properties in the top level...
self._kind_properties = set(Contact.KIND_PROPERTIES)
xml += self._KindPropertiesToXml()
# ...and the contact section properties inside the gd:contactSection elem
xml += Contact.CONTACT_SECTION_HEADER
self._kind_properties = set(Contact.CONTACT_SECTION_PROPERTIES)
xml += self._KindPropertiesToXml()
xml += Contact.CONTACT_SECTION_FOOTER
self._kind_properties.update(Contact.KIND_PROPERTIES)
xml += self._LeftoverPropertiesToXml()
xml += GdKind.FOOTER
return xml
| 35.626039 | 79 | 0.667366 |
4ada1d51ea5810e87e8adbcc30e87b4441a925ad | 3,820 | py | Python | generalizedtrees/tests/test_fgroups.py | Craven-Biostat-Lab/generalizedtrees | c0b9d8727d21d1fcb2e0d72f71159f049d8fc22f | [
"BSD-3-Clause"
] | null | null | null | generalizedtrees/tests/test_fgroups.py | Craven-Biostat-Lab/generalizedtrees | c0b9d8727d21d1fcb2e0d72f71159f049d8fc22f | [
"BSD-3-Clause"
] | 61 | 2019-09-30T17:40:48.000Z | 2020-10-31T01:38:19.000Z | generalizedtrees/tests/test_fgroups.py | Craven-Biostat-Lab/generalizedtrees | c0b9d8727d21d1fcb2e0d72f71159f049d8fc22f | [
"BSD-3-Clause"
] | null | null | null | from generalizedtrees.features import FeatureSpec
import pytest
def test_fgroups_method(breast_cancer_data, breast_cancer_rf_model, caplog):
from generalizedtrees import learn, givens, predict, queues, stop, split, grow, leaves, generate, node
from time import perf_counter
import logging
logger = logging.getLogger()
caplog.set_level(logging.DEBUG)
x_train = breast_cancer_data.x_train
x_test = breast_cancer_data.x_test
model = breast_cancer_rf_model
# Feature groups
fg = [[x, x+10, x+20] for x in range(10)]
logger.info("Creating explainer object")
explainer = learn.GreedyTreeLearner()
explainer.builder.splitter = split.GroupSplitConstructorLC(search_mode='groups')
explainer.builder.splitter.only_use_training_to_generate = True
explainer.builder.splitter.only_use_training_to_score = False
explainer.givens = givens.DataWithOracleGivensLC()
explainer.predictor = predict.ClassifierLC()
explainer.queue = queues.Heap
explainer.local_stop = stop.LocalStopSaturation(training_only=True)
explainer.global_stop = stop.GlobalStopTreeSizeLC(max_size=5)
explainer.split_score = split.ProbabilityImpurityLC('entopy')
explainer.split_generator = split.AxisAlignedSplitGeneratorLC()
explainer.node_builder = grow.ModelTranslationNodeBuilderLC(
leaf_model=leaves.ConstantEstimator,
min_samples=1000,
data_factory=generate.TrepanDataFactoryLC(alpha=0.05, max_attempts=3),
node_type=node.TrepanNode,
)
logger.info("Fitting tree")
t1 = perf_counter()
explainer.fit(x_train, model, feature_groups = fg)
t2 = perf_counter()
logger.info(f'Time taken: {t2-t1}')
logger.info(f'Learned tree:\n{explainer.show_tree()}')
# Make predictions
logger.info("Running prediction")
#trepan_predictions =
explainer.predict(x_test)
logger.info("Done")
def test_fgroups_method_bin_data(small_weights_data, small_weights_model, caplog):
from generalizedtrees import learn, givens, predict, queues, stop, split, grow, leaves, generate, node
from time import perf_counter
import logging
logger = logging.getLogger()
caplog.set_level(logging.DEBUG)
x_train = small_weights_data.x_train
x_test = small_weights_data.x_test
model = small_weights_model
# Feature groups
fg = [[0,1,2,3], [3,4,5], [5,6,7,8,9], [12, 15]]
logger.info("Creating explainer object")
explainer = learn.GreedyTreeLearner()
explainer.builder.splitter = split.GroupSplitConstructorLC(search_mode='groups')
explainer.builder.splitter.only_use_training_to_generate = True
explainer.builder.splitter.only_use_training_to_score = False
explainer.givens = givens.DataWithOracleGivensLC()
explainer.predictor = predict.ClassifierLC()
explainer.queue = queues.Heap
explainer.local_stop = stop.LocalStopSaturation(training_only=True)
explainer.global_stop = stop.GlobalStopTreeSizeLC(max_size=5)
explainer.split_score = split.ProbabilityImpurityLC('entopy')
explainer.split_generator = split.AxisAlignedSplitGeneratorLC()
explainer.node_builder = grow.ModelTranslationNodeBuilderLC(
leaf_model=leaves.ConstantEstimator,
min_samples=1000,
data_factory=generate.TrepanDataFactoryLC(alpha=0.05, max_attempts=3),
node_type=node.TrepanNode,
)
logger.info("Fitting tree")
t1 = perf_counter()
explainer.fit(x_train, model, feature_groups = fg, feature_spec = (FeatureSpec.DISCRETE,) * 10)
t2 = perf_counter()
logger.info(f'Time taken: {t2-t1}')
logger.info(f'Learned tree:\n{explainer.show_tree()}')
# Make predictions
logger.info("Running prediction")
#trepan_predictions =
explainer.predict(x_test)
logger.info("Done")
| 33.508772 | 106 | 0.737958 |
92fff636bb89f2152ee91ba5ff190af571cf07c3 | 785 | py | Python | ejemplos/musica_ligera/musica_ligera.py | agalbachicar/estadistica | 8b1be727b898a8cda2e6a3148d33eb03e3f124aa | [
"Apache-2.0"
] | null | null | null | ejemplos/musica_ligera/musica_ligera.py | agalbachicar/estadistica | 8b1be727b898a8cda2e6a3148d33eb03e3f124aa | [
"Apache-2.0"
] | null | null | null | ejemplos/musica_ligera/musica_ligera.py | agalbachicar/estadistica | 8b1be727b898a8cda2e6a3148d33eb03e3f124aa | [
"Apache-2.0"
] | null | null | null |
SONG='''Ella durmió
Al calor de las masas
Y yo desperté
Queriendo soñarla
Algún tiempo atrás
Pensé en escribirle
Que nunca sorteé
Las trampas del amor
De aquel amor
De música ligera
Nada nos libra
Nada más queda
No le enviaré
Cenizas de rosas
Ni pienso evitar
Un roce secreto
De aquel amor
De música ligera
Nada nos libra
Nada más queda
De aquel amor
De música ligera
Nada nos libra
Nada más queda
Nada más
Nada más queda
Nada más queda
Nada más queda
'''
words = SONG.lower().split()
words_set = set(words)
words_count = [(word, words.count(word)) for word in words_set]
print("Palabras: repeticion")
for w,c in words_count: print("\t{} : {}".format(w, c))
print("Cantidad de palabras: {}".format(len(words)))
print("Cantidad de palabras unicas: {}".format(len(words_set)))
| 16.702128 | 63 | 0.746497 |
562ae08234067e5c835fbb8113daedde315af887 | 686 | py | Python | basic/mythread/processqueue.py | fplust/python3-cookbook | 0eaca2e3631bb69deaf466c32023bbb2093513da | [
"Apache-2.0"
] | 1 | 2019-07-25T09:09:54.000Z | 2019-07-25T09:09:54.000Z | basic/mythread/processqueue.py | fplust/python3-cookbook | 0eaca2e3631bb69deaf466c32023bbb2093513da | [
"Apache-2.0"
] | null | null | null | basic/mythread/processqueue.py | fplust/python3-cookbook | 0eaca2e3631bb69deaf466c32023bbb2093513da | [
"Apache-2.0"
] | null | null | null | #!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
Topic: 多进程通信，使用消息队列通信
Desc :
"""
import multiprocessing
import time
__author__ = 'Xiong Neng'
def consumer(input_q):
while True:
item = input_q.get()
print(item)
input_q.task_done()
def producer(seq, output_q):
for item in seq:
output_q.put(item)
time.sleep(0.6)
def demo():
q = multiprocessing.JoinableQueue() # 可连接的共享进程队列
cons_p = multiprocessing.Process(target=consumer, args=(q, ))
cons_p.daemon = True
cons_p.start()
seq = [1, 2, 3, 4, 5]
producer(seq, q)
q.join() # 保证在主进程退出前，共享队列中所有元素都被处理完了
if __name__ == '__main__':
demo()
| 17.15 | 65 | 0.606414 |
ef4b59630d36f10eaaefa245c97d099335c79928 | 10,124 | py | Python | awx/main/tests/functional/test_projects.py | Akasurde/awx | b81c9dbeeaa891b258364a6471924e3f43994430 | [
"Apache-2.0"
] | 2 | 2021-01-13T09:30:51.000Z | 2022-02-07T07:29:28.000Z | awx/main/tests/functional/test_projects.py | Akasurde/awx | b81c9dbeeaa891b258364a6471924e3f43994430 | [
"Apache-2.0"
] | 12 | 2021-06-17T07:32:11.000Z | 2022-03-29T22:11:45.000Z | awx/main/tests/functional/test_projects.py | Akasurde/awx | b81c9dbeeaa891b258364a6471924e3f43994430 | [
"Apache-2.0"
] | 9 | 2020-08-18T16:07:13.000Z | 2022-03-22T17:42:30.000Z | # -*- coding: utf-8 -*-
from unittest import mock # noqa
import pytest
from awx.api.versioning import reverse
from awx.main.models import Project
from django.core.exceptions import ValidationError
#
# Project listing and visibility tests
#
@pytest.fixture
def team_project_list(organization_factory):
objects = organization_factory('org-test',
superusers=['admin'],
users=['team1:alice', 'team2:bob'],
teams=['team1', 'team2'],
projects=['pteam1', 'pteam2', 'pshared'],
roles=['team1.member_role:pteam1.admin_role',
'team2.member_role:pteam2.admin_role',
'team1.member_role:pshared.admin_role',
'team2.member_role:pshared.admin_role'])
return objects
@pytest.mark.django_db
def test_get_project_path(project):
# Test combining projects root with project local path
with mock.patch('awx.main.models.projects.settings.PROJECTS_ROOT', '/var/lib/awx'):
assert project.get_project_path(check_if_exists=False) == '/var/lib/awx/_92__test_proj'
@pytest.mark.django_db
def test_user_project_paged_list(get, organization_factory):
'Test project listing that spans multiple pages'
# 3 total projects, 1 per page, 3 pages
objects = organization_factory(
'org1',
projects=['project-%s' % i for i in range(3)],
users=['alice'],
roles=['project-%s.admin_role:alice' % i for i in range(3)],
)
# first page has first project and no previous page
pk = objects.users.alice.pk
url = reverse('api:user_projects_list', kwargs={'pk':pk,})
results = get(url, objects.users.alice, QUERY_STRING='page_size=1').data
assert results['count'] == 3
assert len(results['results']) == 1
assert results['previous'] is None
assert results['next'] == (
'/api/v2/users/%s/projects/?page=2&page_size=1' % pk
)
# second page has one more, a previous and next page
results = get(url, objects.users.alice,
QUERY_STRING='page=2&page_size=1').data
assert len(results['results']) == 1
assert results['previous'] == (
'/api/v2/users/%s/projects/?page=1&page_size=1' % pk
)
assert results['next'] == (
'/api/v2/users/%s/projects/?page=3&page_size=1' % pk
)
# third page has last project and a previous page
results = get(url, objects.users.alice,
QUERY_STRING='page=3&page_size=1').data
assert len(results['results']) == 1
assert results['previous'] == (
'/api/v2/users/%s/projects/?page=2&page_size=1' % pk
)
assert results['next'] is None
@pytest.mark.django_db
def test_user_project_paged_list_with_unicode(get, organization_factory):
'Test project listing that contains unicode chars in the next/prev links'
# Create 2 projects that contain a "cloud" unicode character, make sure we
# can search it and properly generate next/previous page links
objects = organization_factory(
'org1',
projects=['project-☁-1','project-☁-2'],
users=['alice'],
roles=['project-☁-1.admin_role:alice','project-☁-2.admin_role:alice'],
)
pk = objects.users.alice.pk
url = reverse('api:user_projects_list', kwargs={'pk':pk,})
# first on first page, next page link contains unicode char
results = get(url, objects.users.alice,
QUERY_STRING='page_size=1&search=%E2%98%81').data
assert results['count'] == 2
assert len(results['results']) == 1
assert results['next'] == (
'/api/v2/users/%s/projects/?page=2&page_size=1&search=%%E2%%98%%81' % pk # noqa
)
# second project on second page, previous page link contains unicode char
results = get(url, objects.users.alice,
QUERY_STRING='page=2&page_size=1&search=%E2%98%81').data
assert results['count'] == 2
assert len(results['results']) == 1
assert results['previous'] == (
'/api/v2/users/%s/projects/?page=1&page_size=1&search=%%E2%%98%%81' % pk # noqa
)
@pytest.mark.django_db
def test_user_project_list(get, organization_factory):
'List of projects a user has access to, filtered by projects you can also see'
objects = organization_factory('org1',
projects=['alice project', 'bob project', 'shared project'],
superusers=['admin'],
users=['alice', 'bob'],
roles=['alice project.admin_role:alice',
'bob project.admin_role:bob',
'shared project.admin_role:bob',
'shared project.admin_role:alice'])
assert get(reverse(
'api:user_projects_list',
kwargs={'pk':objects.superusers.admin.pk,}
), objects.superusers.admin).data['count'] == 3
# admins can see everyones projects
assert get(reverse('api:user_projects_list', kwargs={'pk':objects.users.alice.pk,}), objects.superusers.admin).data['count'] == 2
assert get(reverse('api:user_projects_list', kwargs={'pk':objects.users.bob.pk,}), objects.superusers.admin).data['count'] == 2
# users can see their own projects
assert get(reverse('api:user_projects_list', kwargs={'pk':objects.users.alice.pk,}), objects.users.alice).data['count'] == 2
# alice should only be able to see the shared project when looking at bobs projects
assert get(reverse('api:user_projects_list', kwargs={'pk':objects.users.bob.pk,}), objects.users.alice).data['count'] == 1
# alice should see all projects they can see when viewing an admin
assert get(reverse('api:user_projects_list', kwargs={'pk':objects.superusers.admin.pk,}), objects.users.alice).data['count'] == 2
@pytest.mark.django_db
def test_team_project_list(get, team_project_list):
objects = team_project_list
team1, team2 = objects.teams.team1, objects.teams.team2
alice, bob, admin = objects.users.alice, objects.users.bob, objects.superusers.admin
# admins can see all projects on a team
assert get(reverse('api:team_projects_list', kwargs={'pk':team1.pk,}), admin).data['count'] == 2
assert get(reverse('api:team_projects_list', kwargs={'pk':team2.pk,}), admin).data['count'] == 2
# users can see all projects on teams they are a member of
assert get(reverse('api:team_projects_list', kwargs={'pk':team1.pk,}), alice).data['count'] == 2
# but if she does, then she should only see the shared project
team2.read_role.members.add(alice)
assert get(reverse('api:team_projects_list', kwargs={'pk':team2.pk,}), alice).data['count'] == 1
team2.read_role.members.remove(alice)
# admins can see all projects
assert get(reverse('api:user_projects_list', kwargs={'pk':admin.pk,}), admin).data['count'] == 3
# admins can see everyones projects
assert get(reverse('api:user_projects_list', kwargs={'pk':alice.pk,}), admin).data['count'] == 2
assert get(reverse('api:user_projects_list', kwargs={'pk':bob.pk,}), admin).data['count'] == 2
# users can see their own projects
assert get(reverse('api:user_projects_list', kwargs={'pk':alice.pk,}), alice).data['count'] == 2
# alice should see all projects they can see when viewing an admin
assert get(reverse('api:user_projects_list', kwargs={'pk':admin.pk,}), alice).data['count'] == 2
@pytest.mark.parametrize("u,expected_status_code", [
('rando', 403),
('org_member', 403),
('org_admin', 201),
('admin', 201)
])
@pytest.mark.django_db()
def test_create_project(post, organization, org_admin, org_member, admin, rando, u, expected_status_code):
if u == 'rando':
u = rando
elif u == 'org_member':
u = org_member
elif u == 'org_admin':
u = org_admin
elif u == 'admin':
u = admin
result = post(reverse('api:project_list'), {
'name': 'Project',
'organization': organization.id,
}, u)
print(result.data)
assert result.status_code == expected_status_code
if expected_status_code == 201:
assert Project.objects.filter(name='Project', organization=organization).exists()
@pytest.mark.django_db
def test_project_credential_protection(post, put, project, organization, scm_credential, org_admin):
project.save()
project.admin_role.members.add(org_admin)
put(
reverse('api:project_detail', kwargs={'pk':project.id}), {
'name': 'should not change',
'credential': scm_credential.id
}, org_admin, expect=403
)
post(
reverse('api:project_list'), {
'name': 'should not create',
'organization':organization.id,
'credential': scm_credential.id
}, org_admin, expect=403
)
@pytest.mark.django_db
def test_cannot_schedule_manual_project(manual_project, admin_user, post):
response = post(
reverse('api:project_schedules_list', kwargs={'pk':manual_project.pk,}),
{
"name": "foo", "description": "", "enabled": True,
"rrule": "DTSTART:20160926T040000Z RRULE:FREQ=HOURLY;INTERVAL=1",
"extra_data": {}
}, admin_user, expect=400
)
assert 'Manual' in response.data['unified_job_template'][0]
@pytest.mark.django_db
def test_project_unique_together_with_org(organization):
proj1 = Project(name='foo', organization=organization)
proj1.save()
proj2 = Project(name='foo', organization=organization)
with pytest.raises(ValidationError):
proj2.validate_unique()
proj2 = Project(name='foo', organization=None)
proj2.validate_unique()
@pytest.mark.django_db
def test_project_delete(delete, organization, admin_user):
proj = Project(name='foo', organization=organization)
proj.save()
delete(reverse('api:project_detail', kwargs={'pk':proj.id,}), admin_user)
| 40.01581 | 133 | 0.635421 |
0608d15af81b1a523f136cc9294fc18dd37d4570 | 304 | py | Python | scripts/pylib/utils.py | powerpak/pathogendb-comparison | 8c62e0051bcd2e3850ba5833dfd6f38a75460555 | [
"MIT"
] | 7 | 2020-05-18T23:10:02.000Z | 2021-12-27T05:01:07.000Z | scripts/pylib/utils.py | powerpak/pathogendb-comparison | 8c62e0051bcd2e3850ba5833dfd6f38a75460555 | [
"MIT"
] | 5 | 2020-05-22T08:12:27.000Z | 2020-05-31T09:58:14.000Z | scripts/pylib/utils.py | powerpak/pathogendb-comparison | 8c62e0051bcd2e3850ba5833dfd6f38a75460555 | [
"MIT"
] | 1 | 2020-11-24T23:08:44.000Z | 2020-11-24T23:08:44.000Z | import re
def contig_to_vcf_chrom(contig_name):
"""
Annotations may reference more complex contig names than the VCF does in its CHROM column.
This function maps any given annotation's contig name to its corresponding VCF CHROM name.
"""
return re.sub(r'\W.+$', '', contig_name) | 33.777778 | 94 | 0.707237 |
6be78f960dc54756d60f2d489fa055d327353f02 | 355 | py | Python | recipes/how_to_add_a_picture_to_a_text_document.py | jdum/odfdo | 2494d0bed39f5a55974643206e9bafeed40f3a6b | [
"Apache-2.0"
] | 18 | 2018-04-19T08:30:48.000Z | 2022-02-14T11:00:27.000Z | recipes/how_to_add_a_picture_to_a_text_document.py | jdum/odfdo | 2494d0bed39f5a55974643206e9bafeed40f3a6b | [
"Apache-2.0"
] | 15 | 2018-04-22T00:52:41.000Z | 2021-07-05T10:16:38.000Z | recipes/how_to_add_a_picture_to_a_text_document.py | jdum/odfdo | 2494d0bed39f5a55974643206e9bafeed40f3a6b | [
"Apache-2.0"
] | 6 | 2018-04-22T00:14:12.000Z | 2021-12-06T01:42:07.000Z | from odfdo import Document, Paragraph, Frame
doc = Document("text")
body = doc.body
uri = doc.add_file("newlogo.png")
image_frame = Frame.image_frame(uri, size=("6cm", "4cm"), position=("5cm", "10cm"))
# put image frame in a paragraph:
para = Paragraph("")
para.append(image_frame)
body.append(para)
# doc.save(target='test_picture.odt', pretty=True)
| 23.666667 | 83 | 0.712676 |
66aad9430fb546dc899f661302afded821ab9767 | 506 | py | Python | setup.py | TakutoYoshikai/yakumo | fb0524a157be70024a40d48ce01e7b34594ff4d0 | [
"MIT"
] | null | null | null | setup.py | TakutoYoshikai/yakumo | fb0524a157be70024a40d48ce01e7b34594ff4d0 | [
"MIT"
] | 2 | 2021-12-09T02:54:33.000Z | 2021-12-09T07:09:36.000Z | setup.py | TakutoYoshikai/yakumo | fb0524a157be70024a40d48ce01e7b34594ff4d0 | [
"MIT"
] | null | null | null | from setuptools import setup, find_packages
setup(
name = 'yakumo',
version = '1.0.0',
url = 'https://github.com/TakutoYoshikai/yakumo.git',
license = 'MIT LICENSE',
author = 'Takuto Yoshikai',
author_email = 'takuto.yoshikai@gmail.com',
description = 'yakumo is a steganography tool.',
install_requires = ['setuptools', "pillow"],
packages = find_packages(),
entry_points={
"console_scripts": [
"yakumo = yakumo.yakumo:main",
]
}
)
| 26.631579 | 57 | 0.618577 |
1e55e756b1e0da5a15d4cd04094490a7a4afc9ad | 7,306 | py | Python | tests/utils/test_hook_utils.py | hatched-DavidMichon/airflow-metrics | 3b9c5cf2a07195d37686eaa0bbe824a3333961c3 | [
"Apache-2.0"
] | 16 | 2019-06-28T13:38:22.000Z | 2021-01-25T14:11:39.000Z | tests/utils/test_hook_utils.py | hatched-DavidMichon/airflow-metrics | 3b9c5cf2a07195d37686eaa0bbe824a3333961c3 | [
"Apache-2.0"
] | 9 | 2019-07-11T18:45:20.000Z | 2020-01-16T05:33:18.000Z | tests/utils/test_hook_utils.py | hatched-DavidMichon/airflow-metrics | 3b9c5cf2a07195d37686eaa0bbe824a3333961c3 | [
"Apache-2.0"
] | 8 | 2019-07-31T17:22:35.000Z | 2022-02-22T20:26:11.000Z | from unittest import TestCase
from pytest import raises
from airflow_metrics.utils.hook_utils import HookManager
from tests.utility import mockfn
class TestHookManager(TestCase):
def test_patch_method(self):
class TestClass():
def test_method(self):
pass
test_method_manager = HookManager(TestClass, 'test_method')
test_method_manager.wrap_method()
fake_method_manager = HookManager(TestClass, 'fake_method')
with raises(AttributeError):
fake_method_manager.wrap_method()
def test_swallows_errors(self):
class TestClass():
def test_method(self):
return True
def pre_hook(*args, **kwargs):
raise Exception()
def post_hook(*args, **kwargs):
raise Exception()
test_method_manager = HookManager(TestClass, 'test_method')
test_method_manager.register_pre_hook(pre_hook)
test_method_manager.register_post_hook(post_hook)
test_method_manager.wrap_method()
test_obj = TestClass()
assert test_obj.test_method()
def test_call_order(self):
call_order = []
class TestClass():
def test_method(self):
call_order.append('test method')
def pre_hook_1(*args, **kwargs):
call_order.append('pre-hook 1')
def pre_hook_2(*args, **kwargs):
call_order.append('pre-hook 2')
def post_hook_1(*args, **kwargs):
call_order.append('post-hook 1')
def post_hook_2(*args, **kwargs):
call_order.append('post-hook 2')
test_method_manager = HookManager(TestClass, 'test_method')
test_method_manager.register_pre_hook(pre_hook_1)
test_method_manager.register_pre_hook(pre_hook_2)
test_method_manager.register_post_hook(post_hook_1)
test_method_manager.register_post_hook(post_hook_2)
test_method_manager.wrap_method()
test_obj = TestClass()
assert not call_order
test_obj.test_method()
assert call_order == [
'pre-hook 1',
'pre-hook 2',
'test method',
'post-hook 1',
'post-hook 2'
]
def test_carries_context(self):
class TestClass():
def test_method(self):
pass
@mockfn
def pre_hook_1(ctx, *args, **kwargs):
ctx['pre-hook 1'] = True
@mockfn
def pre_hook_2(ctx, *args, **kwargs):
assert ctx['pre-hook 1']
ctx['pre-hook 2'] = True
@mockfn
def post_hook_1(ctx, *args, **kwargs):
assert ctx['pre-hook 1']
assert ctx['pre-hook 2']
ctx['post-hook 1'] = True
@mockfn
def post_hook_2(ctx, *args, **kwargs):
assert ctx['pre-hook 1']
assert ctx['pre-hook 2']
assert ctx['post-hook 1']
test_method_manager = HookManager(TestClass, 'test_method')
test_method_manager.register_pre_hook(pre_hook_1)
test_method_manager.register_pre_hook(pre_hook_2)
test_method_manager.register_post_hook(post_hook_1)
test_method_manager.register_post_hook(post_hook_2)
test_method_manager.wrap_method()
test_obj = TestClass()
assert not pre_hook_1.called
assert not pre_hook_2.called
assert not post_hook_1.called
assert not post_hook_2.called
test_obj.test_method()
assert pre_hook_1.called
assert pre_hook_2.called
assert post_hook_1.called
assert post_hook_2.called
def test_success_status_true(self):
class TestClass():
def test_method(self):
pass
@mockfn
def pre_hook(ctx, *args, **kwargs):
assert 'success' not in ctx
@mockfn
def post_hook(ctx, *args, **kwargs):
assert ctx['success']
test_method_manager = HookManager(TestClass, 'test_method')
test_method_manager.register_pre_hook(pre_hook)
test_method_manager.register_post_hook(post_hook)
test_method_manager.wrap_method()
test_obj = TestClass()
assert not pre_hook.called
assert not post_hook.called
test_obj.test_method()
assert pre_hook.called
assert post_hook.called
def test_success_status_false(self):
class TestClass():
def test_method(self):
raise Exception()
@mockfn
def pre_hook(ctx, *args, **kwargs):
assert not ctx['success']
@mockfn
def post_hook(ctx, *args, **kwargs):
assert not ctx['success']
test_method_manager = HookManager(TestClass, 'test_method')
test_method_manager.register_pre_hook(pre_hook)
test_method_manager.register_post_hook(post_hook)
test_method_manager.wrap_method()
test_obj = TestClass()
with raises(Exception):
test_obj.test_method()
def test_pass_on_return_value(self):
class TestClass():
def test_method(self):
return 'return value'
@mockfn
def post_hook(ctx, *args, **kwargs):
assert ctx['return'] == 'return value'
test_method_manager = HookManager(TestClass, 'test_method')
test_method_manager.register_post_hook(post_hook)
test_method_manager.wrap_method()
test_obj = TestClass()
assert not post_hook.called
test_obj.test_method()
assert post_hook.called
def test_modify_return_value(self):
class TestClass():
def test_method(self):
return 'return value'
def post_hook(ctx, *args, **kwargs):
ctx['return'] = 'modified value'
test_method_manager = HookManager(TestClass, 'test_method')
test_method_manager.register_post_hook(post_hook)
test_method_manager.wrap_method()
test_obj = TestClass()
assert test_obj.test_method() == 'modified value'
def test_success_only_true(self):
class TestClass():
def test_method(self):
pass
@mockfn
def post_hook_mock(*args, **kwargs):
pass
post_hook = HookManager.success_only(post_hook_mock)
test_method_manager = HookManager(TestClass, 'test_method')
test_method_manager.register_post_hook(post_hook)
test_method_manager.wrap_method()
test_obj = TestClass()
assert not post_hook_mock.called
test_obj.test_method()
assert post_hook_mock.called
def test_success_only_false(self):
class TestClass():
def test_method(self):
raise Exception()
@mockfn
def post_hook_mock(*args, **kwargs):
pass
post_hook = HookManager.success_only(post_hook_mock)
test_method_manager = HookManager(TestClass, 'test_method')
test_method_manager.register_post_hook(post_hook)
test_method_manager.wrap_method()
test_obj = TestClass()
assert not post_hook_mock.called
with raises(Exception):
test_obj.test_method()
assert not post_hook_mock.called
| 30.315353 | 67 | 0.620175 |
4cc0f28ec4b9d69061f2987caf6475f24743e13d | 333 | py | Python | park_management/park_management/report/vat_on_purchase_per_gcc/vat_on_purchase_per_gcc.py | iRaySpace/park_management | e4b95043fd2410c057f6353e5e8a65f51550033c | [
"MIT"
] | null | null | null | park_management/park_management/report/vat_on_purchase_per_gcc/vat_on_purchase_per_gcc.py | iRaySpace/park_management | e4b95043fd2410c057f6353e5e8a65f51550033c | [
"MIT"
] | null | null | null | park_management/park_management/report/vat_on_purchase_per_gcc/vat_on_purchase_per_gcc.py | iRaySpace/park_management | e4b95043fd2410c057f6353e5e8a65f51550033c | [
"MIT"
] | null | null | null | # Copyright (c) 2013, 9t9it and contributors
# For license information, please see license.txt
from __future__ import unicode_literals
from park_management.park_management.report.vat_on_sales_per_gcc.vat_on_sales_per_gcc import (
make_report,
)
def execute(filters=None):
return make_report("Purchase Invoice", filters)
| 25.615385 | 94 | 0.801802 |
dad798cea97b9e30e8e863a078e0327e67521ae1 | 2,339 | py | Python | box/box.py | bramfoo/legosorted | a374546cde91db58e30f51e17124d8d717df9c56 | [
"MIT"
] | null | null | null | box/box.py | bramfoo/legosorted | a374546cde91db58e30f51e17124d8d717df9c56 | [
"MIT"
] | null | null | null | box/box.py | bramfoo/legosorted | a374546cde91db58e30f51e17124d8d717df9c56 | [
"MIT"
] | null | null | null | from legoPlatform.direction import Direction
from sort import Sort
class Box:
garbage_direction = Direction.up
def __init__(self):
self.color = None
self.shape = None
self.sort = None
self.dimension = None
self.slots = []
self.reset()
def reset(self):
self.set_preferences(None, None, None, Sort.color)
self.slots = [
Slot(Direction.left),
Slot(Direction.down),
Slot(Direction.right),
Slot(Box.garbage_direction)
]
def offer(self, lego_block):
for slot in self.slots:
if slot.try_place_block(lego_block, self.color, self.shape, self.dimension, self.sort):
return slot.direction
# We couldn't find a slot for the block, put it in the last slot
return self.slots[-1].direction
def set_preferences(self, color, shape, dimension, sort):
self.color = color
self.shape = shape
self.dimension = dimension
self.sort = sort
class Slot:
def __init__(self, direction):
self.direction = direction
self.blocks = []
def try_place_block(self, new_lego_block, color, shape, dimension, sort):
can_place_block = True
is_empty = len(self.blocks) == 0
current_lego_block = None if is_empty else self.blocks[0]
# Sort on 1 specific dimension
if dimension is not None:
can_place_block = can_place_block and new_lego_block.has_dimension(dimension)
# Sort on 1 specific color
if color is not None:
can_place_block = can_place_block and new_lego_block.color == color
# Sort on 1 specific shape
if shape is not None:
can_place_block = can_place_block and new_lego_block.shape == shape
# Sort on (any) color or (any) shape
if sort is not None:
# Sort on color or shape
if sort == Sort.color:
can_place_block = can_place_block and (is_empty or new_lego_block.color == current_lego_block.color)
else:
can_place_block = can_place_block and (is_empty or new_lego_block.shape == current_lego_block.shape)
if can_place_block:
self.blocks.append(new_lego_block)
return can_place_block
| 29.987179 | 116 | 0.620778 |
110bc429d84b3fd702d824577ac8f0b8be576ade | 2,202 | py | Python | Incident-Response/Tools/dfirtrack/dfirtrack_main/tests/company/test_company_models.py | sn0b4ll/Incident-Playbook | cf519f58fcd4255674662b3620ea97c1091c1efb | [
"MIT"
] | 1 | 2021-07-24T17:22:50.000Z | 2021-07-24T17:22:50.000Z | Incident-Response/Tools/dfirtrack/dfirtrack_main/tests/company/test_company_models.py | sn0b4ll/Incident-Playbook | cf519f58fcd4255674662b3620ea97c1091c1efb | [
"MIT"
] | 2 | 2022-02-28T03:40:31.000Z | 2022-02-28T03:40:52.000Z | Incident-Response/Tools/dfirtrack/dfirtrack_main/tests/company/test_company_models.py | sn0b4ll/Incident-Playbook | cf519f58fcd4255674662b3620ea97c1091c1efb | [
"MIT"
] | 2 | 2022-02-25T08:34:51.000Z | 2022-03-16T17:29:44.000Z | from django.test import TestCase
from dfirtrack_main.models import Company
class CompanyModelTestCase(TestCase):
""" company model tests """
@classmethod
def setUpTestData(cls):
# create object
Company.objects.create(company_name='company_1')
def test_company_string(self):
""" test string representation """
# get object
company_1 = Company.objects.get(company_name='company_1')
# compare
self.assertEqual(str(company_1), 'company_1')
def test_company_id_attribute_label(self):
""" test attribute label """
# get object
company_1 = Company.objects.get(company_name='company_1')
# get label
field_label = company_1._meta.get_field('company_id').verbose_name
# compare
self.assertEqual(field_label, 'company id')
def test_company_division_attribute_label(self):
""" test attribute label """
# get object
company_1 = Company.objects.get(company_name='company_1')
# get label
field_label = company_1._meta.get_field('division').verbose_name
# compare
self.assertEqual(field_label, 'division')
def test_company_name_attribute_label(self):
""" test attribute label """
# get object
company_1 = Company.objects.get(company_name='company_1')
# get label
field_label = company_1._meta.get_field('company_name').verbose_name
# compare
self.assertEqual(field_label, 'company name')
def test_company_note_attribute_label(self):
""" test attribute label """
# get object
company_1 = Company.objects.get(company_name='company_1')
# get label
field_label = company_1._meta.get_field('company_note').verbose_name
# compare
self.assertEqual(field_label, 'company note')
def test_company_name_length(self):
""" test for max length """
# get object
company_1 = Company.objects.get(company_name='company_1')
# get max length
max_length = company_1._meta.get_field('company_name').max_length
# compare
self.assertEqual(max_length, 50)
| 31.457143 | 76 | 0.653043 |
fbb0d0a73a4931806e815538248feff6fb59fe50 | 1,424 | py | Python | datastore/app.py | VISHNUVARDHAN05/key-value-pair | 4e12945f5bc393ae0594e362727034b9713c5787 | [
"Apache-2.0"
] | null | null | null | datastore/app.py | VISHNUVARDHAN05/key-value-pair | 4e12945f5bc393ae0594e362727034b9713c5787 | [
"Apache-2.0"
] | null | null | null | datastore/app.py | VISHNUVARDHAN05/key-value-pair | 4e12945f5bc393ae0594e362727034b9713c5787 | [
"Apache-2.0"
] | null | null | null | __author__ = 'vishnu'
from sys import exit
from flask import Flask
from argparse import ArgumentParser
from configs import settings, configurations
from utils.filehandler import FilePreprocess
from CRD.views import CreateData, ReadData, DeleteData
# Adding/Enabling CommandLineArguments: --datastore
parser = ArgumentParser()
parser.add_argument('--datastore', help='Enter the datastore absolute path.')
args = parser.parse_args()
# Selecting the DataStore Directory.
# Select user provided datastore path else, select the default path.
if args.datastore:
db_path = args.datastore
else:
db_path = configurations.DEFAULT_DB_PATH
# Create a datastore directory.
directory_created = FilePreprocess(db_path).create_folder()
if not directory_created:
print(f"Permission denied: You can not create the directory `{db_path}`.\n")
exit(0)
app = Flask(__name__)
# Flask App Configurations
app.config['DEBUG'] = settings.DEBUG
app.config['SECRET_KEY'] = settings.SECRET_KEY
# API Endpoints
app.add_url_rule('/datastore/create', view_func=CreateData.as_view('create', db_path), methods=['POST'])
app.add_url_rule('/datastore/read', view_func=ReadData.as_view('read', db_path), methods=['GET'])
app.add_url_rule('/datastore/delete', view_func=DeleteData.as_view('delete', db_path), methods=['DELETE'])
# Initiates Flask Server
if __name__ == '__main__':
app.run(host=settings.HOST, port=settings.PORT)
| 29.666667 | 106 | 0.771067 |
5c8e18cf9a14a42f6c2f8fc82fb41fa5165243c4 | 9,866 | py | Python | test/functional/mining_pos_reorg.py | CryptoDev-Project/peony-1 | 199a879c9c2bdccc2a202366b604fe30aaca552b | [
"MIT"
] | null | null | null | test/functional/mining_pos_reorg.py | CryptoDev-Project/peony-1 | 199a879c9c2bdccc2a202366b604fe30aaca552b | [
"MIT"
] | null | null | null | test/functional/mining_pos_reorg.py | CryptoDev-Project/peony-1 | 199a879c9c2bdccc2a202366b604fe30aaca552b | [
"MIT"
] | null | null | null | #!/usr/bin/env python3
# Copyright (c) 2019 The PIVX developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
from test_framework.authproxy import JSONRPCException
from test_framework.test_framework import PnyTestFramework
from test_framework.util import (
sync_blocks,
assert_equal,
assert_raises_rpc_error,
connect_nodes_bi,
connect_nodes_clique,
disconnect_nodes,
set_node_times,
DecimalAmt,
)
class ReorgStakeTest(PnyTestFramework):
def set_test_params(self):
self.num_nodes = 3
# node 0 and 1 stake the blocks, node 2 makes the zerocoin spends
self.extra_args = [['-staking=0']] * self.num_nodes
def setup_chain(self):
# Start with PoS cache: 330 blocks
self._initialize_chain(toPosPhase=True)
self.enable_mocktime()
def setup_network(self):
# connect all nodes between each other
self.setup_nodes()
connect_nodes_clique(self.nodes)
self.sync_all()
def log_title(self):
title = "*** Starting %s ***" % self.__class__.__name__
underline = "-" * len(title)
description = "Tests reorganisation for PoS blocks."
self.log.info("\n\n%s\n%s\n%s\n", title, underline, description)
def disconnect_all(self):
self.log.info("Disconnecting nodes...")
for i in range(self.num_nodes):
for j in range(self.num_nodes):
if j != i:
disconnect_nodes(self.nodes[i], j)
self.log.info("Nodes disconnected")
def get_tot_balance(self, nodeid):
wi = self.nodes[nodeid].getwalletinfo()
return wi['balance'] + wi['immature_balance']
def run_test(self):
def findUtxoInList(txid, vout, utxo_list):
for x in utxo_list:
if x["txid"] == txid and x["vout"] == vout:
return True, x
return False, None
# Stake with node 0 and node 1 up to public spend activation (400)
# 70 blocks: 5 blocks each (x7)
self.log.info("Staking 70 blocks to reach public spends activation...")
set_node_times(self.nodes, self.mocktime)
for i in range(7):
for peer in range(2):
for nblock in range(5):
self.mocktime = self.generate_pos(peer, self.mocktime)
sync_blocks(self.nodes)
set_node_times(self.nodes, self.mocktime)
block_time_0 = block_time_1 = self.mocktime
self.log.info("Blocks staked.")
# Check balances
self.log.info("Checking balances...")
initial_balance = [self.get_tot_balance(i) for i in range(self.num_nodes)]
# --nodes 0, 1: 62 pow blocks + 55 pos blocks
assert_equal(initial_balance[0], DecimalAmt(250.0 * (62 + 55)))
assert_equal(initial_balance[1], DecimalAmt(250.0 * (62 + 55)))
# --node 2: 62 pow blocks + 20 pos blocks - zc minted - zcfee
assert_equal(initial_balance[2], DecimalAmt(250.0 * (62 + 20) - 6666 - 0.08))
assert_equal(self.nodes[2].getzerocoinbalance()['Total'], DecimalAmt(6666))
self.log.info("Balances ok.")
# create the raw zerocoin spend txes
addy = self.nodes[2].getnewaddress()
self.log.info("Creating the raw zerocoin public spends...")
mints = self.nodes[2].listmintedzerocoins(True, True)
tx_A0 = self.nodes[2].createrawzerocoinspend(mints[0]["serial hash"], addy)
tx_A1 = self.nodes[2].createrawzerocoinspend(mints[1]["serial hash"], addy)
# Spending same coins to different recipients to get different txids
new_addy = "yAVWM5urwaTyhiuFQHP2aP47rdZsLUG5PH"
tx_B0 = self.nodes[2].createrawzerocoinspend(mints[0]["serial hash"], new_addy)
tx_B1 = self.nodes[2].createrawzerocoinspend(mints[1]["serial hash"], new_addy)
# Disconnect nodes
minted_amount = mints[0]["denomination"] + mints[1]["denomination"]
self.disconnect_all()
# Stake one block with node-0 and save the stake input
self.log.info("Staking 1 block with node 0...")
initial_unspent_0 = self.nodes[0].listunspent()
self.nodes[0].generate(1)
block_time_0 += 60
set_node_times(self.nodes, block_time_0)
last_block = self.nodes[0].getblock(self.nodes[0].getbestblockhash())
assert(len(last_block["tx"]) > 1) # a PoS block has at least two txes
coinstake_txid = last_block["tx"][1]
coinstake_tx = self.nodes[0].getrawtransaction(coinstake_txid, True)
assert(coinstake_tx["vout"][0]["scriptPubKey"]["hex"] == "") # first output of coinstake is empty
stakeinput = coinstake_tx["vin"][0]
# The stake input was unspent 1 block ago, now it's not
res, utxo = findUtxoInList(stakeinput["txid"], stakeinput["vout"], initial_unspent_0)
assert (res and utxo["spendable"])
res, utxo = findUtxoInList(stakeinput["txid"], stakeinput["vout"], self.nodes[0].listunspent())
assert (not res or not utxo["spendable"])
self.log.info("Coinstake input %s...%s-%d is no longer spendable." % (
stakeinput["txid"][:9], stakeinput["txid"][-4:], stakeinput["vout"]))
# Relay zerocoin spends
self.nodes[0].sendrawtransaction(tx_A0)
self.nodes[0].sendrawtransaction(tx_A1)
# Stake 10 more blocks with node-0 and check balances
self.log.info("Staking 10 more blocks with node 0...")
for i in range(10):
block_time_0 = self.generate_pos(0, block_time_0)
expected_balance_0 = initial_balance[0] + DecimalAmt(11 * 250.0)
assert_equal(self.get_tot_balance(0), expected_balance_0)
self.log.info("Balance for node 0 checks out.")
# Connect with node 2, sync and check zerocoin balance
self.log.info("Reconnecting node 0 and node 2")
connect_nodes_bi(self.nodes, 0, 2)
sync_blocks([self.nodes[i] for i in [0, 2]])
self.log.info("Resetting zerocoin mints on node 2")
self.nodes[2].resetmintzerocoin(True)
assert_equal(self.get_tot_balance(2), initial_balance[2] + DecimalAmt(minted_amount))
assert_equal(self.nodes[2].getzerocoinbalance()['Total'], DecimalAmt(6666-minted_amount))
self.log.info("Balance for node 2 checks out.")
# Double spending txes not possible
assert_raises_rpc_error(-26, "bad-txns-invalid-zpny",
self.nodes[0].sendrawtransaction, tx_B0)
assert_raises_rpc_error(-26, "bad-txns-invalid-zpny",
self.nodes[0].sendrawtransaction, tx_B1)
# verify that the stakeinput can't be spent
stakeinput_tx_json = self.nodes[0].getrawtransaction(stakeinput["txid"], True)
stakeinput_amount = float(stakeinput_tx_json["vout"][int(stakeinput["vout"])]["value"])
rawtx_unsigned = self.nodes[0].createrawtransaction(
[{"txid": stakeinput["txid"], "vout": int(stakeinput["vout"])}],
{"xxncEuJK27ygNh7imNfaX8JV6ZQUnoBqzN": (stakeinput_amount-0.01)})
rawtx = self.nodes[0].signrawtransaction(rawtx_unsigned)
assert(rawtx["complete"])
try:
self.nodes[0].sendrawtransaction(rawtx["hex"])
except JSONRPCException as e:
# JSONRPCException was thrown as expected. Check the code and message values are correct.
if e.error["code"] not in [-26, -25]:
raise AssertionError("Unexpected JSONRPC error code %i" % e.error["code"])
if ([x for x in ["bad-txns-inputs-spent", "Missing inputs"] if x in e.error['message']] == []):
raise e
except Exception as e:
raise AssertionError("Unexpected exception raised: " + type(e).__name__)
self.log.info("GOOD: v2 spend was not possible.")
# Spend tx_B0 and tx_B1 on the other chain
self.nodes[1].sendrawtransaction(tx_B0)
self.nodes[1].sendrawtransaction(tx_B1)
# Stake 12 blocks with node-1
set_node_times(self.nodes, block_time_1)
self.log.info("Staking 12 blocks with node 1...")
for i in range(12):
block_time_1 = self.generate_pos(1, block_time_1)
expected_balance_1 = initial_balance[1] + DecimalAmt(12 * 250.0)
assert_equal(self.get_tot_balance(1), expected_balance_1)
self.log.info("Balance for node 1 checks out.")
# re-connect and sync nodes and check that node-0 and node-2 get on the other chain
new_best_hash = self.nodes[1].getbestblockhash()
self.log.info("Connecting and syncing nodes...")
set_node_times(self.nodes, block_time_1)
connect_nodes_clique(self.nodes)
sync_blocks(self.nodes)
for i in [0, 2]:
assert_equal(self.nodes[i].getbestblockhash(), new_best_hash)
# check balance of node-0
assert_equal(self.get_tot_balance(0), initial_balance[0])
self.log.info("Balance for node 0 checks out.")
# check that NOW the original stakeinput is present and spendable
res, utxo = findUtxoInList(stakeinput["txid"], stakeinput["vout"], self.nodes[0].listunspent())
assert (res and utxo["spendable"])
self.log.info("Coinstake input %s...%s-%d is spendable again." % (
stakeinput["txid"][:9], stakeinput["txid"][-4:], stakeinput["vout"]))
self.nodes[0].sendrawtransaction(rawtx["hex"])
self.nodes[1].generate(1)
sync_blocks(self.nodes)
res, utxo = findUtxoInList(stakeinput["txid"], stakeinput["vout"], self.nodes[0].listunspent())
assert (not res or not utxo["spendable"])
if __name__ == '__main__':
ReorgStakeTest().main() | 46.758294 | 116 | 0.635617 |
965866c2b8a771a47c7b2ab916d0a8d7fc924060 | 3,306 | py | Python | src/sentry/api/endpoints/system_options.py | hieast/sentry | 1179b6b13e86f552d18da0578d7b3bc5d002c0d9 | [
"BSD-3-Clause"
] | 1 | 2019-05-28T06:18:03.000Z | 2019-05-28T06:18:03.000Z | src/sentry/api/endpoints/system_options.py | c88888/sentry | 53837d9e8dad2443c3881fcd05f1b261bdd922fd | [
"BSD-3-Clause"
] | 6 | 2018-10-19T10:04:23.000Z | 2019-12-09T20:29:12.000Z | src/sentry/api/endpoints/system_options.py | zaasmi/codeerrorhelp | 1ab8d3e314386b9b2d58dad9df45355bf6014ac9 | [
"BSD-3-Clause"
] | 2 | 2021-01-26T09:53:39.000Z | 2022-03-22T09:01:47.000Z | from __future__ import absolute_import
import six
import sentry
from django.conf import settings
from rest_framework.response import Response
from sentry import options
from sentry.api.base import Endpoint
from sentry.api.permissions import SuperuserPermission
from sentry.utils.email import is_smtp_enabled
class SystemOptionsEndpoint(Endpoint):
permission_classes = (SuperuserPermission, )
def get(self, request):
query = request.GET.get('query')
if query == 'is:required':
option_list = options.filter(flag=options.FLAG_REQUIRED)
elif query:
return Response('{} is not a supported search query'.format(query), status=400)
else:
option_list = options.all()
smtp_disabled = not is_smtp_enabled()
results = {}
for k in option_list:
disabled, disabled_reason = False, None
if smtp_disabled and k.name[:5] == 'mail.':
disabled_reason, disabled = 'smtpDisabled', True
elif bool(
k.flags & options.FLAG_PRIORITIZE_DISK and settings.SENTRY_OPTIONS.get(k.name)
):
# TODO(mattrobenolt): Expose this as a property on Key.
disabled_reason, disabled = 'diskPriority', True
# TODO(mattrobenolt): help, placeholder, title, type
results[k.name] = {
'value': options.get(k.name),
'field': {
'default': k.default(),
'required': bool(k.flags & options.FLAG_REQUIRED),
'disabled': disabled,
'disabledReason': disabled_reason,
'isSet': options.isset(k.name),
'allowEmpty': bool(k.flags & options.FLAG_ALLOW_EMPTY),
}
}
return Response(results)
def put(self, request):
# TODO(dcramer): this should validate options before saving them
for k, v in six.iteritems(request.DATA):
if v and isinstance(v, six.string_types):
v = v.strip()
try:
option = options.lookup_key(k)
except options.UnknownOption:
# TODO(dcramer): unify API errors
return Response(
{
'error': 'unknown_option',
'errorDetail': {
'option': k,
},
}, status=400
)
try:
if not (option.flags & options.FLAG_ALLOW_EMPTY) and not v:
options.delete(k)
else:
options.set(k, v)
except TypeError as e:
return Response(
{
'error': 'invalid_type',
'errorDetail': {
'option': k,
'message': six.text_type(e),
},
},
status=400
)
# TODO(dcramer): this has nothing to do with configuring options and
# should not be set here
options.set('sentry:version-configured', sentry.get_version())
return Response(status=200)
| 34.8 | 94 | 0.515426 |
187ef270edc9fd5f48d4d9b3af5244fa069f67ec | 1,419 | py | Python | examples/models/file/basic_plot.py | g-parki/bokeh | 664ead5306bba64609e734d4105c8aa8cfb76d81 | [
"BSD-3-Clause"
] | 1 | 2020-05-26T15:21:22.000Z | 2020-05-26T15:21:22.000Z | examples/models/file/basic_plot.py | g-parki/bokeh | 664ead5306bba64609e734d4105c8aa8cfb76d81 | [
"BSD-3-Clause"
] | 1 | 2021-12-15T17:32:31.000Z | 2021-12-21T18:11:05.000Z | examples/models/file/basic_plot.py | g-parki/bokeh | 664ead5306bba64609e734d4105c8aa8cfb76d81 | [
"BSD-3-Clause"
] | 1 | 2021-12-20T05:50:00.000Z | 2021-12-20T05:50:00.000Z | ''' A scatter plot of a smooth periodic oscillation. This example demonstrates red
circle scatter markers with black outlines, using the low-level ``bokeh.models``
API.
.. bokeh-example-metadata::
:sampledata: sine wave
:apis: bokeh.models.Circle, bokeh.models.Plot, bokeh.models.ColumnDataSource, bokeh.models.LinearAxis, bokeh.models.PanTool, bokeh.models.WheelZoomTool
:refs: :ref:`userguide_plotting` > :ref:`userguide_plotting_scatter_markers`
:keywords: circle, figure, scatter
'''
from numpy import arange, pi, sin
from bokeh.document import Document
from bokeh.embed import file_html
from bokeh.models import (Circle, ColumnDataSource, LinearAxis,
PanTool, Plot, WheelZoomTool)
from bokeh.resources import INLINE
from bokeh.util.browser import view
x = arange(-2*pi, 2*pi, 0.1)
y = sin(x)
source = ColumnDataSource(
data=dict(x=x, y=y)
)
plot = Plot(min_border=80)
circle = Circle(x="x", y="y", fill_color="red", size=5, line_color="black")
plot.add_glyph(source, circle)
plot.add_layout(LinearAxis(), 'below')
plot.add_layout(LinearAxis(), 'left')
plot.add_tools(PanTool(), WheelZoomTool())
doc = Document()
doc.add_root(plot)
if __name__ == "__main__":
doc.validate()
filename = "basic_plot.html"
with open(filename, "w") as f:
f.write(file_html(doc, INLINE, "Basic Glyph Plot"))
print("Wrote %s" % filename)
view(filename)
| 29.5625 | 155 | 0.713883 |
d72f522c3b4a13e4085858ff78c2ebfbdd8b68c5 | 1,468 | py | Python | app/tests/integration/test_manufacturers/test_manufacturers_json.py | pedrolp85/pydevice | 39b961bb67f59ac9a9373ecc99748e07505b249e | [
"Apache-2.0"
] | null | null | null | app/tests/integration/test_manufacturers/test_manufacturers_json.py | pedrolp85/pydevice | 39b961bb67f59ac9a9373ecc99748e07505b249e | [
"Apache-2.0"
] | null | null | null | app/tests/integration/test_manufacturers/test_manufacturers_json.py | pedrolp85/pydevice | 39b961bb67f59ac9a9373ecc99748e07505b249e | [
"Apache-2.0"
] | null | null | null | import os
from model.manufacturer import Manufacturer
from unittest import mock
from fastapi.testclient import TestClient
from main import app
from settings import Settings, get_settings
from unittest import mock
import pytest
client = TestClient(app)
@pytest.fixture
def mock_env_manufacturers_json() -> None:
with mock.patch.dict(os.environ, {"MANUFACTURERS_SOURCE": "JSON", "MANUFACTURERS_FILE_SOURCE": "tests/test_files/manufacturers"}):
yield
def test_get_manufacturers_json(mock_env_manufacturers_json):
response = client.get("/manufacturer")
assert response.status_code == 200
assert len(response.json()) > 1
assert response.json()[0]['name'] == "paloalto_json"
def test_get_manufacturer_json(mock_env_manufacturers_json):
response = client.get("/manufacturer/2")
assert response.status_code == 200
assert response.json()['name'] == "cisco_json"
def test_create_manufacturer_json_successful(mock_env_manufacturers_json):
manufacturers_raw = client.get("/manufacturer")
manufacturers = [ Manufacturer(**p) for p in manufacturers_raw.json() ]
last_number = (manufacturers[-1]).id
response = client.post("/manufacturer",
json={
"id": last_number+1 ,
"name": "test_manufacturer_"+str(last_number+1),
"full_name": "ACME TEST MANUFACTURER"
},
)
assert response.status_code == 200
assert response.json()['name'] == "test_manufacturer_"+str(last_number+1) | 34.139535 | 134 | 0.730245 |
1cb236a89adfa2991f72a72bd7d70b3741953bcc | 2,453 | py | Python | setup.py | codehelp/pyOCD | 97261499d059186ad19fb822578cda1c7def4135 | [
"Apache-2.0"
] | null | null | null | setup.py | codehelp/pyOCD | 97261499d059186ad19fb822578cda1c7def4135 | [
"Apache-2.0"
] | null | null | null | setup.py | codehelp/pyOCD | 97261499d059186ad19fb822578cda1c7def4135 | [
"Apache-2.0"
] | null | null | null | """
mbed CMSIS-DAP debugger
Copyright (c) 2012-2015 ARM Limited
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
from setuptools import setup, find_packages
import sys
# Common dependencies.
install_requires = [
'intelhex',
'six',
'enum34',
'future',
'websocket-client',
'intervaltree',
'colorama',
'pyelftools',
'pyusb>=1.0.0b2',
]
# Add OS-specific dependencies.
os_install_requires = {
'linux' : [
],
'win32' : [
'pywinusb>=0.4.0',
],
'darwin' : [
'hidapi',
],
}
install_requires.extend(os_install_requires.get(sys.platform, []))
setup(
name="pyOCD",
use_scm_version={
'local_scheme': 'dirty-tag',
'write_to': 'pyOCD/_version.py'
},
setup_requires=['setuptools_scm!=1.5.3,!=1.5.4', 'setuptools_scm_git_archive'],
description="CMSIS-DAP debugger for Python",
long_description=open('README.rst', 'r').read(),
author="Chris Reed, Martin Kojtal, Russ Butler",
author_email="chris.reed@arm.com, martin.kojtal@arm.com, russ.butler@arm.com",
url='https://github.com/mbedmicro/pyOCD',
license="Apache 2.0",
install_requires=install_requires,
classifiers=[
"Development Status :: 4 - Beta",
"License :: OSI Approved :: Apache Software License",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.6",
],
extras_require={
'dissassembler': ['capstone']
},
entry_points={
'console_scripts': [
'pyocd-gdbserver = pyOCD.tools.gdb_server:main',
'pyocd-flashtool = pyOCD.tools.flash_tool:main',
'pyocd-tool = pyOCD.tools.pyocd:main',
],
},
packages=find_packages(),
include_package_data=True, # include files from MANIFEST.in
)
| 29.554217 | 83 | 0.641256 |
cd7fef8eaeffafc39db005674ae3e75d1067e2e3 | 612 | py | Python | gidibooks/users/services.py | luckyadogun/gidibooks | f06d3116eb0e954e515eeb8b82956a67c4b91861 | [
"MIT"
] | 1 | 2021-04-09T08:58:38.000Z | 2021-04-09T08:58:38.000Z | gidibooks/users/services.py | luckyadogun/gidibooks | f06d3116eb0e954e515eeb8b82956a67c4b91861 | [
"MIT"
] | null | null | null | gidibooks/users/services.py | luckyadogun/gidibooks | f06d3116eb0e954e515eeb8b82956a67c4b91861 | [
"MIT"
] | null | null | null | from typing import Dict
from django.core.exceptions import ValidationError
from users.models import User
from users.utils import user_to_dict
def create_account(data: Dict):
"""
Creates a user object using the dict argument
"""
try:
user = User(
first_name=data["first_name"],
last_name=data["last_name"],
email=data["email"],
)
user.set_password(data["password"])
user.full_clean()
except ValidationError as e:
return {"error": e.message_dict}
else:
user.save()
return user_to_dict(user)
| 21.103448 | 50 | 0.620915 |
84ec5c5ac8b2cd4aba6928fe7f07ae5aa1dd323f | 34 | py | Python | test.py | hubbacrack/csws-week1 | 6bfa05196c22a2283eb3217a5d10df6d63a4af48 | [
"Apache-2.0"
] | null | null | null | test.py | hubbacrack/csws-week1 | 6bfa05196c22a2283eb3217a5d10df6d63a4af48 | [
"Apache-2.0"
] | null | null | null | test.py | hubbacrack/csws-week1 | 6bfa05196c22a2283eb3217a5d10df6d63a4af48 | [
"Apache-2.0"
] | null | null | null | x = "your"
y = "mom"
print(x + y) | 8.5 | 12 | 0.470588 |
eb36bad8a4dd7390ce46edf3189b846ac841373b | 384 | py | Python | Qualification_Round_2/Editorials/pin_problem_tester.py | manojpandey/CodeSprint_India_2014 | 91ecfc9f565f20ae7517f556a0c414990a84e0d8 | [
"MIT"
] | null | null | null | Qualification_Round_2/Editorials/pin_problem_tester.py | manojpandey/CodeSprint_India_2014 | 91ecfc9f565f20ae7517f556a0c414990a84e0d8 | [
"MIT"
] | null | null | null | Qualification_Round_2/Editorials/pin_problem_tester.py | manojpandey/CodeSprint_India_2014 | 91ecfc9f565f20ae7517f556a0c414990a84e0d8 | [
"MIT"
] | 2 | 2015-07-25T11:44:07.000Z | 2019-07-14T11:33:48.000Z | from fractions import gcd
t = input()
assert 1 <= t <= 100000
for _ in xrange(t):
n, m = map(int, raw_input().strip().split(' '))
assert 1 <= n <= 10000
assert 1 <= m <= 10
a = map(int, raw_input().strip().split(' '))
for __ in a:
assert 1 <= __ <= 10
lcm = a[0]
for i in range(1, m):
lcm = (a[i] * lcm) / gcd(a[i], lcm)
print n / lcm | 24 | 51 | 0.502604 |
c9ec315f2aec80fc6e2406ef5c01ec617e40d55a | 1,222 | py | Python | aws_openapi_lint/rules/rule_validator.py | clee/aws-openapi-lint | d1b40e1d760a862d6ed391442376fce50aff48f4 | [
"MIT"
] | 9 | 2019-11-27T20:46:22.000Z | 2022-03-20T15:57:38.000Z | aws_openapi_lint/rules/rule_validator.py | clee/aws-openapi-lint | d1b40e1d760a862d6ed391442376fce50aff48f4 | [
"MIT"
] | 1 | 2021-03-25T23:12:37.000Z | 2021-03-25T23:12:37.000Z | aws_openapi_lint/rules/rule_validator.py | clee/aws-openapi-lint | d1b40e1d760a862d6ed391442376fce50aff48f4 | [
"MIT"
] | 1 | 2021-07-09T20:07:32.000Z | 2021-07-09T20:07:32.000Z | import yaml
import json
class RuleViolation:
def __init__(self, identifier, message='', path=None):
self.path = path
self.identifier = identifier
self.message = message
def __eq__(self, other):
return self.identifier == other.identifier
class InvalidFormatException(Exception):
pass
class RuleValidator:
def __init__(self, file_path):
self.file_path = file_path
self.rules = []
def validate(self):
violations = []
ext = self.file_path.split('.')[::-1][0]
if ext not in ['yml', 'yaml', 'json']:
raise InvalidFormatException()
with open(self.file_path) as file:
spec = self.load_spec_file(file, ext)
for rule in self.rules:
rule_violations = rule.validate(spec)
for rule_violation in rule_violations:
violations.append(rule_violation)
return violations
def add_rule(self, rule):
self.rules.append(rule)
def load_spec_file(self, file, ext):
if ext in ['yml', 'yaml']:
return yaml.load(file, Loader=yaml.FullLoader)
elif ext == 'json':
return json.load(file)
| 24.44 | 58 | 0.594108 |
3f311456a0f46640e0418caf8be3a0c484219535 | 9,279 | py | Python | src/Python/pandasDynamo/pandamo/api/information/summary.py | SHKnudsen/Pandamo | ee99abf406d0609e766702aae98309a0936dae6e | [
"MIT"
] | 19 | 2019-11-10T21:17:44.000Z | 2021-01-29T00:02:57.000Z | release packages/DynamoPandas/extra/pandasDynamo/pandamo/api/information/summary.py | SHKnudsen/Pandamo | ee99abf406d0609e766702aae98309a0936dae6e | [
"MIT"
] | 1 | 2019-11-14T08:21:46.000Z | 2020-02-18T12:59:42.000Z | src/Python/pandasDynamo/pandamo/api/information/summary.py | SHKnudsen/Pandamo | ee99abf406d0609e766702aae98309a0936dae6e | [
"MIT"
] | 3 | 2019-12-24T20:36:04.000Z | 2020-03-16T16:27:17.000Z | import sys
import json
from ast import literal_eval
import pandas as pd
import re
from flask import Blueprint
from flask import current_app as app
from flask import request
from utillities.exceptions import ExceptionHelpers
mod = Blueprint('summary', __name__)
null = None
# Sum of values
@mod.route('sum/', methods=["POST"])
def sum():
try:
request_dict = request.get_json()
jsonstr = request_dict['jsonStr']
axis = request_dict['axis']
df = pd.read_json(json.dumps(eval(jsonstr)), orient='split')
dataframe_sum = df.sum(axis = axis, skipna = True)
values = dataframe_sum.values.tolist()
keys = dataframe_sum.index.values.tolist()
sum_dict = dict(zip(keys, values))
response = app.response_class(
response=json.dumps(sum_dict),
status=200,
mimetype='application/json'
)
except:
exception = ExceptionHelpers.format_exception(sys.exc_info())
response = app.response_class(
response=exception,
status=400,
mimetype='application/json'
)
return response
# Cumulative sum of values
@mod.route('cumulative_sum/', methods=["POST"])
def cumulative_sum():
try:
request_dict = request.get_json()
jsonstr = request_dict['jsonStr']
df = pd.read_json(json.dumps(eval(jsonstr)), orient='split')
dataframe_cumsum = df.cumsum()
values = list(map(list, zip(*dataframe_cumsum.values.tolist())))
keys = dataframe_cumsum.columns.values.tolist()
cum_dict = dict(zip(keys, values))
response = app.response_class(
response=json.dumps(cum_dict),
status=200,
mimetype='application/json'
)
except:
exception = ExceptionHelpers.format_exception(sys.exc_info())
response = app.response_class(
response=exception,
status=400,
mimetype='application/json'
)
return response
# maximum values
@mod.route('max_value/', methods=["POST"])
def max_value():
try:
request_dict = request.get_json()
jsonstr = request_dict['jsonStr']
df = pd.read_json(json.dumps(eval(jsonstr)), orient='split')
dataframe_max_value = df.max()
values = dataframe_max_value.values.tolist()
keys = dataframe_max_value.index.values.tolist()
max_value_dict = dict(zip(keys, values))
response = app.response_class(
response=json.dumps(max_value_dict),
status=200,
mimetype='application/json'
)
except:
exception = ExceptionHelpers.format_exception(sys.exc_info())
response = app.response_class(
response=exception,
status=400,
mimetype='application/json'
)
return response
# Minimum values
@mod.route('min_value/', methods=["POST"])
def min_value():
try:
request_dict = request.get_json()
jsonstr = request_dict['jsonStr']
df = pd.read_json(json.dumps(eval(jsonstr)), orient='split')
dataframe_min_value = df.min()
values = dataframe_min_value.values.tolist()
keys = dataframe_min_value.index.values.tolist()
min_value_dict = dict(zip(keys, values))
response = app.response_class(
response=json.dumps(min_value_dict),
status=200,
mimetype='application/json'
)
except:
exception = ExceptionHelpers.format_exception(sys.exc_info())
response = app.response_class(
response=exception,
status=400,
mimetype='application/json'
)
return response
# Maximum index value
# function returns index of first occurrence of maximum over requested axis.
# While finding the index of the maximum value across any index, all NA/null values are excluded.
@mod.route('max_index_value/', methods=["POST"])
def max_index_value():
try:
request_dict = request.get_json()
jsonstr = request_dict['jsonStr']
axis = request_dict['axis']
df = pd.read_json(json.dumps(eval(jsonstr)), orient='split')
df = df.select_dtypes(exclude=['object'])
dataframe_max_index_value = df.idxmax(axis=axis, skipna=True)
values = dataframe_max_index_value.values.tolist()
keys = dataframe_max_index_value.index.values.tolist()
max_index_value_dict = dict(zip(keys, values))
response = app.response_class(
response=json.dumps(max_index_value_dict),
status=200,
mimetype='application/json'
)
except:
exception = ExceptionHelpers.format_exception(sys.exc_info())
response = app.response_class(
response=exception,
status=400,
mimetype='application/json'
)
return response
# Minimum index value
@mod.route('min_index_value/', methods=["POST"])
def min_index_value():
try:
request_dict = request.get_json()
jsonstr = request_dict['jsonStr']
axis = request_dict['axis']
df = pd.read_json(json.dumps(eval(jsonstr)), orient='split')
df = df.select_dtypes(exclude=['object'])
dataframe_min_index_value = df.idxmin(axis=axis, skipna=True)
values = dataframe_min_index_value.values.tolist()
keys = dataframe_min_index_value.index.values.tolist()
min_index_value_dict = dict(zip(keys, values))
response = app.response_class(
response=json.dumps(min_index_value_dict),
status=200,
mimetype='application/json'
)
except:
exception = ExceptionHelpers.format_exception(sys.exc_info())
response = app.response_class(
response=exception,
status=400,
mimetype='application/json'
)
return response
# Summary statistics
# basic statistical details like percentile, mean, std etc. of a data frame or a series of numeric values.
@mod.route('describe/', methods=["POST"])
def describe():
try:
request_dict = request.get_json()
jsonstr = request_dict['jsonStr']
df = pd.read_json(json.dumps(eval(jsonstr)), orient='split')
dataframe_describe = df.describe(include='all')
df_json = dataframe_describe.to_json(orient='split', date_format='iso')
response = app.response_class(
response=df_json,
status=200,
mimetype='application/json'
)
except:
exception = ExceptionHelpers.format_exception(sys.exc_info())
response = app.response_class(
response=exception,
status=400,
mimetype='application/json'
)
return response
# Mean of values
@mod.route('mean/', methods=["POST"])
def mean():
try:
request_dict = request.get_json()
jsonstr = request_dict['jsonStr']
df = pd.read_json(json.dumps(eval(jsonstr)), orient='split')
dataframe_mean = df.mean()
values = dataframe_mean.values.tolist()
keys = dataframe_mean.index.values.tolist()
mean_dict = dict(zip(keys, values))
response = app.response_class(
response=json.dumps(mean_dict),
status=200,
mimetype='application/json'
)
except:
exception = ExceptionHelpers.format_exception(sys.exc_info())
response = app.response_class(
response=exception,
status=400,
mimetype='application/json'
)
return response
# Median of values
@mod.route('median/', methods=["POST"])
def median():
try:
request_dict = request.get_json()
jsonstr = request_dict['jsonStr']
df = pd.read_json(json.dumps(eval(jsonstr)), orient='split')
dataframe_median = df.median()
values = dataframe_median.values.tolist()
keys = dataframe_median.index.values.tolist()
median_dict = dict(zip(keys, values))
response = app.response_class(
response=json.dumps(median_dict),
status=200,
mimetype='application/json'
)
except:
exception = ExceptionHelpers.format_exception(sys.exc_info())
response = app.response_class(
response=exception,
status=400,
mimetype='application/json'
)
return response
# unique value for each variable
@mod.route('unique/', methods=["POST"])
def unique():
try:
request_dict = request.get_json()
jsonstr = request_dict['jsonStr']
df = pd.read_json(json.dumps(eval(jsonstr)), orient='split')
dataframe_nunique = df.nunique()
values = dataframe_nunique.values.tolist()
keys = dataframe_nunique.index.values.tolist()
nunique_dict = dict(zip(keys, values))
response = app.response_class(
response=json.dumps(nunique_dict),
status=200,
mimetype='application/json'
)
except:
exception = ExceptionHelpers.format_exception(sys.exc_info())
response = app.response_class(
response=exception,
status=400,
mimetype='application/json'
)
return response | 34.494424 | 106 | 0.62302 |
181dd6ced6dcdd12a7f90d81b4e2a3b5053b1fbe | 17,107 | py | Python | hummingbot/client/config/global_config_map.py | dietzam/hummingbot | 40d11a7bb604af8a3e0d22b8baefe45356e08419 | [
"Apache-2.0"
] | 5 | 2021-02-12T17:19:09.000Z | 2021-12-02T08:32:40.000Z | hummingbot/client/config/global_config_map.py | dietzam/hummingbot | 40d11a7bb604af8a3e0d22b8baefe45356e08419 | [
"Apache-2.0"
] | null | null | null | hummingbot/client/config/global_config_map.py | dietzam/hummingbot | 40d11a7bb604af8a3e0d22b8baefe45356e08419 | [
"Apache-2.0"
] | 6 | 2020-10-24T11:40:16.000Z | 2022-03-19T10:39:37.000Z | import random
from typing import Callable, Optional
from decimal import Decimal
import os.path
from hummingbot.client.config.config_var import ConfigVar
from hummingbot.client.settings import (
required_exchanges,
DEXES,
DEFAULT_KEY_FILE_PATH,
DEFAULT_LOG_FILE_PATH,
SCRIPTS_PATH, EXCHANGES
)
from hummingbot.client.config.config_validators import (
validate_bool,
validate_decimal
)
def generate_client_id() -> str:
vals = [random.choice(range(0, 256)) for i in range(0, 20)]
return "".join([f"{val:02x}" for val in vals])
# Required conditions
def paper_trade_disabled():
return global_config_map.get("paper_trade_enabled").value is False
def using_exchange(exchange: str) -> Callable:
return lambda: paper_trade_disabled() and exchange in required_exchanges
def using_wallet() -> bool:
return paper_trade_disabled() and any([e in DEXES for e in required_exchanges])
def using_bamboo_coordinator_mode() -> bool:
return global_config_map.get("bamboo_relay_use_coordinator").value
def validate_script_file_path(file_path: str) -> Optional[bool]:
path, name = os.path.split(file_path)
if path == "":
file_path = os.path.join(SCRIPTS_PATH, file_path)
if not os.path.isfile(file_path):
return f"{file_path} file does not exist."
# Main global config store
global_config_map = {
# The variables below are usually not prompted during setup process
"client_id":
ConfigVar(key="client_id",
prompt=None,
required_if=lambda: False,
default=generate_client_id()),
"log_level":
ConfigVar(key="log_level",
prompt=None,
required_if=lambda: False,
default="INFO"),
"debug_console":
ConfigVar(key="debug_console",
prompt=None,
type_str="bool",
required_if=lambda: False,
default=False),
"strategy_report_interval":
ConfigVar(key="strategy_report_interval",
prompt=None,
type_str="float",
required_if=lambda: False,
default=900),
"logger_override_whitelist":
ConfigVar(key="logger_override_whitelist",
prompt=None,
required_if=lambda: False,
default=["hummingbot.strategy",
"hummingbot.market",
"hummingbot.wallet",
"conf"
],
type_str="list"),
"key_file_path":
ConfigVar(key="key_file_path",
prompt=f"Where would you like to save your private key file? "
f"(default '{DEFAULT_KEY_FILE_PATH}') >>> ",
required_if=lambda: False,
default=DEFAULT_KEY_FILE_PATH),
"log_file_path":
ConfigVar(key="log_file_path",
prompt=f"Where would you like to save your logs? (default '{DEFAULT_LOG_FILE_PATH}') >>> ",
required_if=lambda: False,
default=DEFAULT_LOG_FILE_PATH),
# Required by chosen CEXes or DEXes
"paper_trade_enabled":
ConfigVar(key="paper_trade_enabled",
prompt="Enable paper trading mode (Yes/No) ? >>> ",
type_str="bool",
default=False,
required_if=lambda: True,
validator=validate_bool),
"paper_trade_account_balance":
ConfigVar(key="paper_trade_account_balance",
prompt="Enter paper trade balance settings (Input must be valid json: "
"e.g. [[\"ETH\", 10.0], [\"USDC\", 100]]) >>> ",
required_if=lambda: False,
type_str="json",
),
"binance_api_key":
ConfigVar(key="binance_api_key",
prompt="Enter your Binance API key >>> ",
required_if=using_exchange("binance"),
is_secure=True,
is_connect_key=True),
"binance_api_secret":
ConfigVar(key="binance_api_secret",
prompt="Enter your Binance API secret >>> ",
required_if=using_exchange("binance"),
is_secure=True,
is_connect_key=True),
"coinbase_pro_api_key":
ConfigVar(key="coinbase_pro_api_key",
prompt="Enter your Coinbase API key >>> ",
required_if=using_exchange("coinbase_pro"),
is_secure=True,
is_connect_key=True),
"coinbase_pro_secret_key":
ConfigVar(key="coinbase_pro_secret_key",
prompt="Enter your Coinbase secret key >>> ",
required_if=using_exchange("coinbase_pro"),
is_secure=True,
is_connect_key=True),
"coinbase_pro_passphrase":
ConfigVar(key="coinbase_pro_passphrase",
prompt="Enter your Coinbase passphrase >>> ",
required_if=using_exchange("coinbase_pro"),
is_secure=True,
is_connect_key=True),
"huobi_api_key":
ConfigVar(key="huobi_api_key",
prompt="Enter your Huobi API key >>> ",
required_if=using_exchange("huobi"),
is_secure=True,
is_connect_key=True),
"huobi_secret_key":
ConfigVar(key="huobi_secret_key",
prompt="Enter your Huobi secret key >>> ",
required_if=using_exchange("huobi"),
is_secure=True,
is_connect_key=True),
"liquid_api_key":
ConfigVar(key="liquid_api_key",
prompt="Enter your Liquid API key >>> ",
required_if=using_exchange("liquid"),
is_secure=True,
is_connect_key=True),
"liquid_secret_key":
ConfigVar(key="liquid_secret_key",
prompt="Enter your Liquid secret key >>> ",
required_if=using_exchange("liquid"),
is_secure=True,
is_connect_key=True),
"bamboo_relay_use_coordinator":
ConfigVar(key="bamboo_relay_use_coordinator",
prompt="Would you like to use the Bamboo Relay Coordinator? (Yes/No) >>> ",
required_if=lambda: False,
type_str="bool",
default=False,
validator=validate_bool),
"bamboo_relay_pre_emptive_soft_cancels":
ConfigVar(key="bamboo_relay_pre_emptive_soft_cancels",
prompt="Would you like to pre-emptively soft cancel orders? (Yes/No) >>> ",
required_if=lambda: False,
type_str="bool",
default=False,
validator=validate_bool),
"bittrex_api_key":
ConfigVar(key="bittrex_api_key",
prompt="Enter your Bittrex API key >>> ",
required_if=using_exchange("bittrex"),
is_secure=True,
is_connect_key=True),
"bittrex_secret_key":
ConfigVar(key="bittrex_secret_key",
prompt="Enter your Bittrex secret key >>> ",
required_if=using_exchange("bittrex"),
is_secure=True,
is_connect_key=True),
"kucoin_api_key":
ConfigVar(key="kucoin_api_key",
prompt="Enter your KuCoin API key >>> ",
required_if=using_exchange("kucoin"),
is_secure=True,
is_connect_key=True),
"kucoin_secret_key":
ConfigVar(key="kucoin_secret_key",
prompt="Enter your KuCoin secret key >>> ",
required_if=using_exchange("kucoin"),
is_secure=True,
is_connect_key=True),
"kucoin_passphrase":
ConfigVar(key="kucoin_passphrase",
prompt="Enter your KuCoin passphrase >>> ",
required_if=using_exchange("kucoin"),
is_secure=True,
is_connect_key=True),
"eterbase_api_key":
ConfigVar(key="eterbase_api_key",
prompt="Enter your Eterbase API key >>> ",
required_if=using_exchange("eterbase"),
is_secure=True,
is_connect_key=True),
"eterbase_secret_key":
ConfigVar(key="eterbase_secret_key",
prompt="Enter your Eterbase secret key >>> ",
required_if=using_exchange("eterbase"),
is_secure=True,
is_connect_key=True),
"eterbase_account":
ConfigVar(key="eterbase_account",
prompt="Enter your Eterbase account >>> ",
required_if=using_exchange("eterbase"),
is_secure=True,
is_connect_key=True),
"kraken_api_key":
ConfigVar(key="kraken_api_key",
prompt="Enter your Kraken API key >>> ",
required_if=using_exchange("kraken"),
is_secure=True,
is_connect_key=True),
"kraken_secret_key":
ConfigVar(key="kraken_secret_key",
prompt="Enter your Kraken secret key >>> ",
required_if=using_exchange("kraken"),
is_secure=True,
is_connect_key=True),
"crypto_com_api_key":
ConfigVar(key="crypto_com_api_key",
prompt="Enter your Crypto.com API key >>> ",
required_if=using_exchange("crypto_com"),
is_secure=True,
is_connect_key=True),
"crypto_com_secret_key":
ConfigVar(key="crypto_com_secret_key",
prompt="Enter your Crypto.com secret key >>> ",
required_if=using_exchange("crypto_com"),
is_secure=True,
is_connect_key=True),
"celo_address":
ConfigVar(key="celo_address",
prompt="Enter your Celo account address >>> ",
type_str="str",
required_if=lambda: False,
is_connect_key=True),
"celo_password":
ConfigVar(key="celo_password",
prompt="Enter your Celo account password >>> ",
type_str="str",
required_if=lambda: global_config_map["celo_address"].value is not None,
is_secure=True,
is_connect_key=True),
"ethereum_wallet":
ConfigVar(key="ethereum_wallet",
prompt="Enter your wallet private key >>> ",
type_str="str",
required_if=lambda: False,
is_connect_key=True),
"ethereum_rpc_url":
ConfigVar(key="ethereum_rpc_url",
prompt="Which Ethereum node would you like your client to connect to? >>> ",
required_if=lambda: global_config_map["ethereum_wallet"].value is not None),
"ethereum_rpc_ws_url":
ConfigVar(key="ethereum_rpc_ws_url",
prompt="Enter the Websocket Address of your Ethereum Node >>> ",
required_if=lambda: global_config_map["ethereum_rpc_url"].value is not None),
"ethereum_chain_name":
ConfigVar(key="ethereum_chain_name",
prompt="What is your preferred ethereum chain name? >>> ",
type_str="str",
required_if=lambda: False,
default="MAIN_NET"),
"ethereum_token_overrides":
ConfigVar(key="ethereum_token_overrides",
prompt="What is your preferred ethereum token overrides? >>> ",
type_str="json",
required_if=lambda: False,
default={}),
# Whether or not to invoke cancel_all on exit if marketing making on a open order book DEX (e.g. Radar Relay)
"on_chain_cancel_on_exit":
ConfigVar(key="on_chain_cancel_on_exit",
prompt="Would you like to cancel transactions on chain if using an open order books exchanges? >>> ",
required_if=lambda: False,
type_str="bool",
default=False),
"kill_switch_enabled":
ConfigVar(key="kill_switch_enabled",
prompt="Would you like to enable the kill switch? (Yes/No) >>> ",
required_if=paper_trade_disabled,
type_str="bool",
default=False,
validator=validate_bool),
"kill_switch_rate":
ConfigVar(key="kill_switch_rate",
prompt="At what profit/loss rate would you like the bot to stop? "
"(e.g. -5 equals 5 percent loss) >>> ",
type_str="decimal",
default=-100,
validator=lambda v: validate_decimal(v, Decimal(-100), Decimal(100)),
required_if=lambda: global_config_map["kill_switch_enabled"].value),
"telegram_enabled":
ConfigVar(key="telegram_enabled",
prompt="Would you like to enable telegram? >>> ",
type_str="bool",
default=False,
required_if=lambda: False),
"telegram_token":
ConfigVar(key="telegram_token",
prompt="What is your telegram token? >>> ",
required_if=lambda: False),
"telegram_chat_id":
ConfigVar(key="telegram_chat_id",
prompt="What is your telegram chat id? >>> ",
required_if=lambda: False),
"send_error_logs":
ConfigVar(key="send_error_logs",
prompt="Would you like to send error logs to hummingbot? (Yes/No) >>> ",
type_str="bool",
default=True),
"min_quote_order_amount":
ConfigVar(key="min_quote_order_amount",
prompt=None,
required_if=lambda: False,
type_str="json",
),
# Database options
"db_engine":
ConfigVar(key="db_engine",
prompt="Please enter database engine you want to use (reference: https://docs.sqlalchemy.org/en/13/dialects/) >>> ",
type_str="str",
required_if=lambda: False,
default="sqlite"),
"db_host":
ConfigVar(key="db_host",
prompt="Please enter your DB host address >>> ",
type_str="str",
required_if=lambda: global_config_map.get("db_engine").value != "sqlite",
default="127.0.0.1"),
"db_port":
ConfigVar(key="db_port",
prompt="Please enter your DB port >>> ",
type_str="str",
required_if=lambda: global_config_map.get("db_engine").value != "sqlite",
default="3306"),
"db_username":
ConfigVar(key="db_username",
prompt="Please enter your DB username >>> ",
type_str="str",
required_if=lambda: global_config_map.get("db_engine").value != "sqlite",
default="username"),
"db_password":
ConfigVar(key="db_password",
prompt="Please enter your DB password >>> ",
type_str="str",
required_if=lambda: global_config_map.get("db_engine").value != "sqlite",
default="password"),
"db_name":
ConfigVar(key="db_name",
prompt="Please enter your the name of your DB >>> ",
type_str="str",
required_if=lambda: global_config_map.get("db_engine").value != "sqlite",
default="dbname"),
"0x_active_cancels":
ConfigVar(key="0x_active_cancels",
prompt="Enable active order cancellations for 0x exchanges (warning: this costs gas)? >>> ",
type_str="bool",
default=False,
validator=validate_bool),
"script_enabled":
ConfigVar(key="script_enabled",
prompt="Would you like to enable script feature? (Yes/No) >>> ",
type_str="bool",
default=False,
validator=validate_bool),
"script_file_path":
ConfigVar(key="script_file_path",
prompt='Enter path to your script file >>> ',
type_str="str",
required_if=lambda: global_config_map["script_enabled"].value,
validator=validate_script_file_path),
"balance_asset_limit":
ConfigVar(key="balance_asset_limit",
prompt="Use the `balance limit` command"
"e.g. balance limit [EXCHANGE] [ASSET] [AMOUNT]",
required_if=lambda: False,
type_str="json",
default={exchange: None for exchange in EXCHANGES}),
}
| 42.7675 | 134 | 0.549073 |
c35b4594bf06213e49baee9ee71e92e6d142aa08 | 44 | py | Python | 1A_reverse_string.py | StevenGhow/For_Junyi | 1d6e78d5c786464ef1698ec6d066a94d58abb4c3 | [
"MIT"
] | null | null | null | 1A_reverse_string.py | StevenGhow/For_Junyi | 1d6e78d5c786464ef1698ec6d066a94d58abb4c3 | [
"MIT"
] | null | null | null | 1A_reverse_string.py | StevenGhow/For_Junyi | 1d6e78d5c786464ef1698ec6d066a94d58abb4c3 | [
"MIT"
] | null | null | null | oriStr = input("input:")
print(oriStr[::-1]) | 22 | 24 | 0.636364 |
69e293d2a6b623886a82620030f6efcbf824e037 | 1,525 | py | Python | src/more/inspect/__init__.py | badmonkey/python-hobgoblin | 46cfbea7738d137f8afa08aafdd65e3de9159763 | [
"MIT"
] | null | null | null | src/more/inspect/__init__.py | badmonkey/python-hobgoblin | 46cfbea7738d137f8afa08aafdd65e3de9159763 | [
"MIT"
] | null | null | null | src/more/inspect/__init__.py | badmonkey/python-hobgoblin | 46cfbea7738d137f8afa08aafdd65e3de9159763 | [
"MIT"
] | null | null | null | import inspect as _inspect
from inspect import * # noqa
import codefresh.more.typing as typing
def find_new(cls):
""" Search mro for a __new__ function """
for x in _inspect.getmro(cls):
f = getattr(x, "__new__", None)
if f:
return f, x.__name__
return None, None
def class_by_name(cls: str) -> typing.Type:
""" Convert fully qualified class name into a class object """
parts = cls.split(".")
module = ".".join(parts[:-1])
m = __import__(module)
for comp in parts[1:]:
m = getattr(m, comp)
return m
def unique_name(cls: typing.Type) -> str:
return f"{cls.__qualname__}".replace(".<locals>", "").replace(".", "_")
def caller(offset=3, ignore=None):
ignore = ignore or ("decorum", "codefresh")
callstack = _inspect.stack()
for info in callstack[offset:]:
frame = info.frame
_module = _inspect.getmodule(frame)
if _module is None:
break
if info.function == "__enter__":
continue
name = _module.__name__
for x in ignore:
if name.startswith(f"{x}."):
continue
return _module, info
return None, None
def caller_module(offset=3, ignore=None):
_module, _ = caller(offset, ignore)
if _module:
return _module.__name__
return None
def caller_package(offset=3, ignore=None):
_module, _ = caller(offset, ignore)
if _module:
return _module.__name__.split(".")[0]
return None
| 22.101449 | 75 | 0.600656 |
e95f3efa780e77f5d5e3b316ca26b69f7311ddb5 | 1,305 | py | Python | Backend/TuneSwitch/switch/token_auth.py | anandhakrishnanaji/TuneSwitch | f37e5fcfe0ce63960a72690735efb90fa614b245 | [
"MIT"
] | 9 | 2020-09-01T12:03:36.000Z | 2022-03-02T18:22:10.000Z | Backend/TuneSwitch/switch/token_auth.py | anandhakrishnanaji/TuneSwitch | f37e5fcfe0ce63960a72690735efb90fa614b245 | [
"MIT"
] | 3 | 2021-03-30T14:18:54.000Z | 2021-06-10T20:08:39.000Z | Backend/TuneSwitch/switch/token_auth.py | anandhakrishnanaji/TuneSwitch | f37e5fcfe0ce63960a72690735efb90fa614b245 | [
"MIT"
] | 5 | 2020-09-01T12:03:55.000Z | 2022-01-08T09:10:44.000Z | from channels.auth import AuthMiddlewareStack
from rest_framework.authtoken.models import Token
from django.contrib.auth.models import AnonymousUser
from asgiref.sync import sync_to_async
from channels.db import database_sync_to_async
@database_sync_to_async
def get_user(token_key):
try:
return Token.objects.get(key=token_key).user
except Token.DoesNotExist:
return AnonymousUser()
class TokenAuthMiddleware:
def __init__(self, inner):
self.inner = inner
def __call__(self, scope):
return TokenAuthMiddlewareInstance(scope, self)
class TokenAuthMiddlewareInstance:
def __init__(self, scope, middleware):
self.middleware = middleware
self.scope = dict(scope)
self.inner = self.middleware.inner
async def __call__(self, receive, send):
headers = dict(self.scope['headers'])
if b'authorization' in headers:
token_name, token_key = headers[b'authorization'].decode().split()
if token_name == 'Token':
self.scope['user'] = await get_user(token_key)
print(self.scope['user'].username)
inner= self.inner(self.scope)
return await inner(receive,send)
TokenAuthMiddlewareStack = lambda inner: TokenAuthMiddleware(AuthMiddlewareStack(inner)) | 32.625 | 88 | 0.70728 |
5ba444c7d92e5633b9783b74ba31d6a8741e51a7 | 14,244 | py | Python | zerver/lib/digest.py | TylerPham2000/zulip | 2e7aaba0dde5517b4a55cb0bd782f009be45e3ba | [
"Apache-2.0"
] | 17,004 | 2015-09-25T18:27:24.000Z | 2022-03-31T22:02:32.000Z | zerver/lib/digest.py | TylerPham2000/zulip | 2e7aaba0dde5517b4a55cb0bd782f009be45e3ba | [
"Apache-2.0"
] | 20,344 | 2015-09-25T19:02:42.000Z | 2022-03-31T23:54:40.000Z | zerver/lib/digest.py | TylerPham2000/zulip | 2e7aaba0dde5517b4a55cb0bd782f009be45e3ba | [
"Apache-2.0"
] | 7,271 | 2015-09-25T18:48:39.000Z | 2022-03-31T21:06:11.000Z | import datetime
import heapq
import logging
from collections import defaultdict
from typing import Any, Dict, List, Set, Tuple
from django.conf import settings
from django.db import transaction
from django.utils.timezone import now as timezone_now
from confirmation.models import one_click_unsubscribe_link
from zerver.context_processors import common_context
from zerver.lib.email_notifications import build_message_list
from zerver.lib.logging_util import log_to_file
from zerver.lib.message import get_last_message_id
from zerver.lib.queue import queue_json_publish
from zerver.lib.send_email import FromAddress, send_future_email
from zerver.lib.url_encoding import encode_stream
from zerver.models import (
Message,
Realm,
RealmAuditLog,
Recipient,
Stream,
Subscription,
UserActivityInterval,
UserProfile,
get_active_streams,
)
logger = logging.getLogger(__name__)
log_to_file(logger, settings.DIGEST_LOG_PATH)
DIGEST_CUTOFF = 5
MAX_HOT_TOPICS_TO_BE_INCLUDED_IN_DIGEST = 4
TopicKey = Tuple[int, str]
class DigestTopic:
def __init__(self, topic_key: TopicKey) -> None:
self.topic_key = topic_key
self.human_senders: Set[str] = set()
self.sample_messages: List[Message] = []
self.num_human_messages = 0
def stream_id(self) -> int:
# topic_key is (stream_id, topic_name)
return self.topic_key[0]
def add_message(self, message: Message) -> None:
if len(self.sample_messages) < 2:
self.sample_messages.append(message)
if message.sent_by_human():
self.human_senders.add(message.sender.full_name)
self.num_human_messages += 1
def length(self) -> int:
return self.num_human_messages
def diversity(self) -> int:
return len(self.human_senders)
def teaser_data(self, user: UserProfile, stream_map: Dict[int, Stream]) -> Dict[str, Any]:
teaser_count = self.num_human_messages - len(self.sample_messages)
first_few_messages = build_message_list(
user=user,
messages=self.sample_messages,
stream_map=stream_map,
)
return {
"participants": sorted(self.human_senders),
"count": teaser_count,
"first_few_messages": first_few_messages,
}
# Digests accumulate 2 types of interesting traffic for a user:
# 1. New streams
# 2. Interesting stream traffic, as determined by the longest and most
# diversely comment upon topics.
def should_process_digest(realm_str: str) -> bool:
if realm_str in settings.SYSTEM_ONLY_REALMS:
# Don't try to send emails to system-only realms
return False
return True
# Changes to this should also be reflected in
# zerver/worker/queue_processors.py:DigestWorker.consume()
def queue_digest_user_ids(user_ids: List[int], cutoff: datetime.datetime) -> None:
# Convert cutoff to epoch seconds for transit.
event = {"user_ids": user_ids, "cutoff": cutoff.strftime("%s")}
queue_json_publish("digest_emails", event)
def enqueue_emails(cutoff: datetime.datetime) -> None:
if not settings.SEND_DIGEST_EMAILS:
return
weekday = timezone_now().weekday()
for realm in Realm.objects.filter(
deactivated=False, digest_emails_enabled=True, digest_weekday=weekday
):
if should_process_digest(realm.string_id):
_enqueue_emails_for_realm(realm, cutoff)
def _enqueue_emails_for_realm(realm: Realm, cutoff: datetime.datetime) -> None:
# This should only be called directly by tests. Use enqueue_emails
# to process all realms that are set up for processing on any given day.
realm_user_ids = set(
UserProfile.objects.filter(
realm=realm,
is_active=True,
is_bot=False,
enable_digest_emails=True,
).values_list("id", flat=True)
)
twelve_hours_ago = timezone_now() - datetime.timedelta(hours=12)
recent_user_ids = set(
RealmAuditLog.objects.filter(
realm_id=realm.id,
event_type=RealmAuditLog.USER_DIGEST_EMAIL_CREATED,
event_time__gt=twelve_hours_ago,
)
.values_list("modified_user_id", flat=True)
.distinct()
)
realm_user_ids -= recent_user_ids
active_user_ids = set(
UserActivityInterval.objects.filter(
user_profile_id__in=realm_user_ids,
end__gt=cutoff,
)
.values_list("user_profile_id", flat=True)
.distinct()
)
user_ids = list(realm_user_ids - active_user_ids)
user_ids.sort()
# We process batches of 30. We want a big enough batch
# to amorize work, but not so big that a single item
# from the queue takes too long to process.
chunk_size = 30
for i in range(0, len(user_ids), chunk_size):
chunk_user_ids = user_ids[i : i + chunk_size]
queue_digest_user_ids(chunk_user_ids, cutoff)
logger.info(
"Queuing user_ids for potential digest: %s",
chunk_user_ids,
)
def get_recent_topics(
stream_ids: List[int],
cutoff_date: datetime.datetime,
) -> List[DigestTopic]:
# Gather information about topic conversations, then
# classify by:
# * topic length
# * number of senders
messages = (
Message.objects.filter(
recipient__type=Recipient.STREAM,
recipient__type_id__in=stream_ids,
date_sent__gt=cutoff_date,
)
.order_by(
"id", # we will sample the first few messages
)
.select_related(
"recipient", # we need stream_id
"sender", # we need the sender's full name
"sending_client", # for Message.sent_by_human
)
)
digest_topic_map: Dict[TopicKey, DigestTopic] = {}
for message in messages:
topic_key = (message.recipient.type_id, message.topic_name())
if topic_key not in digest_topic_map:
digest_topic_map[topic_key] = DigestTopic(topic_key)
digest_topic_map[topic_key].add_message(message)
topics = list(digest_topic_map.values())
return topics
def get_hot_topics(
all_topics: List[DigestTopic],
stream_ids: Set[int],
) -> List[DigestTopic]:
topics = [topic for topic in all_topics if topic.stream_id() in stream_ids]
hot_topics = heapq.nlargest(2, topics, key=DigestTopic.diversity)
for topic in heapq.nlargest(
MAX_HOT_TOPICS_TO_BE_INCLUDED_IN_DIGEST, topics, key=DigestTopic.length
):
if topic not in hot_topics:
hot_topics.append(topic)
if len(hot_topics) == MAX_HOT_TOPICS_TO_BE_INCLUDED_IN_DIGEST:
break
return hot_topics
def get_recent_streams(realm: Realm, threshold: datetime.datetime) -> List[Stream]:
fields = ["id", "name", "is_web_public", "invite_only"]
return list(get_active_streams(realm).filter(date_created__gt=threshold).only(*fields))
def gather_new_streams(
realm: Realm,
recent_streams: List[Stream], # streams only need id and name
can_access_public: bool,
) -> Tuple[int, Dict[str, List[str]]]:
if can_access_public:
new_streams = [stream for stream in recent_streams if not stream.invite_only]
else:
new_streams = [stream for stream in recent_streams if stream.is_web_public]
base_url = f"{realm.uri}/#narrow/stream/"
streams_html = []
streams_plain = []
for stream in new_streams:
narrow_url = base_url + encode_stream(stream.id, stream.name)
stream_link = f"<a href='{narrow_url}'>{stream.name}</a>"
streams_html.append(stream_link)
streams_plain.append(stream.name)
return len(new_streams), {"html": streams_html, "plain": streams_plain}
def enough_traffic(hot_conversations: str, new_streams: int) -> bool:
return bool(hot_conversations or new_streams)
def get_user_stream_map(user_ids: List[int]) -> Dict[int, Set[int]]:
rows = Subscription.objects.filter(
user_profile_id__in=user_ids,
recipient__type=Recipient.STREAM,
active=True,
is_muted=False,
).values("user_profile_id", "recipient__type_id")
# maps user_id -> {stream_id, stream_id, ...}
dct: Dict[int, Set[int]] = defaultdict(set)
for row in rows:
dct[row["user_profile_id"]].add(row["recipient__type_id"])
return dct
def get_slim_stream_map(stream_ids: Set[int]) -> Dict[int, Stream]:
# This can be passed to build_message_list.
streams = Stream.objects.filter(
id__in=stream_ids,
).only("id", "name")
return {stream.id: stream for stream in streams}
def bulk_get_digest_context(users: List[UserProfile], cutoff: float) -> Dict[int, Dict[str, Any]]:
# We expect a non-empty list of users all from the same realm.
assert users
realm = users[0].realm
for user in users:
assert user.realm_id == realm.id
# Convert from epoch seconds to a datetime object.
cutoff_date = datetime.datetime.fromtimestamp(int(cutoff), tz=datetime.timezone.utc)
result: Dict[int, Dict[str, Any]] = {}
user_ids = [user.id for user in users]
user_stream_map = get_user_stream_map(user_ids)
recently_modified_streams = get_modified_streams(user_ids, cutoff_date)
all_stream_ids = set()
for user in users:
stream_ids = user_stream_map[user.id]
stream_ids -= recently_modified_streams.get(user.id, set())
all_stream_ids |= stream_ids
# Get all the recent topics for all the users. This does the heavy
# lifting of making an expensive query to the Message table. Then
# for each user, we filter to just the streams they care about.
recent_topics = get_recent_topics(sorted(list(all_stream_ids)), cutoff_date)
stream_map = get_slim_stream_map(all_stream_ids)
recent_streams = get_recent_streams(realm, cutoff_date)
for user in users:
stream_ids = user_stream_map[user.id]
hot_topics = get_hot_topics(recent_topics, stream_ids)
context = common_context(user)
# Start building email template data.
unsubscribe_link = one_click_unsubscribe_link(user, "digest")
context.update(unsubscribe_link=unsubscribe_link)
# Get context data for hot conversations.
context["hot_conversations"] = [
hot_topic.teaser_data(user, stream_map) for hot_topic in hot_topics
]
# Gather new streams.
new_streams_count, new_streams = gather_new_streams(
realm=realm,
recent_streams=recent_streams,
can_access_public=user.can_access_public_streams(),
)
context["new_streams"] = new_streams
context["new_streams_count"] = new_streams_count
result[user.id] = context
return result
def get_digest_context(user: UserProfile, cutoff: float) -> Dict[str, Any]:
return bulk_get_digest_context([user], cutoff)[user.id]
@transaction.atomic
def bulk_handle_digest_email(user_ids: List[int], cutoff: float) -> None:
# We go directly to the database to get user objects,
# since inactive users are likely to not be in the cache.
users = UserProfile.objects.filter(id__in=user_ids).order_by("id").select_related("realm")
context_map = bulk_get_digest_context(users, cutoff)
digest_users = []
for user in users:
context = context_map[user.id]
# We don't want to send emails containing almost no information.
if enough_traffic(context["hot_conversations"], context["new_streams_count"]):
digest_users.append(user)
logger.info("Sending digest email for user %s", user.id)
# Send now, as a ScheduledEmail
send_future_email(
"zerver/emails/digest",
user.realm,
to_user_ids=[user.id],
from_name="Zulip Digest",
from_address=FromAddress.no_reply_placeholder,
context=context,
)
bulk_write_realm_audit_logs(digest_users)
def bulk_write_realm_audit_logs(users: List[UserProfile]) -> None:
if not users:
return
# We write RealmAuditLog rows for auditing, and we will also
# use these rows during the next run to possibly exclude the
# users (if insufficient time has passed).
last_message_id = get_last_message_id()
now = timezone_now()
log_rows = [
RealmAuditLog(
realm_id=user.realm_id,
modified_user_id=user.id,
event_last_message_id=last_message_id,
event_time=now,
event_type=RealmAuditLog.USER_DIGEST_EMAIL_CREATED,
)
for user in users
]
RealmAuditLog.objects.bulk_create(log_rows)
def get_modified_streams(
user_ids: List[int], cutoff_date: datetime.datetime
) -> Dict[int, Set[int]]:
"""Skipping streams where the user's subscription status has changed
when constructing digests is critical to ensure correctness for
streams without shared history, guest users, and long-term idle
users, because it means that every user has the same view of the
history of a given stream whose message history is being included
(and thus we can share a lot of work).
The downside is that newly created streams are never included in
the first digest email after their creation. Should we wish to
change that, we will need to be very careful to avoid creating
bugs for any of those classes of users.
"""
events = [
RealmAuditLog.SUBSCRIPTION_CREATED,
RealmAuditLog.SUBSCRIPTION_ACTIVATED,
RealmAuditLog.SUBSCRIPTION_DEACTIVATED,
]
# Get rows where the users' subscriptions have changed.
rows = (
RealmAuditLog.objects.filter(
modified_user_id__in=user_ids,
event_time__gt=cutoff_date,
event_type__in=events,
)
.values("modified_user_id", "modified_stream_id")
.distinct()
)
result: Dict[int, Set[int]] = defaultdict(set)
for row in rows:
user_id = row["modified_user_id"]
stream_id = row["modified_stream_id"]
result[user_id].add(stream_id)
return result
| 32.372727 | 98 | 0.679865 |
9a510502cb5e9b3f4c17ff9634d1bf0f67fc345a | 131 | py | Python | polite/__init__.py | H0R5E/polite | bbbbf4fffbade585cb8b7114c4a8821e822c42e0 | [
"MIT"
] | 1 | 2020-05-03T21:10:33.000Z | 2020-05-03T21:10:33.000Z | polite/__init__.py | H0R5E/polite | bbbbf4fffbade585cb8b7114c4a8821e822c42e0 | [
"MIT"
] | 6 | 2017-06-12T13:50:09.000Z | 2019-07-02T10:24:45.000Z | polite/__init__.py | H0R5E/polite | bbbbf4fffbade585cb8b7114c4a8821e822c42e0 | [
"MIT"
] | 2 | 2017-06-12T12:40:03.000Z | 2018-11-17T12:47:48.000Z |
# Define build number for packaging test
from ._build import BUILD
__all__ = ["abc", "configuration", "paths"]
__build__ = BUILD
| 18.714286 | 43 | 0.732824 |
16bd90c8111e1bbe9cb1d71e441e124663b6d282 | 2,572 | py | Python | redash/authentication/account.py | frextrite/redash | 74beed80d20d858b51b5560e7984b20d5d2c874e | [
"BSD-2-Clause"
] | 3 | 2018-06-01T00:05:18.000Z | 2019-03-07T14:03:10.000Z | redash/authentication/account.py | frextrite/redash | 74beed80d20d858b51b5560e7984b20d5d2c874e | [
"BSD-2-Clause"
] | 10 | 2017-10-17T09:17:53.000Z | 2019-12-05T07:13:41.000Z | redash/authentication/account.py | tradingfoe/redash-clone | 94065b8dce0e27f6f40a7adc2b99e078b03115b3 | [
"BSD-2-Clause"
] | 5 | 2018-06-02T11:12:44.000Z | 2020-05-13T18:34:33.000Z | import logging
from flask import render_template
from redash import settings
from redash.tasks import send_mail
from redash.utils import base_url
# noinspection PyUnresolvedReferences
from itsdangerous import URLSafeTimedSerializer, SignatureExpired, BadSignature
logger = logging.getLogger(__name__)
serializer = URLSafeTimedSerializer(settings.SECRET_KEY)
def invite_token(user):
return serializer.dumps(str(user.id))
def verify_link_for_user(user):
token = invite_token(user)
verify_url = "{}/verify/{}".format(base_url(user.org), token)
return verify_url
def invite_link_for_user(user):
token = invite_token(user)
invite_url = "{}/invite/{}".format(base_url(user.org), token)
return invite_url
def reset_link_for_user(user):
token = invite_token(user)
invite_url = "{}/reset/{}".format(base_url(user.org), token)
return invite_url
def validate_token(token):
max_token_age = settings.INVITATION_TOKEN_MAX_AGE
return serializer.loads(token, max_age=max_token_age)
def send_verify_email(user, org):
context = {
'user': user,
'verify_url': verify_link_for_user(user),
}
html_content = render_template('emails/verify.html', **context)
text_content = render_template('emails/verify.txt', **context)
subject = u"{}, please verify your email address".format(user.name)
send_mail.delay([user.email], subject, html_content, text_content)
def send_invite_email(inviter, invited, invite_url, org):
context = dict(inviter=inviter, invited=invited, org=org, invite_url=invite_url)
html_content = render_template('emails/invite.html', **context)
text_content = render_template('emails/invite.txt', **context)
subject = u"{} invited you to join Redash".format(inviter.name)
send_mail.delay([invited.email], subject, html_content, text_content)
def send_password_reset_email(user):
reset_link = reset_link_for_user(user)
context = dict(user=user, reset_link=reset_link)
html_content = render_template('emails/reset.html', **context)
text_content = render_template('emails/reset.txt', **context)
subject = u"Reset your password"
send_mail.delay([user.email], subject, html_content, text_content)
return reset_link
def send_user_disabled_email(user):
html_content = render_template('emails/reset_disabled.html', user=user)
text_content = render_template('emails/reset_disabled.txt', user=user)
subject = u"Your Redash account is disabled"
send_mail.delay([user.email], subject, html_content, text_content)
| 31.365854 | 84 | 0.745334 |
dbb5f46ba10fc29763b73d81bef6dbcff4f5be3a | 2,280 | py | Python | spotify_tensorflow/luigi/tfx_task.py | rahmantasnim/spotify-tensorflow | 5673aa8191f59a77adf17f0d458716cd581e68e0 | [
"Apache-2.0"
] | null | null | null | spotify_tensorflow/luigi/tfx_task.py | rahmantasnim/spotify-tensorflow | 5673aa8191f59a77adf17f0d458716cd581e68e0 | [
"Apache-2.0"
] | null | null | null | spotify_tensorflow/luigi/tfx_task.py | rahmantasnim/spotify-tensorflow | 5673aa8191f59a77adf17f0d458716cd581e68e0 | [
"Apache-2.0"
] | null | null | null | # -*- coding: utf-8 -*-
#
# Copyright 2017-2019 Spotify AB.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
#
from abc import abstractmethod
import time
from spotify_tensorflow.luigi.python_dataflow_task import PythonDataflowTask
class TFXBaseTask(PythonDataflowTask):
def __init__(self, *args, **kwargs):
super(TFXBaseTask, self).__init__(*args, **kwargs)
if self.job_name is None:
# job_name must consist of only the characters [-a-z0-9]
cls_name = self.__class__.__name__.replace("_", "-").lower()
self.job_name = "{cls_name}-{timestamp}".format(cls_name=cls_name,
timestamp=str(time.time())[:-3])
def tfx_args(self):
""" Extra arguments that will be passed to your tfx dataflow job.
Example:
return ["--schema_file=gs://uri/to/schema_file"]
Note that:
* You "set" args by overriding this method in your tfx subclass.
* This function should return an iterable of strings.
"""
return []
def _mk_cmd_line(self):
cmd_line = super(TFXBaseTask, self)._mk_cmd_line()
cmd_line.extend(self.tfx_args())
return cmd_line
class TFTransformTask(TFXBaseTask):
def __init__(self, *args, **kwargs):
super(TFTransformTask, self).__init__(*args, **kwargs)
def tfx_args(self):
return [
"--schema_file=%s" % self.get_schema_file()
]
@abstractmethod
def get_schema_file(self): # type: () -> str
"""
Should return fully qualified path to the stats file generated by TFDV.
This has to be defined as a method because the stats file is based on the input dataset
"""
pass
| 33.529412 | 95 | 0.645175 |
cf2a74956bb487d86f68c7744fcbe1a3a34b0937 | 142 | py | Python | app/question/urls.py | PICT-ACM-Student-Chapter/OJ_API | 9172c2bedb82d5091d535d27c548385b35aeacad | [
"MIT"
] | 2 | 2021-08-14T18:10:37.000Z | 2022-03-03T17:16:45.000Z | app/question/urls.py | PICT-ACM-Student-Chapter/OJ_API | 9172c2bedb82d5091d535d27c548385b35aeacad | [
"MIT"
] | null | null | null | app/question/urls.py | PICT-ACM-Student-Chapter/OJ_API | 9172c2bedb82d5091d535d27c548385b35aeacad | [
"MIT"
] | 1 | 2021-09-22T09:12:21.000Z | 2021-09-22T09:12:21.000Z | from django.urls import path
from question.views import QuestionDetail
urlpatterns = [
path('<str:que_id>', QuestionDetail.as_view())
]
| 17.75 | 50 | 0.746479 |
2fdba0f82d7d7e666fa5e3b54065dbd74f48eadc | 8,664 | py | Python | src/cryptography/hazmat/bindings/openssl/x509.py | public/cryptography | e01eeb407aa77e6c8108bf08c85533d268a496bd | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | src/cryptography/hazmat/bindings/openssl/x509.py | public/cryptography | e01eeb407aa77e6c8108bf08c85533d268a496bd | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | src/cryptography/hazmat/bindings/openssl/x509.py | public/cryptography | e01eeb407aa77e6c8108bf08c85533d268a496bd | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | # This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.
from __future__ import absolute_import, division, print_function
INCLUDES = """
#include <openssl/ssl.h>
/*
* This is part of a work-around for the difficulty cffi has in dealing with
* `STACK_OF(foo)` as the name of a type. We invent a new, simpler name that
* will be an alias for this type and use the alias throughout. This works
* together with another opaque typedef for the same name in the TYPES section.
* Note that the result is an opaque type.
*/
typedef STACK_OF(X509) Cryptography_STACK_OF_X509;
typedef STACK_OF(X509_CRL) Cryptography_STACK_OF_X509_CRL;
typedef STACK_OF(X509_REVOKED) Cryptography_STACK_OF_X509_REVOKED;
"""
TYPES = """
typedef ... Cryptography_STACK_OF_X509;
typedef ... Cryptography_STACK_OF_X509_CRL;
typedef ... Cryptography_STACK_OF_X509_REVOKED;
typedef struct {
ASN1_OBJECT *algorithm;
...;
} X509_ALGOR;
typedef ... X509_ATTRIBUTE;
typedef struct {
X509_ALGOR *signature;
...;
} X509_CINF;
typedef struct {
ASN1_OBJECT *object;
ASN1_BOOLEAN critical;
ASN1_OCTET_STRING *value;
} X509_EXTENSION;
typedef ... X509_EXTENSIONS;
typedef ... X509_REQ;
typedef struct {
ASN1_INTEGER *serialNumber;
ASN1_TIME *revocationDate;
X509_EXTENSIONS *extensions;
int sequence;
...;
} X509_REVOKED;
typedef struct {
Cryptography_STACK_OF_X509_REVOKED *revoked;
...;
} X509_CRL_INFO;
typedef struct {
X509_CRL_INFO *crl;
...;
} X509_CRL;
typedef struct {
X509_CINF *cert_info;
...;
} X509;
typedef ... NETSCAPE_SPKI;
"""
FUNCTIONS = """
X509 *X509_new(void);
void X509_free(X509 *);
X509 *X509_dup(X509 *);
int X509_print_ex(BIO *, X509 *, unsigned long, unsigned long);
int X509_set_version(X509 *, long);
EVP_PKEY *X509_get_pubkey(X509 *);
int X509_set_pubkey(X509 *, EVP_PKEY *);
unsigned char *X509_alias_get0(X509 *, int *);
int X509_sign(X509 *, EVP_PKEY *, const EVP_MD *);
int X509_digest(const X509 *, const EVP_MD *, unsigned char *, unsigned int *);
ASN1_TIME *X509_gmtime_adj(ASN1_TIME *, long);
unsigned long X509_subject_name_hash(X509 *);
X509_NAME *X509_get_subject_name(X509 *);
int X509_set_subject_name(X509 *, X509_NAME *);
X509_NAME *X509_get_issuer_name(X509 *);
int X509_set_issuer_name(X509 *, X509_NAME *);
int X509_get_ext_count(X509 *);
int X509_add_ext(X509 *, X509_EXTENSION *, int);
X509_EXTENSION *X509_EXTENSION_dup(X509_EXTENSION *);
X509_EXTENSION *X509_get_ext(X509 *, int);
int X509_EXTENSION_get_critical(X509_EXTENSION *);
ASN1_OBJECT *X509_EXTENSION_get_object(X509_EXTENSION *);
void X509_EXTENSION_free(X509_EXTENSION *);
int X509_REQ_set_version(X509_REQ *, long);
X509_REQ *X509_REQ_new(void);
void X509_REQ_free(X509_REQ *);
int X509_REQ_set_pubkey(X509_REQ *, EVP_PKEY *);
int X509_REQ_sign(X509_REQ *, EVP_PKEY *, const EVP_MD *);
int X509_REQ_verify(X509_REQ *, EVP_PKEY *);
int X509_REQ_digest(const X509_REQ *, const EVP_MD *,
unsigned char *, unsigned int *);
EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *);
int X509_REQ_print_ex(BIO *, X509_REQ *, unsigned long, unsigned long);
int X509V3_EXT_print(BIO *, X509_EXTENSION *, unsigned long, int);
ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *);
X509_REVOKED *X509_REVOKED_new(void);
void X509_REVOKED_free(X509_REVOKED *);
int X509_REVOKED_set_serialNumber(X509_REVOKED *, ASN1_INTEGER *);
int X509_REVOKED_add1_ext_i2d(X509_REVOKED *, int, void *, int, unsigned long);
X509_CRL *d2i_X509_CRL_bio(BIO *, X509_CRL **);
X509_CRL *X509_CRL_new(void);
void X509_CRL_free(X509_CRL *);
int X509_CRL_add0_revoked(X509_CRL *, X509_REVOKED *);
int i2d_X509_CRL_bio(BIO *, X509_CRL *);
int X509_CRL_print(BIO *, X509_CRL *);
int X509_CRL_set_issuer_name(X509_CRL *, X509_NAME *);
int X509_CRL_sign(X509_CRL *, EVP_PKEY *, const EVP_MD *);
int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *, EVP_PKEY *);
int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *, EVP_PKEY *, const EVP_MD *);
char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *);
EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *);
int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *, EVP_PKEY *);
NETSCAPE_SPKI *NETSCAPE_SPKI_new(void);
void NETSCAPE_SPKI_free(NETSCAPE_SPKI *);
/* ASN1 serialization */
int i2d_X509_bio(BIO *, X509 *);
X509 *d2i_X509_bio(BIO *, X509 **);
int i2d_X509_REQ_bio(BIO *, X509_REQ *);
X509_REQ *d2i_X509_REQ_bio(BIO *, X509_REQ **);
int i2d_PrivateKey_bio(BIO *, EVP_PKEY *);
EVP_PKEY *d2i_PrivateKey_bio(BIO *, EVP_PKEY **);
int i2d_PUBKEY_bio(BIO *, EVP_PKEY *);
EVP_PKEY *d2i_PUBKEY_bio(BIO *, EVP_PKEY **);
ASN1_INTEGER *X509_get_serialNumber(X509 *);
int X509_set_serialNumber(X509 *, ASN1_INTEGER *);
const char *X509_verify_cert_error_string(long);
const char *X509_get_default_cert_area(void);
const char *X509_get_default_cert_dir(void);
const char *X509_get_default_cert_file(void);
const char *X509_get_default_cert_dir_env(void);
const char *X509_get_default_cert_file_env(void);
const char *X509_get_default_private_dir(void);
int i2d_RSA_PUBKEY(RSA *, unsigned char **);
RSA *d2i_RSA_PUBKEY(RSA **, const unsigned char **, long);
RSA *d2i_RSAPublicKey(RSA **, const unsigned char **, long);
RSA *d2i_RSAPrivateKey(RSA **, const unsigned char **, long);
int i2d_DSA_PUBKEY(DSA *, unsigned char **);
DSA *d2i_DSA_PUBKEY(DSA **, const unsigned char **, long);
DSA *d2i_DSAPublicKey(DSA **, const unsigned char **, long);
DSA *d2i_DSAPrivateKey(DSA **, const unsigned char **, long);
RSA *d2i_RSAPrivateKey_bio(BIO *, RSA **);
int i2d_RSAPrivateKey_bio(BIO *, RSA *);
RSA *d2i_RSAPublicKey_bio(BIO *, RSA **);
int i2d_RSAPublicKey_bio(BIO *, RSA *);
RSA *d2i_RSA_PUBKEY_bio(BIO *, RSA **);
int i2d_RSA_PUBKEY_bio(BIO *, RSA *);
DSA *d2i_DSA_PUBKEY_bio(BIO *, DSA **);
int i2d_DSA_PUBKEY_bio(BIO *, DSA *);
DSA *d2i_DSAPrivateKey_bio(BIO *, DSA **);
int i2d_DSAPrivateKey_bio(BIO *, DSA *);
"""
MACROS = """
long X509_get_version(X509 *);
ASN1_TIME *X509_get_notBefore(X509 *);
ASN1_TIME *X509_get_notAfter(X509 *);
long X509_REQ_get_version(X509_REQ *);
X509_NAME *X509_REQ_get_subject_name(X509_REQ *);
Cryptography_STACK_OF_X509 *sk_X509_new_null(void);
void sk_X509_free(Cryptography_STACK_OF_X509 *);
int sk_X509_num(Cryptography_STACK_OF_X509 *);
int sk_X509_push(Cryptography_STACK_OF_X509 *, X509 *);
X509 *sk_X509_value(Cryptography_STACK_OF_X509 *, int);
X509_EXTENSIONS *sk_X509_EXTENSION_new_null(void);
int sk_X509_EXTENSION_num(X509_EXTENSIONS *);
X509_EXTENSION *sk_X509_EXTENSION_value(X509_EXTENSIONS *, int);
int sk_X509_EXTENSION_push(X509_EXTENSIONS *, X509_EXTENSION *);
X509_EXTENSION *sk_X509_EXTENSION_delete(X509_EXTENSIONS *, int);
void sk_X509_EXTENSION_free(X509_EXTENSIONS *);
int sk_X509_REVOKED_num(Cryptography_STACK_OF_X509_REVOKED *);
X509_REVOKED *sk_X509_REVOKED_value(Cryptography_STACK_OF_X509_REVOKED *, int);
int i2d_RSAPublicKey(RSA *, unsigned char **);
int i2d_RSAPrivateKey(RSA *, unsigned char **);
int i2d_DSAPublicKey(DSA *, unsigned char **);
int i2d_DSAPrivateKey(DSA *, unsigned char **);
/* These aren't macros these arguments are all const X on openssl > 1.0.x */
int X509_CRL_set_lastUpdate(X509_CRL *, ASN1_TIME *);
int X509_CRL_set_nextUpdate(X509_CRL *, ASN1_TIME *);
/* These use STACK_OF(X509_EXTENSION) in 0.9.8e. Once we drop support for
RHEL/CentOS 5 we should move these back to FUNCTIONS. */
int X509_REQ_add_extensions(X509_REQ *, X509_EXTENSIONS *);
X509_EXTENSIONS *X509_REQ_get_extensions(X509_REQ *);
int i2d_EC_PUBKEY(EC_KEY *, unsigned char **);
EC_KEY *d2i_EC_PUBKEY(EC_KEY **, const unsigned char **, long);
EC_KEY *d2i_EC_PUBKEY_bio(BIO *, EC_KEY **);
int i2d_EC_PUBKEY_bio(BIO *, EC_KEY *);
EC_KEY *d2i_ECPrivateKey_bio(BIO *, EC_KEY **);
int i2d_ECPrivateKey_bio(BIO *, EC_KEY *);
"""
CUSTOMIZATIONS = """
/* OpenSSL 0.9.8e does not have this definition. */
#if OPENSSL_VERSION_NUMBER <= 0x0090805fL
typedef STACK_OF(X509_EXTENSION) X509_EXTENSIONS;
#endif
#ifdef OPENSSL_NO_EC
int (*i2d_EC_PUBKEY)(EC_KEY *, unsigned char **) = NULL;
EC_KEY *(*d2i_EC_PUBKEY)(EC_KEY **, const unsigned char **, long) = NULL;
EC_KEY *(*d2i_EC_PUBKEY_bio)(BIO *, EC_KEY **) = NULL;
int (*i2d_EC_PUBKEY_bio)(BIO *, EC_KEY *) = NULL;
EC_KEY *(*d2i_ECPrivateKey_bio)(BIO *, EC_KEY **) = NULL;
int (*i2d_ECPrivateKey_bio)(BIO *, EC_KEY *) = NULL;
#endif
"""
CONDITIONAL_NAMES = {
"Cryptography_HAS_EC": [
"i2d_EC_PUBKEY",
"d2i_EC_PUBKEY",
"d2i_EC_PUBKEY_bio",
"i2d_EC_PUBKEY_bio",
"d2i_ECPrivateKey_bio",
"i2d_ECPrivateKey_bio",
]
}
| 32.69434 | 79 | 0.750231 |
139c1194b740529de6db76e65802d38041fcdca6 | 9,855 | py | Python | sdk/python/pulumi_azure_nextgen/network/v20171001/express_route_circuit_authorization.py | pulumi/pulumi-azure-nextgen | 452736b0a1cf584c2d4c04666e017af6e9b2c15c | [
"Apache-2.0"
] | 31 | 2020-09-21T09:41:01.000Z | 2021-02-26T13:21:59.000Z | sdk/python/pulumi_azure_nextgen/network/v20171001/express_route_circuit_authorization.py | pulumi/pulumi-azure-nextgen | 452736b0a1cf584c2d4c04666e017af6e9b2c15c | [
"Apache-2.0"
] | 231 | 2020-09-21T09:38:45.000Z | 2021-03-01T11:16:03.000Z | sdk/python/pulumi_azure_nextgen/network/v20171001/express_route_circuit_authorization.py | pulumi/pulumi-azure-nextgen | 452736b0a1cf584c2d4c04666e017af6e9b2c15c | [
"Apache-2.0"
] | 4 | 2020-09-29T14:14:59.000Z | 2021-02-10T20:38:16.000Z | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union
from ... import _utilities, _tables
from ._enums import *
__all__ = ['ExpressRouteCircuitAuthorization']
class ExpressRouteCircuitAuthorization(pulumi.CustomResource):
def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
authorization_key: Optional[pulumi.Input[str]] = None,
authorization_name: Optional[pulumi.Input[str]] = None,
authorization_use_status: Optional[pulumi.Input[Union[str, 'AuthorizationUseStatus']]] = None,
circuit_name: Optional[pulumi.Input[str]] = None,
id: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
provisioning_state: Optional[pulumi.Input[str]] = None,
resource_group_name: Optional[pulumi.Input[str]] = None,
__props__=None,
__name__=None,
__opts__=None):
"""
Authorization in an ExpressRouteCircuit resource.
:param str resource_name: The name of the resource.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[str] authorization_key: The authorization key.
:param pulumi.Input[str] authorization_name: The name of the authorization.
:param pulumi.Input[Union[str, 'AuthorizationUseStatus']] authorization_use_status: AuthorizationUseStatus. Possible values are: 'Available' and 'InUse'.
:param pulumi.Input[str] circuit_name: The name of the express route circuit.
:param pulumi.Input[str] id: Resource ID.
:param pulumi.Input[str] name: Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
:param pulumi.Input[str] provisioning_state: Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
:param pulumi.Input[str] resource_group_name: The name of the resource group.
"""
if __name__ is not None:
warnings.warn("explicit use of __name__ is deprecated", DeprecationWarning)
resource_name = __name__
if __opts__ is not None:
warnings.warn("explicit use of __opts__ is deprecated, use 'opts' instead", DeprecationWarning)
opts = __opts__
if opts is None:
opts = pulumi.ResourceOptions()
if not isinstance(opts, pulumi.ResourceOptions):
raise TypeError('Expected resource options to be a ResourceOptions instance')
if opts.version is None:
opts.version = _utilities.get_version()
if opts.id is None:
if __props__ is not None:
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = dict()
__props__['authorization_key'] = authorization_key
__props__['authorization_name'] = authorization_name
__props__['authorization_use_status'] = authorization_use_status
if circuit_name is None and not opts.urn:
raise TypeError("Missing required property 'circuit_name'")
__props__['circuit_name'] = circuit_name
__props__['id'] = id
__props__['name'] = name
__props__['provisioning_state'] = provisioning_state
if resource_group_name is None and not opts.urn:
raise TypeError("Missing required property 'resource_group_name'")
__props__['resource_group_name'] = resource_group_name
__props__['etag'] = None
alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="azure-nextgen:network:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/latest:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20150501preview:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20150615:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20160330:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20160601:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20160901:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20161201:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20170301:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20170601:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20170801:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20170901:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20171101:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20180101:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20180201:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20180401:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20180601:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20180701:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20180801:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20181001:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20181101:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20181201:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20190201:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20190401:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20190601:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20190701:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20190801:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20190901:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20191101:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20191201:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20200301:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20200401:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20200501:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20200601:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20200701:ExpressRouteCircuitAuthorization"), pulumi.Alias(type_="azure-nextgen:network/v20200801:ExpressRouteCircuitAuthorization")])
opts = pulumi.ResourceOptions.merge(opts, alias_opts)
super(ExpressRouteCircuitAuthorization, __self__).__init__(
'azure-nextgen:network/v20171001:ExpressRouteCircuitAuthorization',
resource_name,
__props__,
opts)
@staticmethod
def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None) -> 'ExpressRouteCircuitAuthorization':
"""
Get an existing ExpressRouteCircuitAuthorization resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = dict()
return ExpressRouteCircuitAuthorization(resource_name, opts=opts, __props__=__props__)
@property
@pulumi.getter(name="authorizationKey")
def authorization_key(self) -> pulumi.Output[Optional[str]]:
"""
The authorization key.
"""
return pulumi.get(self, "authorization_key")
@property
@pulumi.getter(name="authorizationUseStatus")
def authorization_use_status(self) -> pulumi.Output[Optional[str]]:
"""
AuthorizationUseStatus. Possible values are: 'Available' and 'InUse'.
"""
return pulumi.get(self, "authorization_use_status")
@property
@pulumi.getter
def etag(self) -> pulumi.Output[str]:
"""
A unique read-only string that changes whenever the resource is updated.
"""
return pulumi.get(self, "etag")
@property
@pulumi.getter
def name(self) -> pulumi.Output[Optional[str]]:
"""
Gets name of the resource that is unique within a resource group. This name can be used to access the resource.
"""
return pulumi.get(self, "name")
@property
@pulumi.getter(name="provisioningState")
def provisioning_state(self) -> pulumi.Output[Optional[str]]:
"""
Gets the provisioning state of the public IP resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
"""
return pulumi.get(self, "provisioning_state")
def translate_output_property(self, prop):
return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
def translate_input_property(self, prop):
return _tables.SNAKE_TO_CAMEL_CASE_TABLE.get(prop) or prop
| 67.5 | 3,215 | 0.725723 |
e393478ab801c3aab9cb8a7c4d13744e2e0a2e6c | 2,037 | py | Python | ProjectApplication/grant_management/migrations/0053_add_file_validator.py | code-review-doctor/project-application | d85b40b69572efbcda24ce9c40803f76d8ffd192 | [
"MIT"
] | 5 | 2020-07-29T10:00:11.000Z | 2022-02-19T11:00:34.000Z | ProjectApplication/grant_management/migrations/0053_add_file_validator.py | code-review-doctor/project-application | d85b40b69572efbcda24ce9c40803f76d8ffd192 | [
"MIT"
] | 471 | 2019-09-20T14:37:28.000Z | 2022-03-25T14:16:34.000Z | ProjectApplication/grant_management/migrations/0053_add_file_validator.py | code-review-doctor/project-application | d85b40b69572efbcda24ce9c40803f76d8ffd192 | [
"MIT"
] | 5 | 2020-03-15T12:42:47.000Z | 2022-02-15T18:06:52.000Z | # Generated by Django 3.0.10 on 2020-09-21 10:38
from django.db import migrations, models
import grant_management.models
import project_core.utils.utils
import storages.backends.s3boto3
class Migration(migrations.Migration):
dependencies = [
('grant_management', '0052_invoice_allow_overbudget_by_can_be_blank'),
]
operations = [
migrations.AlterField(
model_name='financialreport',
name='file',
field=models.FileField(blank=True, null=True, storage=storages.backends.s3boto3.S3Boto3Storage(), upload_to=grant_management.models.finance_report_file_rename, validators=[*project_core.utils.utils.management_file_validator()]),
),
migrations.AlterField(
model_name='grantagreement',
name='file',
field=models.FileField(storage=storages.backends.s3boto3.S3Boto3Storage(), upload_to=grant_management.models.grant_agreement_file_rename, validators=[*project_core.utils.utils.management_file_validator()]),
),
migrations.AlterField(
model_name='invoice',
name='file',
field=models.FileField(blank=True, null=True, storage=storages.backends.s3boto3.S3Boto3Storage(), upload_to=grant_management.models.invoice_file_rename, validators=[*project_core.utils.utils.management_file_validator()]),
),
migrations.AlterField(
model_name='medium',
name='file',
field=models.FileField(storage=storages.backends.s3boto3.S3Boto3Storage(), upload_to=grant_management.models.medium_file_rename, validators=[*project_core.utils.utils.management_file_validator()]),
),
migrations.AlterField(
model_name='scientificreport',
name='file',
field=models.FileField(blank=True, null=True, storage=storages.backends.s3boto3.S3Boto3Storage(), upload_to=grant_management.models.scientific_report_file_rename, validators=[*project_core.utils.utils.management_file_validator()]),
),
]
| 48.5 | 243 | 0.710849 |
4bc1014e99bf4e2d12f399da6695c094b541f218 | 3,172 | py | Python | code.py | NishthaShukla/mutual-fund-returns | 3b84318f14992f00e9ddad0f847c806947f9b862 | [
"MIT"
] | null | null | null | code.py | NishthaShukla/mutual-fund-returns | 3b84318f14992f00e9ddad0f847c806947f9b862 | [
"MIT"
] | null | null | null | code.py | NishthaShukla/mutual-fund-returns | 3b84318f14992f00e9ddad0f847c806947f9b862 | [
"MIT"
] | null | null | null | # --------------
# import libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# Code starts here
data = pd.read_csv(path)
print(data.shape)
print(data.describe())
data.drop(['Serial Number'],inplace=True,axis=1)
# code ends here
# --------------
#Importing header files
from scipy.stats import chi2_contingency
import scipy.stats as stats
#Critical value
critical_value = stats.chi2.ppf(q = 0.95, # Find the critical value for 95% confidence*
df = 11) # Df = number of variable categories(in purpose) - 1
# Code starts here
return_rating = data['morningstar_return_rating'].value_counts()
risk_rating = data['morningstar_risk_rating'].value_counts()
print(return_rating)
print(risk_rating)
observed = pd.concat([return_rating.transpose(),risk_rating.transpose()],keys=['return','risk'],axis=1)
print(observed)
chi2, p, dof, ex = chi2_contingency(observed)
null_hypo = 'Reject' if chi2>critical_value else 'Accept'
# Code ends here
# --------------
# Code starts here
correlation = abs(data.corr())
us_correlation=correlation.unstack()
us_correlation = us_correlation.sort_values(ascending=False)
max_correlated = us_correlation[us_correlation>=0.75]
print(max_correlated)
data = data.drop(columns=['morningstar_rating','portfolio_stocks','category_12','sharpe_ratio_3y'])
# code ends here
# --------------
# Code starts here
import matplotlib.pyplot as plt
bxplt = data.boxplot(column=['price_earning','net_annual_expenses_ratio'])
fig ,ax_1 = plt.subplots()
ax_1.boxplot(data['price_earning'])
ax_1.set_title(data['price_earning'])
fig ,ax_2 = plt.subplots()
ax_2.boxplot(data['net_annual_expenses_ratio'])
ax_2.set_title(data['net_annual_expenses_ratio'])
# code ends here
# --------------
# import libraries
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score,mean_squared_error
# Code starts here
X = data.drop(columns=['bonds_aaa'])
y = data['bonds_aaa']
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.3,random_state = 3)
lr = LinearRegression()
lr.fit(X_train,y_train)
y_pred = lr.predict(X_test)
rmse= np.sqrt(mean_squared_error(y_pred,y_test))
print(rmse)
# Code ends here
# --------------
# import libraries
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.linear_model import Ridge,Lasso
# regularization parameters for grid search
ridge_lambdas = [0.01, 0.03, 0.06, 0.1, 0.3, 0.6, 1, 3, 6, 10, 30, 60]
lasso_lambdas = [0.0001, 0.0003, 0.0006, 0.001, 0.003, 0.006, 0.01, 0.03, 0.06, 0.1, 0.3, 0.6, 1]
# Code starts here
ridge_model = Ridge()
ridge_grid=GridSearchCV(estimator=ridge_model, param_grid=dict(alpha=ridge_lambdas))
ridge_grid.fit(X_train,y_train)
ridge_pred = ridge_grid.predict(X_test)
ridge_rmse = np.sqrt(mean_squared_error(y_test,ridge_pred))
lasso_model = Lasso()
lasso_grid=GridSearchCV(estimator=lasso_model, param_grid=dict(alpha=lasso_lambdas))
lasso_grid.fit(X_train,y_train)
lasso_pred = lasso_grid.predict(X_test)
lasso_rmse = np.sqrt(mean_squared_error(y_test,lasso_pred))
# Code ends here
| 23.849624 | 103 | 0.741173 |
32debd1a9478669bed7b092a1c825313da384209 | 6,913 | py | Python | pyFAI/gui/helper/model_transform.py | yugangzhang/pyFAI | e0453b279dac1f165f637e2a2ed1d4ddf57d31ba | [
"MIT"
] | 1 | 2021-04-28T20:09:13.000Z | 2021-04-28T20:09:13.000Z | pyFAI/gui/helper/model_transform.py | yugangzhang/pyFAI | e0453b279dac1f165f637e2a2ed1d4ddf57d31ba | [
"MIT"
] | null | null | null | pyFAI/gui/helper/model_transform.py | yugangzhang/pyFAI | e0453b279dac1f165f637e2a2ed1d4ddf57d31ba | [
"MIT"
] | null | null | null | # coding: utf-8
# /*##########################################################################
#
# Copyright (c) 2017-2018 European Synchrotron Radiation Facility
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# ###########################################################################*/
"""Helper to transform or extract information from the abstratc model.
"""
from __future__ import division
__authors__ = ["V. Valls"]
__license__ = "MIT"
import numpy
from pyFAI.control_points import ControlPoints
from pyFAI.gui.model.CalibrationModel import CalibrationModel
from pyFAI.gui.model.PeakSelectionModel import PeakSelectionModel
from pyFAI.gui.model.PeakModel import PeakModel
from pyFAI.gui.CalibrationContext import CalibrationContext
def createControlPoints(model):
"""Create ControlPoints object from the calibration model
:rtype: pyFAI.control_points.ControlPoints
"""
if not isinstance(model, CalibrationModel):
raise TypeError("Unexpected model type")
calibrant = model.experimentSettingsModel().calibrantModel().calibrant()
wavelength = model.experimentSettingsModel().wavelength().value()
controlPoints = ControlPoints(calibrant=calibrant, wavelength=wavelength)
for peakModel in model.peakSelectionModel():
if not peakModel.isEnabled():
continue
ringNumber = peakModel.ringNumber() - 1
points = peakModel.coords().tolist()
controlPoints.append(points=points, ring=ringNumber)
return controlPoints
def createPeaksArray(model):
"""Create a contiguous peak array containing (y, x, ring number)
:param PeakSelectionModel model: A set of selected peaks
:rtype: numpy.ndarray
"""
if not isinstance(model, PeakSelectionModel):
raise TypeError("Unexpected model type")
count = 0
for group in model:
count += len(group)
pos = 0
peaks = numpy.empty(shape=(count, 3), dtype=float)
for group in model:
if not group.isEnabled():
continue
end = pos + len(group)
peaks[pos:end, 0:2] = group.coords()
peaks[pos:end, 2] = group.ringNumber() - 1
pos = end
peaks = numpy.array(peaks)
return peaks
def filterControlPoints(filterCallback, peakSelectionModel, removedPeaks=None):
"""Filter each peaks of the model using a callback
:param Callable[int,int,bool] filter: Filter returning true is the
peak have to stay in the result.
:param PeakSelectionModel peakSelectionModel: Model to filter
:param List[Tuple[int,int]] removedPeaks: Provide a list to feed it with
removed peaks from the model.
"""
peakSelectionModel.lockSignals()
for peakGroup in peakSelectionModel:
changed = False
newCoords = []
for coord in peakGroup.coords():
if filterCallback(coord[0], coord[1]):
newCoords.append(coord)
else:
if removedPeaks is not None:
removedPeaks.append(coord)
changed = True
if changed:
if len(newCoords) == 0:
newCoords = numpy.empty(shape=(0, 2))
else:
newCoords = numpy.array(newCoords)
peakGroup.setCoords(newCoords)
peakSelectionModel.unlockSignals()
def _findUnusedName(peakSelectionModel):
"""
:rtype: str
"""
names = ["% 8s" % p.name() for p in peakSelectionModel]
if len(names) > 0:
names = list(sorted(names))
bigger = names[-1].strip()
number = 0
for c in bigger:
number = number * 26 + (ord(c) - ord('a'))
else:
number = -1
number = number + 1
# compute the next one
name = ""
if number == 0:
name = "a"
else:
n = number
while n > 0:
c = n % 26
n = n // 26
name = chr(c + ord('a')) + name
return name
def createRing(points, peakSelectionModel, ringNumber=None, context=None):
"""Create a new ring from a group of points
:rtype: PeakModel
"""
if context is None:
context = CalibrationContext.instance()
name = _findUnusedName(peakSelectionModel)
if ringNumber is None:
ringNumber = 1
color = context.getMarkerColor(ringNumber - 1)
peakModel = PeakModel(peakSelectionModel)
peakModel.setName(name)
peakModel.setColor(color)
peakModel.setCoords(points)
peakModel.setRingNumber(ringNumber)
return peakModel
def initPeaksFromControlPoints(peakSelectionModel, controlPoints, context=None):
"""Initialize peak selection model using control points object
:rtype: pyFAI.control_points.ControlPoints
"""
if not isinstance(peakSelectionModel, PeakSelectionModel):
raise TypeError("Unexpected model type")
if not isinstance(controlPoints, ControlPoints):
raise TypeError("Unexpected model type")
if context is None:
context = CalibrationContext.instance()
peakSelectionModel.clear()
for label in controlPoints.get_labels():
group = controlPoints.get(lbl=label)
color = context.getMarkerColor(group.ring)
points = numpy.array(group.points)
peakModel = createRing(points, peakSelectionModel=peakSelectionModel, context=context)
peakModel.setRingNumber(group.ring + 1)
peakModel.setColor(color)
peakModel.setName(label)
peakSelectionModel.append(peakModel)
def geometryModelToGeometry(geometryModel, geometry):
geometry.dist = geometryModel.distance().value()
geometry.poni1 = geometryModel.poni1().value()
geometry.poni2 = geometryModel.poni2().value()
geometry.rot1 = geometryModel.rotation1().value()
geometry.rot2 = geometryModel.rotation2().value()
geometry.rot3 = geometryModel.rotation3().value()
geometry.wavelength = geometryModel.wavelength().value()
| 34.393035 | 94 | 0.668595 |
1b7e558027ef75b54ff9b1627f86911820ba8a24 | 5,971 | py | Python | test/functional/rpc_users.py | ekkakon/vpcpos | 4a6fb8ca0220baaaf3cc3bc6bcfc3c1218a931a8 | [
"MIT"
] | null | null | null | test/functional/rpc_users.py | ekkakon/vpcpos | 4a6fb8ca0220baaaf3cc3bc6bcfc3c1218a931a8 | [
"MIT"
] | null | null | null | test/functional/rpc_users.py | ekkakon/vpcpos | 4a6fb8ca0220baaaf3cc3bc6bcfc3c1218a931a8 | [
"MIT"
] | null | null | null | #!/usr/bin/env python3
# Copyright (c) 2015-2017 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Test multiple RPC users."""
from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import str_to_b64str, assert_equal
import os
import http.client
import urllib.parse
class HTTPBasicsTest (BitcoinTestFramework):
def set_test_params(self):
self.num_nodes = 2
def setup_chain(self):
super().setup_chain()
#Append rpcauth to bitcoin.conf before initialization
rpcauth = "rpcauth=rt:93648e835a54c573682c2eb19f882535$7681e9c5b74bdd85e78166031d2058e1069b3ed7ed967c93fc63abba06f31144"
rpcauth2 = "rpcauth=rt2:f8607b1a88861fac29dfccf9b52ff9f$ff36a0c23c8c62b4846112e50fa888416e94c17bfd4c42f88fd8f55ec6a3137e"
rpcuser = "rpcuser=rpcuser�"
rpcpassword = "rpcpassword=rpcpassword�"
with open(os.path.join(self.options.tmpdir+"/node0", "voltpotcoin.conf"), 'a', encoding='utf8') as f:
f.write(rpcauth+"\n")
f.write(rpcauth2+"\n")
with open(os.path.join(self.options.tmpdir+"/node1", "voltpotcoin.conf"), 'a', encoding='utf8') as f:
f.write(rpcuser+"\n")
f.write(rpcpassword+"\n")
def run_test(self):
##################################################
# Check correctness of the rpcauth config option #
##################################################
url = urllib.parse.urlparse(self.nodes[0].url)
#Old authpair
authpair = url.username + ':' + url.password
#New authpair generated via share/rpcuser tool
password = "cA773lm788buwYe4g4WT+05pKyNruVKjQ25x3n0DQcM="
#Second authpair with different username
password2 = "8/F3uMDw4KSEbw96U3CA1C4X05dkHDN2BPFjTgZW4KI="
authpairnew = "rt:"+password
headers = {"Authorization": "Basic " + str_to_b64str(authpair)}
conn = http.client.HTTPConnection(url.hostname, url.port)
conn.connect()
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
resp = conn.getresponse()
assert_equal(resp.status, 200)
conn.close()
#Use new authpair to confirm both work
headers = {"Authorization": "Basic " + str_to_b64str(authpairnew)}
conn = http.client.HTTPConnection(url.hostname, url.port)
conn.connect()
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
resp = conn.getresponse()
assert_equal(resp.status, 200)
conn.close()
#Wrong login name with rt's password
authpairnew = "rtwrong:"+password
headers = {"Authorization": "Basic " + str_to_b64str(authpairnew)}
conn = http.client.HTTPConnection(url.hostname, url.port)
conn.connect()
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
resp = conn.getresponse()
assert_equal(resp.status, 401)
conn.close()
#Wrong password for rt
authpairnew = "rt:"+password+"wrong"
headers = {"Authorization": "Basic " + str_to_b64str(authpairnew)}
conn = http.client.HTTPConnection(url.hostname, url.port)
conn.connect()
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
resp = conn.getresponse()
assert_equal(resp.status, 401)
conn.close()
#Correct for rt2
authpairnew = "rt2:"+password2
headers = {"Authorization": "Basic " + str_to_b64str(authpairnew)}
conn = http.client.HTTPConnection(url.hostname, url.port)
conn.connect()
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
resp = conn.getresponse()
assert_equal(resp.status, 200)
conn.close()
#Wrong password for rt2
authpairnew = "rt2:"+password2+"wrong"
headers = {"Authorization": "Basic " + str_to_b64str(authpairnew)}
conn = http.client.HTTPConnection(url.hostname, url.port)
conn.connect()
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
resp = conn.getresponse()
assert_equal(resp.status, 401)
conn.close()
###############################################################
# Check correctness of the rpcuser/rpcpassword config options #
###############################################################
url = urllib.parse.urlparse(self.nodes[1].url)
# rpcuser and rpcpassword authpair
rpcuserauthpair = "rpcuser�:rpcpassword�"
headers = {"Authorization": "Basic " + str_to_b64str(rpcuserauthpair)}
conn = http.client.HTTPConnection(url.hostname, url.port)
conn.connect()
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
resp = conn.getresponse()
assert_equal(resp.status, 200)
conn.close()
#Wrong login name with rpcuser's password
rpcuserauthpair = "rpcuserwrong:rpcpassword"
headers = {"Authorization": "Basic " + str_to_b64str(rpcuserauthpair)}
conn = http.client.HTTPConnection(url.hostname, url.port)
conn.connect()
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
resp = conn.getresponse()
assert_equal(resp.status, 401)
conn.close()
#Wrong password for rpcuser
rpcuserauthpair = "rpcuser:rpcpasswordwrong"
headers = {"Authorization": "Basic " + str_to_b64str(rpcuserauthpair)}
conn = http.client.HTTPConnection(url.hostname, url.port)
conn.connect()
conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
resp = conn.getresponse()
assert_equal(resp.status, 401)
conn.close()
if __name__ == '__main__':
HTTPBasicsTest ().main ()
| 38.772727 | 129 | 0.614637 |
eceba1404a6734948c0692324e9b3b42dafa15c8 | 4,000 | py | Python | Turbulence_analysis/yt_post_scrape_common.py | AspdenGroup/PeleAnalysis_Aspden | 4259efa97a65a646a4e1bc3493cd9dae1e7024c5 | [
"BSD-3-Clause-LBNL"
] | 4 | 2019-04-24T13:33:35.000Z | 2021-08-24T07:11:22.000Z | Turbulence_analysis/yt_post_scrape_common.py | AspdenGroup/PeleAnalysis_Aspden | 4259efa97a65a646a4e1bc3493cd9dae1e7024c5 | [
"BSD-3-Clause-LBNL"
] | 4 | 2020-02-25T01:58:46.000Z | 2022-02-01T20:22:49.000Z | Turbulence_analysis/yt_post_scrape_common.py | AspdenGroup/PeleAnalysis_Aspden | 4259efa97a65a646a4e1bc3493cd9dae1e7024c5 | [
"BSD-3-Clause-LBNL"
] | 6 | 2018-11-05T11:53:20.000Z | 2021-03-22T10:44:54.000Z | ################################################################
################################################################
####
#### Post Processing for HIT Simulations
####
#### Authors: Emmanuel Motheau and John Wakefield
#### Last Edited: May 10, 2018
####
#### Written for Python 3.
####
####
################################################################
################################################################
#### Imports
from functools import partial
from functools import reduce
import yt
import numpy as np
#TODO: migrate to ic.txt or elsewhere
gamma = 1.4
#### Disambiguate Fields
def find_temp(l):
for f in l:
if "temp" in f[1].lower():
temp_field = f[1]
print("Found temperature field named '{}'.".format(temp_field))
return f[1]
raise Exception("Temperature field not found.")
#### Helper functions
# Read ic.txt, put values in dictionary
def load_dim_consts(rootdir):
text_file = open(rootdir + '/ic.txt', 'r')
lines = text_file.read().replace(' ', '').split('\n')
headings = lines[0].split(',')
vals = map(float, lines[1].split(','))
text_file.close()
return dict(zip(headings, vals))
# Compute magnitude of field
def mag_sq_func(data_list):
return reduce(
lambda a, b: a + b,
map(lambda c: c**2, data_list)
)
def mag_func(data_list):
return np.sqrt(mag_sq_func(data_list))
# Compute kinetic energy
def kin_energy_func(field, data):
return mag_sq_func([
data['boxlib', 'x_velocity'],
data['boxlib', 'y_velocity'],
data['boxlib', 'z_velocity']
])
# Compute vorticity
def magvort_sq_func(field, data):
return data['boxlib', 'magvort'] * data['boxlib', 'magvort']
def vort_x_func(field, data):
return (
+ data['boxlib', 'z_velocity_gradient_y']
- data['boxlib', 'y_velocity_gradient_z']
)
def vort_y_func(field, data):
return (
- data['boxlib', 'z_velocity_gradient_x']
+ data['boxlib', 'x_velocity_gradient_z']
)
def vort_z_func(field, data):
return (
+ data['boxlib', 'y_velocity_gradient_x']
- data['boxlib', 'x_velocity_gradient_y']
)
def vort_mag_func(field, data):
return mag_func([
data['boxlib', 'z_velocity_gradient_y']
- data['boxlib', 'y_velocity_gradient_z'],
- data['boxlib', 'z_velocity_gradient_x']
+ data['boxlib', 'x_velocity_gradient_z'],
data['boxlib', 'y_velocity_gradient_x']
- data['boxlib', 'x_velocity_gradient_y']
])
def vort_mag_sq_func(field, data):
return mag_sq_func([
data['boxlib', 'z_velocity_gradient_y']
- data['boxlib', 'y_velocity_gradient_z'],
- data['boxlib', 'z_velocity_gradient_x']
+ data['boxlib', 'x_velocity_gradient_z'],
data['boxlib', 'y_velocity_gradient_x']
- data['boxlib', 'x_velocity_gradient_y']
])
# Compute dilatation
def divu_sq_func(field, data):
return data['boxlib', 'divu'] * data['boxlib', 'divu']
def dilatation_func(field, data):
return (
data['boxlib', 'x_velocity_gradient_x'] +
data['boxlib', 'y_velocity_gradient_y'] +
data['boxlib', 'z_velocity_gradient_z']
)
def dilatation_sq_func(field, data):
return (
data['boxlib', 'x_velocity_gradient_x'] +
data['boxlib', 'y_velocity_gradient_y'] +
data['boxlib', 'z_velocity_gradient_z']
)**2
# Compute temperature variation
def get_temp_var_func(avg, temp_field):
def func(field, data):
return data['boxlib', temp_field] - avg
return func
def get_temp_var_sq_func(avg, temp_field):
def func(field, data):
return (data['boxlib', temp_field] - avg)**2
return func
# Transpose Lists
def transpose(l):
m = [[x] for x in l[0]]
for s in l[1:]:
for k, x in enumerate(s):
m[k] += [x]
return m
| 28.169014 | 75 | 0.56875 |
7380f437e509b6de3a9c6820075a746b995fd4ab | 755 | py | Python | pp/test/test_import_gds_markers.py | flaport/gdsfactory | 1f2e844c1fe27b9c6340e2d51500fd3358fa16e5 | [
"MIT"
] | 8 | 2020-08-25T11:25:18.000Z | 2022-03-27T11:32:11.000Z | pp/test/test_import_gds_markers.py | flaport/gdsfactory | 1f2e844c1fe27b9c6340e2d51500fd3358fa16e5 | [
"MIT"
] | null | null | null | pp/test/test_import_gds_markers.py | flaport/gdsfactory | 1f2e844c1fe27b9c6340e2d51500fd3358fa16e5 | [
"MIT"
] | 1 | 2022-03-04T07:03:29.000Z | 2022-03-04T07:03:29.000Z | import pytest
import pp
from pp.import_gds import add_ports_from_markers_center, import_gds
from pp.port import auto_rename_ports
gdspaths = [pp.CONFIG["gdsdir"] / name for name in ["mmi1x2.gds", "mzi2x2.gds"]]
@pytest.mark.parametrize("gdspath", gdspaths)
def test_components_ports(gdspath, num_regression):
c = import_gds(gdspath)
add_ports_from_markers_center(c)
auto_rename_ports(c)
num_regression.check(c.get_ports_array())
if __name__ == "__main__":
c = import_gds(gdspaths[0])
add_ports_from_markers_center(c)
auto_rename_ports(c)
print(c.ports.keys())
print(c.name)
c = import_gds(gdspaths[1])
add_ports_from_markers_center(c)
auto_rename_ports(c)
print(c.ports.keys())
print(c.name)
| 25.166667 | 80 | 0.73245 |
cd1ba78aa7ffb08947488f81b9af0e94624f161c | 3,565 | py | Python | cooked_input/examples/events.py | lwanger/cooked_input | 5125f3c9253c3b67959327684b3fbd1008b057f9 | [
"MIT"
] | 16 | 2017-06-23T17:53:39.000Z | 2019-09-13T17:36:36.000Z | cooked_input/examples/events.py | lwanger/cooked_input | 5125f3c9253c3b67959327684b3fbd1008b057f9 | [
"MIT"
] | 10 | 2018-05-21T14:08:23.000Z | 2021-10-04T10:54:23.000Z | cooked_input/examples/events.py | lwanger/cooked_input | 5125f3c9253c3b67959327684b3fbd1008b057f9 | [
"MIT"
] | 2 | 2018-05-21T12:07:37.000Z | 2018-06-04T10:11:25.000Z | """
This is a simple event list manager showing cooked_input menus, tables, and commands.
Len Wanger, 2019
"""
from collections import namedtuple
import cooked_input as ci
EventType = namedtuple('EventType', 'id name desc')
Event = namedtuple('Event', 'id date desc type')
event_types = [
EventType(1, 'birthday' ,'a birthday event'),
EventType(2, 'anniversary' ,'an anniversary event'),
EventType(3, 'meeting', 'a meeting event')
]
events = []
def help_cmd_action(cmd_str, cmd_vars, cmd_dict):
help_str = """
Commands:
/?, /help Display this help message
/cancel Cancel the current operation
"""
print(help_str)
return ci.CommandResponse(ci.COMMAND_ACTION_NOP, None)
def cancel_cmd_action(cmd_str, cmd_vars, cmd_dict):
if ci.get_yes_no(prompt='Are you sure you want to cancel?', default='no') == 'yes':
print('\nCommand cancelled...')
return ci.CommandResponse(ci.COMMAND_ACTION_CANCEL, None)
else:
return ci.CommandResponse(ci.COMMAND_ACTION_NOP, None)
def exit_cmd_action(cmd_str, cmd_vars, cmd_dict):
return ci.CommandResponse(ci.COMMAND_ACTION_EXIT, None)
help_cmd = ci.GetInputCommand(help_cmd_action)
cancel_cmd = ci.GetInputCommand(cancel_cmd_action)
app_cmds = {'/?': help_cmd, '/h': help_cmd, '/cancel': cancel_cmd}
def reset_db_action(row, action_item):
cmds = action_dict['commands']
if ci.get_yes_no(prompt='Delete all events? ', default='no', commands=cmds) == 'yes':
action_dict['events'] = []
def add_event_action(row, action_item):
events = action_dict['events']
event_types = action_dict['event_types']
cmds = action_dict['commands']
desc = ci.get_string(prompt="Event description? ", commands=cmds)
tbl = ci.create_table(event_types, ["name", "desc"], ["Name", "Desc"], add_item_to_item_data=True)
event_type = tbl.get_table_choice(prompt='Type? ', commands=cmds)
date = ci.get_date(prompt='Date? ', default='today', commands=cmds)
type_id = event_type.item_data['item'].id
events.append(Event(len(events)+1, date, desc, type_id))
def list_event_action(row, action_item):
events = action_dict['events']
event_types = action_dict['event_types']
if len(events) == 0:
print('\nno events\n')
return
et_dict = {item.id: item.name for item in event_types}
items = []
for e in events:
date = e.date.strftime('%x')
etype = et_dict[e.type]
items.append({'id': e.id, 'date': date, 'desc': e.desc, 'type': etype})
fields = ['date', 'desc', 'type']
field_names = ['Date', 'Desc', 'Type']
tbl = ci.create_table(items, fields, field_names, title='Events')
print('\n')
tbl.show_table()
print('\n')
def db_submenu_action(row, action_item):
style = action_dict['menu_style']
items = [ ci.TableItem('Delete all events', action=reset_db_action) ]
menu = ci.Table(rows=items, add_exit=ci.TABLE_ADD_RETURN, style=style, action_dict=action_dict)
menu.run()
if __name__ == '__main__':
style = ci.TableStyle(show_cols=False, show_border=False)
action_dict = { 'events': events, 'event_types': event_types, 'commands': app_cmds, 'style': style }
items = [
ci.TableItem('Add an event', action=add_event_action),
ci.TableItem('List events', action=list_event_action),
ci.TableItem('Database submenu', action=db_submenu_action)
]
menu = ci.Table(rows=items, add_exit=ci.TABLE_ADD_EXIT, style=style, action_dict=action_dict)
menu.run() | 36.377551 | 104 | 0.674053 |
34cac95b258ee160be11157680f1b547801b6cb0 | 3,608 | py | Python | models/suggestion.py | pordonj/the-blue-alliance | d5874bf760391436f0c7ff579fc4f7c88aafea87 | [
"MIT"
] | 1 | 2016-03-19T20:29:35.000Z | 2016-03-19T20:29:35.000Z | models/suggestion.py | gregmarra/the-blue-alliance | 5bedaf5c80b4623984760d3da3289640639112f9 | [
"MIT"
] | 11 | 2020-10-10T03:05:29.000Z | 2022-02-27T09:57:22.000Z | models/suggestion.py | gregmarra/the-blue-alliance | 5bedaf5c80b4623984760d3da3289640639112f9 | [
"MIT"
] | null | null | null | import json
from google.appengine.ext import ndb
from helpers.suggestions.media_creator import MediaCreator
from models.account import Account
from models.media import Media
class Suggestion(ndb.Model):
"""
Suggestions are generic containers for user-submitted data corrections to
the site. The generally store a model, a key, and then a json blob of
fields to append or ammend in the model.
"""
MODELS = {"event", "match", "media", "social-media", "offseason-event", "api_auth_access",
"robot", "event_media"}
MODEL_NAMES = {
"event": "Webcasts",
"match": "Match Videos",
"media": "Team Media",
"social-media": "Social Media",
"offseason-event": "Offseason Events",
"api_auth_access": "API Key Requests",
"robot": "CAD Models",
"event_media": "Event Videos"
}
# social-media is a Media with no year
# offseason-event is for new events (opposed to 'event' for adding webcasts to existing events)
REVIEW_ACCEPTED = 1
REVIEW_PENDING = 0
REVIEW_REJECTED = -1
REVIEW_AUTOREJECTED = -2
review_state = ndb.IntegerProperty(default=0)
reviewed_at = ndb.DateTimeProperty()
reviewer = ndb.KeyProperty(kind=Account)
author = ndb.KeyProperty(kind=Account, required=True)
contents_json = ndb.TextProperty(indexed=False) # a json blob
target_key = ndb.StringProperty() # "2012cmp"
target_model = ndb.StringProperty(choices=MODELS, required=True) # "event"
created = ndb.DateTimeProperty(auto_now_add=True, indexed=False)
updated = ndb.DateTimeProperty(auto_now=True, indexed=False)
def __init__(self, *args, **kw):
self._contents = None
super(Suggestion, self).__init__(*args, **kw)
def put(self, *args, **kwargs):
if self.review_state == 0:
user = self.author.get()
if user and user.shadow_banned:
self.review_state = self.REVIEW_AUTOREJECTED
return super(Suggestion, self).put(*args, **kwargs)
@property
def contents(self):
"""
Lazy load contents_json
"""
if self._contents is None:
self._contents = json.loads(self.contents_json)
return self._contents
@contents.setter
def contents(self, contents):
self._contents = contents
self.contents_json = json.dumps(self._contents)
@property
def candidate_media(self):
team_reference = Media.create_reference(
self.contents['reference_type'],
self.contents['reference_key'])
return MediaCreator.create_media_model(self, team_reference)
@property
def youtube_video(self):
if "youtube_videos" in self.contents:
return self.contents["youtube_videos"][0]
@classmethod
def render_media_key_name(cls, year, target_model, target_key, foreign_type, foreign_key):
"""
Keys aren't required for this model. This is only necessary if checking
for duplicate suggestions is desired.
"""
return 'media_{}_{}_{}_{}_{}'.format(year, target_model, target_key, foreign_type, foreign_key)
@classmethod
def render_webcast_key_name(cls, event_key, webcast_dict):
"""
Keys aren't required for this model. This is only necessary if checking
for duplicate suggestions is desired.
"""
return 'webcast_{}_{}_{}_{}'.format(
event_key,
webcast_dict.get('type', None),
webcast_dict.get('channel', None),
webcast_dict.get('file', None))
| 35.029126 | 103 | 0.64939 |
22da6a830c3961f12d929a161994d3dd39e5a507 | 35,064 | py | Python | plugins/modules/oci_database_database_actions.py | sagar2938/oci-ansible-collection | 5b8ce583a0d5d0aabf14494d61aea4649e18d1e6 | [
"Apache-2.0"
] | null | null | null | plugins/modules/oci_database_database_actions.py | sagar2938/oci-ansible-collection | 5b8ce583a0d5d0aabf14494d61aea4649e18d1e6 | [
"Apache-2.0"
] | null | null | null | plugins/modules/oci_database_database_actions.py | sagar2938/oci-ansible-collection | 5b8ce583a0d5d0aabf14494d61aea4649e18d1e6 | [
"Apache-2.0"
] | null | null | null | #!/usr/bin/python
# Copyright (c) 2020, 2021 Oracle and/or its affiliates.
# This software is made available to you under the terms of the GPL 3.0 license or the Apache 2.0 license.
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
# Apache License v2.0
# See LICENSE.TXT for details.
# GENERATED FILE - DO NOT EDIT - MANUAL CHANGES WILL BE OVERWRITTEN
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {
"metadata_version": "1.1",
"status": ["preview"],
"supported_by": "community",
}
DOCUMENTATION = """
---
module: oci_database_database_actions
short_description: Perform actions on a Database resource in Oracle Cloud Infrastructure
description:
- Perform actions on a Database resource in Oracle Cloud Infrastructure
- Disables the Database Management service for the database.
- Enables the Database Management service for an Oracle Database located in Oracle Cloud Infrastructure. This service allows the database to access tools
including Metrics and Performance hub. Database Management is enabled at the container database (CDB) level.
- Changes encryption key management from customer-managed, using the L(Vault
service,https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm), to Oracle-managed.
- Updates one or more attributes of the Database Management service for the database.
- Restore a Database based on the request parameters you provide.
- Creates a new version of an existing L(Vault service,https://docs.cloud.oracle.com/iaas/Content/KeyManagement/Concepts/keyoverview.htm) key.
- Upgrades the specified Oracle Database instance.
version_added: "2.9.0"
author: Oracle (@oracle)
options:
database_id:
description:
- The database L(OCID,https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm).
type: str
aliases: ["id"]
required: true
credential_details:
description:
- ""
- Required for I(action=enable_database_management).
type: dict
suboptions:
user_name:
description:
- The name of the Oracle Database user that will be used to connect to the database.
type: str
required: true
password_secret_id:
description:
- The L(OCID,https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the Oracle Cloud Infrastructure
L(secret,https://docs.cloud.oracle.com/Content/KeyManagement/Concepts/keyoverview.htm#concepts).
type: str
required: true
private_end_point_id:
description:
- The L(OCID,https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the private endpoint.
- Required for I(action=enable_database_management).
type: str
management_type:
description:
- The Database Management type.
- Applicable only for I(action=enable_database_management)I(action=modify_database_management).
type: str
choices:
- "BASIC"
- "ADVANCED"
service_name:
description:
- The name of the Oracle Database service that will be used to connect to the database.
- Required for I(action=enable_database_management).
type: str
kms_key_id:
description:
- The OCID of the key container that is used as the master encryption key in database transparent data encryption (TDE) operations.
- Required for I(action=migrate_vault_key).
type: str
kms_key_version_id:
description:
- The OCID of the key container version that is used in database transparent data encryption (TDE) operations KMS Key can have multiple key
versions. If none is specified, the current key version (latest) of the Key Id is used for the operation.
- Applicable only for I(action=migrate_vault_key).
type: str
database_scn:
description:
- Restores using the backup with the System Change Number (SCN) specified.
- Applicable only for I(action=restore).
type: str
timestamp:
description:
- Restores to the timestamp specified.
- Applicable only for I(action=restore).
type: str
latest:
description:
- Restores to the last known good state with the least possible data loss.
- Applicable only for I(action=restore).
type: bool
action:
description:
- The action to perform on the Database.
type: str
required: true
choices:
- "disable_database_management"
- "enable_database_management"
- "migrate_vault_key"
- "modify_database_management"
- "restore"
- "rotate_vault_key"
- "precheck"
- "upgrade"
- "rollback"
database_upgrade_source_details:
description:
- ""
- Applicable only for I(action=upgrade).
type: dict
suboptions:
source:
description:
- "The source of the Oracle Database software to be used for the upgrade.
- Use `DB_HOME` to specify an existing Database Home to upgrade the database. The database is moved to the target Database Home and makes
use of the Oracle Database software version of the target Database Home.
- Use `DB_VERSION` to specify a generally-available Oracle Database software version to upgrade the database.
- Use `DB_SOFTWARE_IMAGE` to specify a L(database software
image,https://docs.cloud.oracle.com/iaas/Content/Database/Concepts/databasesoftwareimage.htm) to upgrade the database."
type: str
choices:
- "DB_HOME"
- "DB_SOFTWARE_IMAGE"
- "DB_VERSION"
required: true
options:
description:
- "Additional upgrade options supported by DBUA(Database Upgrade Assistant).
Example: \\"-upgradeTimezone false -keepEvents\\""
type: str
db_home_id:
description:
- The L(OCID,https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the Database Home.
- Required when source is 'DB_HOME'
type: str
database_software_image_id:
description:
- The database software image L(OCID,https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the image to be used to
upgrade a database.
- Required when source is 'DB_SOFTWARE_IMAGE'
type: str
db_version:
description:
- A valid Oracle Database version. To get a list of supported versions, use the L(ListDbVersions,https://docs.cloud.oracle.com/en-
us/iaas/api/#/en/database/latest/DbVersionSummary/ListDbVersions) operation.
- Required when source is 'DB_VERSION'
type: str
extends_documentation_fragment: [ oracle.oci.oracle, oracle.oci.oracle_wait_options ]
"""
EXAMPLES = """
- name: Perform action disable_database_management on database
oci_database_database_actions:
# required
database_id: "ocid1.database.oc1..xxxxxxEXAMPLExxxxxx"
action: disable_database_management
- name: Perform action enable_database_management on database
oci_database_database_actions:
# required
database_id: "ocid1.database.oc1..xxxxxxEXAMPLExxxxxx"
credential_details:
# required
user_name: user_name_example
password_secret_id: "ocid1.passwordsecret.oc1..xxxxxxEXAMPLExxxxxx"
private_end_point_id: "ocid1.privateendpoint.oc1..xxxxxxEXAMPLExxxxxx"
service_name: service_name_example
action: enable_database_management
# optional
management_type: BASIC
- name: Perform action migrate_vault_key on database
oci_database_database_actions:
# required
database_id: "ocid1.database.oc1..xxxxxxEXAMPLExxxxxx"
kms_key_id: "ocid1.kmskey.oc1..xxxxxxEXAMPLExxxxxx"
action: migrate_vault_key
# optional
kms_key_version_id: "ocid1.kmskeyversion.oc1..xxxxxxEXAMPLExxxxxx"
- name: Perform action modify_database_management on database
oci_database_database_actions:
# required
database_id: "ocid1.database.oc1..xxxxxxEXAMPLExxxxxx"
action: modify_database_management
# optional
credential_details:
# required
user_name: user_name_example
password_secret_id: "ocid1.passwordsecret.oc1..xxxxxxEXAMPLExxxxxx"
private_end_point_id: "ocid1.privateendpoint.oc1..xxxxxxEXAMPLExxxxxx"
management_type: BASIC
service_name: service_name_example
- name: Perform action restore on database
oci_database_database_actions:
# required
database_id: "ocid1.database.oc1..xxxxxxEXAMPLExxxxxx"
action: restore
# optional
database_scn: database_scn_example
timestamp: 2013-10-20T19:20:30+01:00
latest: true
- name: Perform action rotate_vault_key on database
oci_database_database_actions:
# required
database_id: "ocid1.database.oc1..xxxxxxEXAMPLExxxxxx"
action: rotate_vault_key
- name: Perform action precheck on database
oci_database_database_actions:
# required
database_id: "ocid1.database.oc1..xxxxxxEXAMPLExxxxxx"
action: precheck
# optional
database_upgrade_source_details:
# required
source: DB_HOME
db_home_id: "ocid1.dbhome.oc1..xxxxxxEXAMPLExxxxxx"
# optional
options: options_example
- name: Perform action upgrade on database
oci_database_database_actions:
# required
database_id: "ocid1.database.oc1..xxxxxxEXAMPLExxxxxx"
action: upgrade
# optional
database_upgrade_source_details:
# required
source: DB_HOME
db_home_id: "ocid1.dbhome.oc1..xxxxxxEXAMPLExxxxxx"
# optional
options: options_example
- name: Perform action rollback on database
oci_database_database_actions:
# required
database_id: "ocid1.database.oc1..xxxxxxEXAMPLExxxxxx"
action: rollback
# optional
database_upgrade_source_details:
# required
source: DB_HOME
db_home_id: "ocid1.dbhome.oc1..xxxxxxEXAMPLExxxxxx"
# optional
options: options_example
"""
RETURN = """
database:
description:
- Details of the Database resource acted upon by the current operation
returned: on success
type: complex
contains:
id:
description:
- The L(OCID,https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the database.
returned: on success
type: str
sample: "ocid1.resource.oc1..xxxxxxEXAMPLExxxxxx"
compartment_id:
description:
- The L(OCID,https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the compartment.
returned: on success
type: str
sample: "ocid1.compartment.oc1..xxxxxxEXAMPLExxxxxx"
character_set:
description:
- The character set for the database.
returned: on success
type: str
sample: character_set_example
ncharacter_set:
description:
- The national character set for the database.
returned: on success
type: str
sample: ncharacter_set_example
db_home_id:
description:
- The L(OCID,https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the Database Home.
returned: on success
type: str
sample: "ocid1.dbhome.oc1..xxxxxxEXAMPLExxxxxx"
db_system_id:
description:
- The L(OCID,https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the DB system.
returned: on success
type: str
sample: "ocid1.dbsystem.oc1..xxxxxxEXAMPLExxxxxx"
vm_cluster_id:
description:
- The L(OCID,https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the VM cluster.
returned: on success
type: str
sample: "ocid1.vmcluster.oc1..xxxxxxEXAMPLExxxxxx"
db_name:
description:
- The database name.
returned: on success
type: str
sample: db_name_example
pdb_name:
description:
- The name of the pluggable database. The name must begin with an alphabetic character and can contain a maximum of thirty alphanumeric
characters. Special characters are not permitted. Pluggable database should not be same as database name.
returned: on success
type: str
sample: pdb_name_example
db_workload:
description:
- The database workload type.
returned: on success
type: str
sample: db_workload_example
db_unique_name:
description:
- A system-generated name for the database to ensure uniqueness within an Oracle Data Guard group (a primary database and its standby
databases). The unique name cannot be changed.
returned: on success
type: str
sample: db_unique_name_example
lifecycle_details:
description:
- Additional information about the current lifecycle state.
returned: on success
type: str
sample: lifecycle_details_example
lifecycle_state:
description:
- The current state of the database.
returned: on success
type: str
sample: PROVISIONING
time_created:
description:
- The date and time the database was created.
returned: on success
type: str
sample: "2013-10-20T19:20:30+01:00"
last_backup_timestamp:
description:
- The date and time when the latest database backup was created.
returned: on success
type: str
sample: "2013-10-20T19:20:30+01:00"
db_backup_config:
description:
- ""
returned: on success
type: complex
contains:
auto_backup_enabled:
description:
- If set to true, configures automatic backups. If you previously used RMAN or dbcli to configure backups and then you switch to using
the Console or the API for backups, a new backup configuration is created and associated with your database. This means that you can
no longer rely on your previously configured unmanaged backups to work.
returned: on success
type: bool
sample: true
recovery_window_in_days:
description:
- Number of days between the current and the earliest point of recoverability covered by automatic backups.
This value applies to automatic backups only. After a new automatic backup has been created, Oracle removes old automatic backups that
are created before the window.
When the value is updated, it is applied to all existing automatic backups.
returned: on success
type: int
sample: 56
auto_backup_window:
description:
- Time window selected for initiating automatic backup for the database system. There are twelve available two-hour time windows. If no
option is selected, a start time between 12:00 AM to 7:00 AM in the region of the database is automatically chosen. For example, if
the user selects SLOT_TWO from the enum list, the automatic backup job will start in between 2:00 AM (inclusive) to 4:00 AM
(exclusive).
- "Example: `SLOT_TWO`"
returned: on success
type: str
sample: SLOT_TWO
backup_destination_details:
description:
- Backup destination details.
returned: on success
type: complex
contains:
type:
description:
- Type of the database backup destination.
returned: on success
type: str
sample: NFS
id:
description:
- The L(OCID,https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of the backup destination.
returned: on success
type: str
sample: "ocid1.resource.oc1..xxxxxxEXAMPLExxxxxx"
vpc_user:
description:
- For a RECOVERY_APPLIANCE backup destination, the Virtual Private Catalog (VPC) user that is used to access the Recovery
Appliance.
returned: on success
type: str
sample: vpc_user_example
vpc_password:
description:
- For a RECOVERY_APPLIANCE backup destination, the password for the VPC user that is used to access the Recovery Appliance.
returned: on success
type: str
sample: example-password
internet_proxy:
description:
- Proxy URL to connect to object store.
returned: on success
type: str
sample: internet_proxy_example
freeform_tags:
description:
- Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace.
For more information, see L(Resource Tags,https://docs.cloud.oracle.com/Content/General/Concepts/resourcetags.htm).
- "Example: `{\\"Department\\": \\"Finance\\"}`"
returned: on success
type: dict
sample: {'Department': 'Finance'}
defined_tags:
description:
- Defined tags for this resource. Each key is predefined and scoped to a namespace.
For more information, see L(Resource Tags,https://docs.cloud.oracle.com/Content/General/Concepts/resourcetags.htm).
returned: on success
type: dict
sample: {'Operations': {'CostCenter': 'US'}}
connection_strings:
description:
- The Connection strings used to connect to the Oracle Database.
returned: on success
type: complex
contains:
cdb_default:
description:
- Host name based CDB Connection String.
returned: on success
type: str
sample: cdb_default_example
cdb_ip_default:
description:
- IP based CDB Connection String.
returned: on success
type: str
sample: cdb_ip_default_example
all_connection_strings:
description:
- All connection strings to use to connect to the Database.
returned: on success
type: dict
sample: {}
kms_key_id:
description:
- The OCID of the key container that is used as the master encryption key in database transparent data encryption (TDE) operations.
returned: on success
type: str
sample: "ocid1.kmskey.oc1..xxxxxxEXAMPLExxxxxx"
source_database_point_in_time_recovery_timestamp:
description:
- Point in time recovery timeStamp of the source database at which cloned database system is cloned from the source database system, as
described in L(RFC 3339,https://tools.ietf.org/rfc/rfc3339)
returned: on success
type: str
sample: "2013-10-20T19:20:30+01:00"
database_software_image_id:
description:
- The database software image L(OCID,https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm)
returned: on success
type: str
sample: "ocid1.databasesoftwareimage.oc1..xxxxxxEXAMPLExxxxxx"
is_cdb:
description:
- True if the database is a container database.
returned: on success
type: bool
sample: true
database_management_config:
description:
- ""
returned: on success
type: complex
contains:
management_status:
description:
- The status of the Database Management service.
returned: on success
type: str
sample: ENABLING
management_type:
description:
- The Database Management type.
returned: on success
type: str
sample: BASIC
sid_prefix:
description:
- Specifies a prefix for the `Oracle SID` of the database to be created.
returned: on success
type: str
sample: sid_prefix_example
sample: {
"id": "ocid1.resource.oc1..xxxxxxEXAMPLExxxxxx",
"compartment_id": "ocid1.compartment.oc1..xxxxxxEXAMPLExxxxxx",
"character_set": "character_set_example",
"ncharacter_set": "ncharacter_set_example",
"db_home_id": "ocid1.dbhome.oc1..xxxxxxEXAMPLExxxxxx",
"db_system_id": "ocid1.dbsystem.oc1..xxxxxxEXAMPLExxxxxx",
"vm_cluster_id": "ocid1.vmcluster.oc1..xxxxxxEXAMPLExxxxxx",
"db_name": "db_name_example",
"pdb_name": "pdb_name_example",
"db_workload": "db_workload_example",
"db_unique_name": "db_unique_name_example",
"lifecycle_details": "lifecycle_details_example",
"lifecycle_state": "PROVISIONING",
"time_created": "2013-10-20T19:20:30+01:00",
"last_backup_timestamp": "2013-10-20T19:20:30+01:00",
"db_backup_config": {
"auto_backup_enabled": true,
"recovery_window_in_days": 56,
"auto_backup_window": "SLOT_TWO",
"backup_destination_details": [{
"type": "NFS",
"id": "ocid1.resource.oc1..xxxxxxEXAMPLExxxxxx",
"vpc_user": "vpc_user_example",
"vpc_password": "example-password",
"internet_proxy": "internet_proxy_example"
}]
},
"freeform_tags": {'Department': 'Finance'},
"defined_tags": {'Operations': {'CostCenter': 'US'}},
"connection_strings": {
"cdb_default": "cdb_default_example",
"cdb_ip_default": "cdb_ip_default_example",
"all_connection_strings": {}
},
"kms_key_id": "ocid1.kmskey.oc1..xxxxxxEXAMPLExxxxxx",
"source_database_point_in_time_recovery_timestamp": "2013-10-20T19:20:30+01:00",
"database_software_image_id": "ocid1.databasesoftwareimage.oc1..xxxxxxEXAMPLExxxxxx",
"is_cdb": true,
"database_management_config": {
"management_status": "ENABLING",
"management_type": "BASIC"
},
"sid_prefix": "sid_prefix_example"
}
"""
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.oracle.oci.plugins.module_utils import (
oci_common_utils,
oci_wait_utils,
)
from ansible_collections.oracle.oci.plugins.module_utils.oci_resource_utils import (
OCIActionsHelperBase,
get_custom_class,
)
try:
from oci.work_requests import WorkRequestClient
from oci.database import DatabaseClient
from oci.database.models import EnableDatabaseManagementDetails
from oci.database.models import MigrateVaultKeyDetails
from oci.database.models import ModifyDatabaseManagementDetails
from oci.database.models import RestoreDatabaseDetails
from oci.database.models import UpgradeDatabaseDetails
HAS_OCI_PY_SDK = True
except ImportError:
HAS_OCI_PY_SDK = False
class DatabaseActionsHelperGen(OCIActionsHelperBase):
"""
Supported actions:
disable_database_management
enable_database_management
migrate_vault_key
modify_database_management
restore
rotate_vault_key
upgrade
"""
def __init__(self, *args, **kwargs):
super(DatabaseActionsHelperGen, self).__init__(*args, **kwargs)
self.work_request_client = WorkRequestClient(
self.client._config, **self.client._kwargs
)
@staticmethod
def get_module_resource_id_param():
return "database_id"
def get_module_resource_id(self):
return self.module.params.get("database_id")
def get_get_fn(self):
return self.client.get_database
def get_resource(self):
return oci_common_utils.call_with_backoff(
self.client.get_database, database_id=self.module.params.get("database_id"),
)
def disable_database_management(self):
return oci_wait_utils.call_and_wait(
call_fn=self.client.disable_database_management,
call_fn_args=(),
call_fn_kwargs=dict(database_id=self.module.params.get("database_id"),),
waiter_type=oci_wait_utils.WORK_REQUEST_WAITER_KEY,
operation="{0}_{1}".format(
self.module.params.get("action").upper(),
oci_common_utils.ACTION_OPERATION_KEY,
),
waiter_client=self.work_request_client,
resource_helper=self,
wait_for_states=oci_common_utils.get_work_request_completed_states(),
)
def enable_database_management(self):
action_details = oci_common_utils.convert_input_data_to_model_class(
self.module.params, EnableDatabaseManagementDetails
)
return oci_wait_utils.call_and_wait(
call_fn=self.client.enable_database_management,
call_fn_args=(),
call_fn_kwargs=dict(
database_id=self.module.params.get("database_id"),
enable_database_management_details=action_details,
),
waiter_type=oci_wait_utils.WORK_REQUEST_WAITER_KEY,
operation="{0}_{1}".format(
self.module.params.get("action").upper(),
oci_common_utils.ACTION_OPERATION_KEY,
),
waiter_client=self.work_request_client,
resource_helper=self,
wait_for_states=oci_common_utils.get_work_request_completed_states(),
)
def migrate_vault_key(self):
action_details = oci_common_utils.convert_input_data_to_model_class(
self.module.params, MigrateVaultKeyDetails
)
return oci_wait_utils.call_and_wait(
call_fn=self.client.migrate_vault_key,
call_fn_args=(),
call_fn_kwargs=dict(
database_id=self.module.params.get("database_id"),
migrate_vault_key_details=action_details,
),
waiter_type=oci_wait_utils.WORK_REQUEST_WAITER_KEY,
operation="{0}_{1}".format(
self.module.params.get("action").upper(),
oci_common_utils.ACTION_OPERATION_KEY,
),
waiter_client=self.work_request_client,
resource_helper=self,
wait_for_states=oci_common_utils.get_work_request_completed_states(),
)
def modify_database_management(self):
action_details = oci_common_utils.convert_input_data_to_model_class(
self.module.params, ModifyDatabaseManagementDetails
)
return oci_wait_utils.call_and_wait(
call_fn=self.client.modify_database_management,
call_fn_args=(),
call_fn_kwargs=dict(
database_id=self.module.params.get("database_id"),
modify_database_management_details=action_details,
),
waiter_type=oci_wait_utils.WORK_REQUEST_WAITER_KEY,
operation="{0}_{1}".format(
self.module.params.get("action").upper(),
oci_common_utils.ACTION_OPERATION_KEY,
),
waiter_client=self.work_request_client,
resource_helper=self,
wait_for_states=oci_common_utils.get_work_request_completed_states(),
)
def restore(self):
action_details = oci_common_utils.convert_input_data_to_model_class(
self.module.params, RestoreDatabaseDetails
)
return oci_wait_utils.call_and_wait(
call_fn=self.client.restore_database,
call_fn_args=(),
call_fn_kwargs=dict(
database_id=self.module.params.get("database_id"),
restore_database_details=action_details,
),
waiter_type=oci_wait_utils.WORK_REQUEST_WAITER_KEY,
operation="{0}_{1}".format(
self.module.params.get("action").upper(),
oci_common_utils.ACTION_OPERATION_KEY,
),
waiter_client=self.work_request_client,
resource_helper=self,
wait_for_states=oci_common_utils.get_work_request_completed_states(),
)
def rotate_vault_key(self):
return oci_wait_utils.call_and_wait(
call_fn=self.client.rotate_vault_key,
call_fn_args=(),
call_fn_kwargs=dict(database_id=self.module.params.get("database_id"),),
waiter_type=oci_wait_utils.WORK_REQUEST_WAITER_KEY,
operation="{0}_{1}".format(
self.module.params.get("action").upper(),
oci_common_utils.ACTION_OPERATION_KEY,
),
waiter_client=self.work_request_client,
resource_helper=self,
wait_for_states=oci_common_utils.get_work_request_completed_states(),
)
def upgrade(self):
action_details = oci_common_utils.convert_input_data_to_model_class(
self.module.params, UpgradeDatabaseDetails
)
return oci_wait_utils.call_and_wait(
call_fn=self.client.upgrade_database,
call_fn_args=(),
call_fn_kwargs=dict(
database_id=self.module.params.get("database_id"),
upgrade_database_details=action_details,
),
waiter_type=oci_wait_utils.WORK_REQUEST_WAITER_KEY,
operation="{0}_{1}".format(
self.module.params.get("action").upper(),
oci_common_utils.ACTION_OPERATION_KEY,
),
waiter_client=self.work_request_client,
resource_helper=self,
wait_for_states=oci_common_utils.get_work_request_completed_states(),
)
DatabaseActionsHelperCustom = get_custom_class("DatabaseActionsHelperCustom")
class ResourceHelper(DatabaseActionsHelperCustom, DatabaseActionsHelperGen):
pass
def main():
module_args = oci_common_utils.get_common_arg_spec(
supports_create=False, supports_wait=True
)
module_args.update(
dict(
database_id=dict(aliases=["id"], type="str", required=True),
credential_details=dict(
type="dict",
options=dict(
user_name=dict(type="str", required=True),
password_secret_id=dict(type="str", required=True),
),
),
private_end_point_id=dict(type="str"),
management_type=dict(type="str", choices=["BASIC", "ADVANCED"]),
service_name=dict(type="str"),
kms_key_id=dict(type="str"),
kms_key_version_id=dict(type="str"),
database_scn=dict(type="str"),
timestamp=dict(type="str"),
latest=dict(type="bool"),
action=dict(
type="str",
required=True,
choices=[
"disable_database_management",
"enable_database_management",
"migrate_vault_key",
"modify_database_management",
"restore",
"rotate_vault_key",
"precheck",
"upgrade",
"rollback",
],
),
database_upgrade_source_details=dict(
type="dict",
options=dict(
source=dict(
type="str",
required=True,
choices=["DB_HOME", "DB_SOFTWARE_IMAGE", "DB_VERSION"],
),
options=dict(type="str"),
db_home_id=dict(type="str"),
database_software_image_id=dict(type="str"),
db_version=dict(type="str"),
),
),
)
)
module = AnsibleModule(argument_spec=module_args, supports_check_mode=True)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
resource_helper = ResourceHelper(
module=module,
resource_type="database",
service_client_class=DatabaseClient,
namespace="database",
)
result = resource_helper.perform_action(module.params.get("action"))
module.exit_json(**result)
if __name__ == "__main__":
main()
| 41.106682 | 160 | 0.601015 |
347534993a4fb66a62ce4ac93c3faedd82adc330 | 1,852 | py | Python | smoketests/pages/base.py | feer56/Kitsune2 | 68daba37eae4eceaffcb1ca978c783955b42d2eb | [
"BSD-3-Clause"
] | null | null | null | smoketests/pages/base.py | feer56/Kitsune2 | 68daba37eae4eceaffcb1ca978c783955b42d2eb | [
"BSD-3-Clause"
] | 1 | 2021-04-30T20:33:35.000Z | 2021-04-30T20:33:35.000Z | smoketests/pages/base.py | feer56/Kitsune2 | 68daba37eae4eceaffcb1ca978c783955b42d2eb | [
"BSD-3-Clause"
] | null | null | null | #!/usr/bin/env python
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
from selenium.common.exceptions import (
ElementNotVisibleException,
NoSuchElementException
)
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
class Page(object):
def __init__(self, testsetup):
self.testsetup = testsetup
self.base_url = testsetup.base_url
self.selenium = testsetup.selenium
self.timeout = testsetup.timeout
def go_to_page(self):
self.selenium.get(self.base_url + self._url)
self.is_the_current_page
@property
def is_the_current_page(self):
if self._page_title:
WebDriverWait(self.selenium, self.timeout).until(lambda s: s.title)
assert self.selenium.title == self._page_title
return True
def is_element_visible_no_wait(self, locator):
self.selenium.implicitly_wait(0)
try:
return self.selenium.find_element(*locator).is_displayed()
except (NoSuchElementException, ElementNotVisibleException):
return False
finally:
# set back to where you once belonged
self.selenium.implicitly_wait(self.testsetup.default_implicit_wait)
def is_element_visible(self, locator):
try:
return self.selenium.find_element(*locator).is_displayed()
except Exception:
return False
def wait_for(self, locator):
# FIXME: self.timeout
WebDriverWait(self.selenium, 5).until(EC.visibility_of_element_located(locator))
@property
def current_page_url(self):
return(self.selenium.current_url)
| 32.491228 | 88 | 0.691685 |
8057f73cd3557022d090de0af8f29cbaf89b3e6e | 623 | py | Python | dashboard/migrations/0020_auto_20211026_2217.py | TheRK420/roommate | 89b9146cc57e45e32dcc308f859e5f06190159da | [
"Apache-2.0"
] | 1 | 2021-11-12T13:45:35.000Z | 2021-11-12T13:45:35.000Z | dashboard/migrations/0020_auto_20211026_2217.py | TheRK420/roommate | 89b9146cc57e45e32dcc308f859e5f06190159da | [
"Apache-2.0"
] | null | null | null | dashboard/migrations/0020_auto_20211026_2217.py | TheRK420/roommate | 89b9146cc57e45e32dcc308f859e5f06190159da | [
"Apache-2.0"
] | null | null | null | # Generated by Django 3.1.4 on 2021-10-26 16:47
import datetime
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('dashboard', '0019_auto_20211026_2203'),
]
operations = [
migrations.AlterField(
model_name='addroom',
name='image1',
field=models.ImageField(upload_to='media/'),
),
migrations.AlterField(
model_name='bookingrooms',
name='timestamp',
field=models.DateTimeField(default=datetime.datetime(2021, 10, 26, 22, 17, 22, 594709)),
),
]
| 24.92 | 100 | 0.598716 |
62caf3316009b792de3a1f9f1caa026e207b26f0 | 2,365 | py | Python | 2015/03/03a.py | befeleme/aoc | dec81ceeffb8746af28eeeb7f925b219f2445079 | [
"WTFPL"
] | 3 | 2021-12-07T17:46:48.000Z | 2022-02-23T13:33:19.000Z | 2015/03/03a.py | befeleme/aoc | dec81ceeffb8746af28eeeb7f925b219f2445079 | [
"WTFPL"
] | null | null | null | 2015/03/03a.py | befeleme/aoc | dec81ceeffb8746af28eeeb7f925b219f2445079 | [
"WTFPL"
] | null | null | null | '''This script contains some doctests.
Invoke the tests from the command line:
`python -m doctest -v 03a.py`
Module documentation: https://docs.python.org/3/library/doctest.html
'''
from pathlib import Path
OFFSETS = {
'>': (1, 0),
'v': (0, -1),
'<': (-1, 0),
'^': (0, 1),
}
def move_to_next_house(current_position, move):
'''
Return the next house's coordinates.
Examples:
>>> move_to_next_house((0, 5), '>')
(1, 5)
>>> move_to_next_house((65, 2), '^')
(65, 3)
>>> move_to_next_house((-150, -68), 'v')
(-150, -69)
'''
new_x, new_y = OFFSETS[move]
old_x, old_y = current_position
return old_x + new_x, old_y + new_y
def deliver(house_map):
'''
Return the count of the houses visited at least once in the area.
Examples:
>>> deliver('>')
2
>>> deliver('^>v<')
4
>>> deliver('^v^v^v^v^v')
2
'''
visited_houses = set()
current_position = (0, 0)
visited_houses.add(current_position)
for move in house_map:
current_position = move_to_next_house(current_position, move)
visited_houses.add(current_position)
return len(visited_houses)
def deliver_with_robo_santa(house_map):
'''
Return the count of the houses visited at least once in the area
if Santa and Robo-Santa take every second house.
Examples:
>>> deliver_with_robo_santa('^>v<')
3
>>> deliver_with_robo_santa('^v')
3
>>> deliver_with_robo_santa('^v^v^v^v^v')
11
'''
visited_houses = set()
santas_current_position = (0, 0)
robo_santas_current_position = (0, 0)
visited_houses.add(santas_current_position)
for i, move in enumerate(house_map):
# even houses go to Santa
if i % 2 == 0:
santas_current_position = move_to_next_house(santas_current_position, move)
visited_houses.add(santas_current_position)
# and the odd ones to Robo-Santa
else:
robo_santas_current_position = move_to_next_house(robo_santas_current_position, move)
visited_houses.add(robo_santas_current_position)
return len(visited_houses)
area_map = Path('input').read_text()
print(deliver(area_map))
print(deliver_with_robo_santa(area_map))
| 24.635417 | 97 | 0.612685 |
4c83d23476342e46d1bb808c01ec8730ba840239 | 4,188 | py | Python | correct_batch_effects_wdn/ljosa_preprocessing.py | shaun95/google-research | d41bbaca1eb9bfd980ec2b3fd201c3ddb4d1f2e5 | [
"Apache-2.0"
] | 1 | 2022-02-25T05:34:44.000Z | 2022-02-25T05:34:44.000Z | correct_batch_effects_wdn/ljosa_preprocessing.py | shaun95/google-research | d41bbaca1eb9bfd980ec2b3fd201c3ddb4d1f2e5 | [
"Apache-2.0"
] | null | null | null | correct_batch_effects_wdn/ljosa_preprocessing.py | shaun95/google-research | d41bbaca1eb9bfd980ec2b3fd201c3ddb4d1f2e5 | [
"Apache-2.0"
] | 1 | 2022-03-30T07:20:29.000Z | 2022-03-30T07:20:29.000Z | # coding=utf-8
# Copyright 2022 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Lint as: python3
"""Pre-processing step for Ljosa embeddings.
The goal is to replicate the work done in the Ljosa paper
(https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3884769/), within our framework so
we can try the WDN method on them (i.e. the Wasserstein Distance Network method
for batch correction).
There are two steps: The first is to normalize the components between the 1st
and 99th percentile of the controls. The second step is factor analysis with
50 dimesions.
The input is an H5 dataframe with 462 embedding dimensions. The output should
be two embeddings dataframes, after each step of the analysis. The first
dataframe has 456 components, since some dimensions are dropped (when the
normalization is not successful). The post-factor analysis embedding has
50 dimensions because this is the number of factors used.
The methods here could also be used as post-processing after e.g. the WDN
method.
"""
from absl import app
from absl import flags
import numpy as np
import pandas as pd
from correct_batch_effects_wdn import io_utils
from correct_batch_effects_wdn import metadata
from correct_batch_effects_wdn import transform
FLAGS = flags.FLAGS
flags.DEFINE_string("original_df", None,
"Original Ljosa embeddings, with unused variables taken "
"out.")
flags.DEFINE_string("post_normliazation_path", None,
"Where to save post-normalization dataframe.")
flags.DEFINE_string("post_fa_path", None,
"Where to save post-factor analysis dataframe.")
def normalize_ljosa(df):
"""Apply the normalization for each dimension of the embedding.
Find the 1st and 99th percentile of the controls for each dimension, for each
plate. Then normalize the remaining treatments so that they have matching
1st and 99th percentiles.
Args:
df (pandas dataframe): Input embedding dataframe
Returns:
emb_df_normalized (pandas dataframe): Normalized dataframe.
"""
emb_df_normalized = []
for (_, _), df_batch_plate in df.groupby(level=[metadata.BATCH,
metadata.PLATE]):
df_batch_plate_new = df_batch_plate.copy()
## Find 1st and 99th percentile of controls (for each plate)
df_batch_plate_control = df_batch_plate.xs("DMSO", level=metadata.MOA)
percentile_1st = np.percentile(df_batch_plate_control, q=1, axis=0)
percentile_99th = np.percentile(df_batch_plate_control, q=99, axis=0)
## normalize remainingd treatments
slope = 1 / (percentile_99th - percentile_1st)
intercept = - slope * percentile_1st
for i, col in enumerate(df_batch_plate.columns):
df_batch_plate_new[col] = df_batch_plate[col] * slope[i] + intercept[i]
emb_df_normalized.append(df_batch_plate_new)
emb_df_normalized = pd.concat(emb_df_normalized)
## Drop columns with NaN entries.
col_to_drop = np.where(emb_df_normalized.isnull().any())[0]
emb_df_normalized.drop(col_to_drop, axis=1, inplace=True)
return emb_df_normalized
def main(argv):
del argv # Unused.
df = io_utils.read_dataframe_from_hdf5(FLAGS.original_df)
## Generate the percentile-normalized embeddings
emb_df_normalized = normalize_ljosa(df)
## Generate the post-factor analysis embeddings
np.random.seed(0)
emb_df_fa = transform.factor_analysis(emb_df_normalized, 0.15, 50)
io_utils.write_dataframe_to_hdf5(emb_df_fa, FLAGS.post_fa_path)
io_utils.write_dataframe_to_hdf5(emb_df_normalized,
FLAGS.post_normliazation_path)
if __name__ == "__main__":
app.run(main)
| 36.417391 | 80 | 0.744269 |
e08d65e121fbe253de646309aa37e232cbc469b3 | 2,037 | py | Python | src/cryptography/hazmat/primitives/cmac.py | jonathanslenders/cryptography | 2535e557872ac2f94355eb8a91a598f5cfc8afcf | [
"PSF-2.0",
"Apache-2.0",
"BSD-3-Clause"
] | 1 | 2019-09-20T18:51:44.000Z | 2019-09-20T18:51:44.000Z | src/cryptography/hazmat/primitives/cmac.py | jonathanslenders/cryptography | 2535e557872ac2f94355eb8a91a598f5cfc8afcf | [
"PSF-2.0",
"Apache-2.0",
"BSD-3-Clause"
] | 11 | 2022-03-04T14:14:10.000Z | 2022-03-31T01:50:05.000Z | src/cryptography/hazmat/primitives/cmac.py | jonathanslenders/cryptography | 2535e557872ac2f94355eb8a91a598f5cfc8afcf | [
"PSF-2.0",
"Apache-2.0",
"BSD-3-Clause"
] | 2 | 2022-02-04T07:50:54.000Z | 2022-02-04T10:21:43.000Z | # This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.
import typing
from cryptography import utils
from cryptography.exceptions import (
AlreadyFinalized,
)
from cryptography.hazmat.primitives import ciphers
if typing.TYPE_CHECKING:
from cryptography.hazmat.backends.openssl.cmac import _CMACContext
class CMAC:
_ctx: typing.Optional["_CMACContext"]
_algorithm: ciphers.BlockCipherAlgorithm
def __init__(
self,
algorithm: ciphers.BlockCipherAlgorithm,
backend: typing.Any = None,
ctx: typing.Optional["_CMACContext"] = None,
):
if not isinstance(algorithm, ciphers.BlockCipherAlgorithm):
raise TypeError("Expected instance of BlockCipherAlgorithm.")
self._algorithm = algorithm
if ctx is None:
from cryptography.hazmat.backends.openssl.backend import (
backend as ossl,
)
self._ctx = ossl.create_cmac_ctx(self._algorithm)
else:
self._ctx = ctx
def update(self, data: bytes) -> None:
if self._ctx is None:
raise AlreadyFinalized("Context was already finalized.")
utils._check_bytes("data", data)
self._ctx.update(data)
def finalize(self) -> bytes:
if self._ctx is None:
raise AlreadyFinalized("Context was already finalized.")
digest = self._ctx.finalize()
self._ctx = None
return digest
def verify(self, signature: bytes) -> None:
utils._check_bytes("signature", signature)
if self._ctx is None:
raise AlreadyFinalized("Context was already finalized.")
ctx, self._ctx = self._ctx, None
ctx.verify(signature)
def copy(self) -> "CMAC":
if self._ctx is None:
raise AlreadyFinalized("Context was already finalized.")
return CMAC(self._algorithm, ctx=self._ctx.copy())
| 30.402985 | 79 | 0.654885 |
99cbc1030ef83b0d6863a76130f1631339bccf4e | 2,872 | py | Python | ntmdists.py | Seanny123/counting_to_addition | e41089065f50c07fba3e18657be175ac91162bd9 | [
"MIT"
] | 4 | 2017-01-11T04:27:21.000Z | 2019-05-27T17:41:46.000Z | ntmdists.py | Seanny123/counting_to_addition | e41089065f50c07fba3e18657be175ac91162bd9 | [
"MIT"
] | null | null | null | ntmdists.py | Seanny123/counting_to_addition | e41089065f50c07fba3e18657be175ac91162bd9 | [
"MIT"
] | 1 | 2019-11-19T05:21:55.000Z | 2019-11-19T05:21:55.000Z | from nengo.dists import *
from sobol_seq import i4_sobol_generate
class SphericalCoords(Distribution):
def __init__(self, m):
self.m = m
def sample(self, num, d=None, rng=np.random):
shape = self._sample_shape(num, d)
y = rng.uniform(size=shape)
return self.ppf(y)
def pdf(self, x):
from scipy.special import beta
return np.pi * np.sin(np.pi * x) ** (self.m-1) / beta(self.m / 2.0, 0.5)
def cdf(self, x):
from scipy.special import betainc
y = 0.5 * betainc(self.m / 2.0, 0.5, np.sin(np.pi * x) ** 2)
return np.where(x < 0.5, y, 1 - y)
def ppf(self, y):
from scipy.special import betaincinv
y_reflect = np.where(y < 0.5, y, 1 - y)
z_sq = betaincinv(self.m / 2.0, 0.5, 2 * y_reflect)
x = np.arcsin(np.sqrt(z_sq)) / np.pi
return np.where(y < 0.5, x, 1 - x)
class Sobol(Distribution):
def sample(self, num, d=None, rng=np.random):
if d is None or d < 1 or d > 40: # TODO: also check if integer
raise ValueError("d (%d) must be integer in range [1, 40]" % d)
num, d = self._sample_shape(num, d)
#from scipy.stats import uniform
#mdd = MultiDimDistribution([uniform for _ in range(d)])
#return np.asarray(mdd.sobol(num))
return i4_sobol_generate(d, num, skip=0)
def random_orthogonal(d, rng=np.random):
m = UniformHypersphere(surface=True).sample(d, d, rng=rng)
# formula for nearest orthogonal matrix (assumes m is linearly independent)
u, s, v = np.linalg.svd(m)
return np.dot(u, v)
class ScatteredHypersphere(UniformHypersphere):
def sample(self, num, d=1.0, rng=np.random, ntm=Sobol()):
if self.surface:
cube = ntm.sample(num, d-1)
radius = 1.0
else:
dcube = ntm.sample(num, d)
cube, radius = dcube[:, :-1], dcube[:, -1:] ** (1.0 / d)
# inverse transform method (section 1.5.2)
for j in range(d-1):
cube[:, j] = SphericalCoords(d-1-j).ppf(cube[:, j])
# spherical coordinate transform
i = np.ones(d-1)
i[-1] = 2.0
s = np.sin(i[None, :] * np.pi * cube)
c = np.cos(i[None, :] * np.pi * cube)
mapped = np.ones((num, d))
mapped[:, 1:] = np.cumprod(s, axis=1)
mapped[:, :-1] *= c
assert np.allclose(npext.norm(mapped, axis=1, keepdims=True), 1)
# radius adjustment for ball versus sphere, and rotate
rotation = random_orthogonal(d, rng=rng)
return np.dot(mapped * radius, rotation)
if __name__ == '__main__':
import pylab
pylab.figure(figsize=(6, 6))
pylab.scatter(*ScatteredHypersphere(surface=False).sample(400, 2).T, lw=0)
pylab.scatter(*ScatteredHypersphere(surface=True).sample(100, 2).T, c='r', lw=0)
pylab.show() | 33.395349 | 84 | 0.577646 |
5b379eae6d43b51fa6d1c50051f3668def27e516 | 35,059 | py | Python | pair-classifier/pair_classifier/classify_bugs.py | lxylxy123456/bugswarm | 522ea76ede28811463efda7551509f07b3951961 | [
"BSD-3-Clause"
] | 18 | 2019-12-27T06:53:39.000Z | 2022-03-03T03:05:35.000Z | pair-classifier/pair_classifier/classify_bugs.py | lxylxy123456/bugswarm | 522ea76ede28811463efda7551509f07b3951961 | [
"BSD-3-Clause"
] | 13 | 2020-01-10T17:11:38.000Z | 2021-12-13T20:34:38.000Z | pair-classifier/pair_classifier/classify_bugs.py | lxylxy123456/bugswarm | 522ea76ede28811463efda7551509f07b3951961 | [
"BSD-3-Clause"
] | 10 | 2020-01-10T17:36:57.000Z | 2021-09-13T19:51:43.000Z | # Run this script after generating folders for all image-tags by running main.py
#
# This script will generate:
#
# * a folder '[type-of-error]_results' which contains:
# reports_[type].tsv : contains details for each tag processed
# not_[type] : list of tags not classified as [type-of-error]
# reports_[type] : Same info as report.tsv, pretty printed
# where [type-of-error] or [type] can be 'build', 'code', or 'test'
#
# * a JSON file which contains all results calculated in this script (classification.json)
#
# * a JSON file containing counts of all errors detected per language
#
# * TSV files for:
# - classification results (results.tsv, results-details.tsv)
# - all errors, standard errors, user-defined errors
#
# USAGE: python3 classify_bugs.py
# python3 classify_bugs.py -h (Will display all optional arguments)
#
# REQUIREMENTS:
# 1. This script is run with Python3.x
# 2. main.py has been run
import re
import sys
import time
import os
import json
import argparse
from bugswarm.common.artifact_processing import utils as procutils
from bugswarm.common import log
from .exception_lists import python_exceptions, python_nonstd, java_all, java_nonstd, not_errors
# Extracts filenames from the diff
def process_diff(diff_file):
files_changed = list()
files_added = list()
files_deleted = list()
re_filename = r'[a-zA-Z0-9\/\.\-\_\{\}]*'
with open(diff_file) as f:
diff = f.readlines()
count = 0
for line in diff:
count = count + 1
matches_change = re.match(r"Files (passed|failed)\/(?P<file_pass>" + re_filename +
r") and (passed|failed)\/(?P<file_fail>" + re_filename + ") differ", line)
if matches_change:
matches = matches_change.groupdict()
if matches.get('file_pass', 'default_pass') == matches.get('file_fail', 'default_fail'):
files_changed.append(matches.get('file_pass', ''))
matches_add_del = re.match(r"Only in (?P<fail_or_pass>(passed|failed))\/(?P<file_path>" +
re_filename + r"): (?P<filename>[\w.]+)$", line)
if matches_add_del:
matches = matches_add_del.groupdict()
if matches.get('fail_or_pass', '') == 'passed':
files_added.append(matches.get('file_path', '') + matches.get('filename', ''))
elif matches.get('fail_or_pass', '') == 'failed':
files_deleted.append(matches.get('file_path', '') + matches.get('filename', ''))
# if not files_changed:
# return list(),list(),list()
return files_changed, files_deleted, files_added
# Read cloc.csv
def process_loc(cloc_file, lang=None):
num_lang_files = 0
lang_loc = 0
num_files = 0
total_loc = 0
with open(cloc_file) as f:
loc = f.readlines()
loc = [line.strip().split(',') for line in loc]
for line in loc[1:]:
if lang and line[1].lower() == lang:
num_lang_files = int(line[0])
lang_loc = int(line[4])
num_files += int(line[0])
total_loc += int(line[4])
if not lang or lang_loc == 0 or num_lang_files == 0:
lang_loc = loc[1][4]
num_lang_files = loc[1][0]
return lang_loc, total_loc, num_lang_files, num_files
def is_test(files_changed):
"""
Checks if the file classifies as test error or not
:param files_changed: the modified filename list between two commits
:return: confidence, files_test, files_not_test
"""
count = 0
files_test = list()
files_not_test = list()
if len(files_changed) < 1:
log.error("No files changed")
return None, list(), list()
for filename in files_changed:
if re.search(r'tests?\/', filename):
count += 1
files_test.append(filename)
elif re.search(r'test', filename):
count += 0.5
files_test.append(filename)
else:
files_not_test.append(filename)
files_actually_changed = len(files_changed)
if files_actually_changed > 0:
confidence = count / files_actually_changed
else:
confidence = 0.0
return confidence, files_test, files_not_test
def is_dependency(files_changed, all_files_changed):
"""
Checks if the file classifies as deoendency (build) error or not
:param files_changed: the modified filename list between two commits
:param all_files_changed: all filenames that been modified
:return: confidence, files_relevant, files_not_relevant
"""
build_config_files = ['pom.xml', 'travis.yml', 'build.gradle', '.travis/', 'build.xml']
count = 0
files_relevant = list()
files_not_relevant = list()
if len(files_changed) < 1:
log.error("No files changed")
return None, list(), list()
for filename in files_changed:
if any([x in filename for x in build_config_files]):
count += 1
files_relevant.append(filename)
else:
files_not_relevant.append(filename)
files_actually_changed = len(all_files_changed)
if files_actually_changed > 0:
confidence = count / files_actually_changed
else:
confidence = 0.0
return confidence, files_relevant, files_not_relevant
def generate_report(all_info=None):
all_info = [] if not all_info else all_info
report = "\n----------------------------------------------------------------\n"
for tag, data in all_info:
if isinstance(data, list):
report = report + "\n" + tag + ": \n\t" + '\n\t'.join(map(str, data))
else:
report = report + "\n" + tag + ": " + str(data)
return report
def is_code(files_changed, all_files_changed):
"""
Checks if the file classifies as code error or not
:param files_changed: the modified filename list between two commits
:param all_files_changed: all files been modified
:return: confidence, files_code, files_not_code
"""
count = 0
files_code = list()
files_not_code = list()
if len(files_changed) < 1:
log.error("No files changed")
return None, list(), list()
for filename in files_changed:
# cannot contain 'test' or 'tests' in path
if not re.search(r'test', filename):
# if ends with ".java", needs to have "main"
if re.search(r'\.java$', filename) and re.search(r'src', filename):
count += 1
files_code.append(filename)
# if is a python file
elif re.search(r'\.pyx?$', filename):
count += 1
files_code.append(filename)
else:
files_not_code.append(filename)
files_actually_changed = len(all_files_changed)
if files_actually_changed > 0:
confidence = count / files_actually_changed
else:
confidence = 0.0
return confidence, files_code, files_not_code
def classify_test(file_modified=None):
"""
classify if the pair is test related
:param file_modified: the list of file has been modified
:return: test-related or not, confidence, files_not_test
"""
file_modified = [] if not file_modified else file_modified
confidence, files_test, files_not_test = is_test(file_modified)
if not confidence or confidence == 0.0:
return False, confidence, files_not_test
else:
return True, confidence, files_not_test
def classify_build(remain_files=None, file_modified=None):
"""
classify if the pair is build related
:param remain_files: the remainning list of files
:param file_modified: the list of file has been modified
:return: build-related or not, confidence, files_not_build
"""
remain_files = [] if not remain_files else remain_files
confidence, files_build, files_not_build = is_dependency(remain_files, file_modified)
if not confidence or confidence == 0.0:
return False, confidence, files_not_build
else:
return True, confidence, files_not_build
def classify_code(remain_files=None, file_modified=None):
"""
classify if the pair is code related
:param remain_files: the remainning list of files
:param file_modified: the list of file has been modified
:return: code-related or not, confidence
"""
remain_files = [] if not remain_files else remain_files
confidence, files_code, files_not_code = is_code(remain_files, file_modified)
if not confidence or confidence == 0.0:
return False, confidence
else:
return True, confidence
def process_logs(root, file_list):
"""
Returns contents of the failed log as a list
:param root: directory
:param file_list: [failed log, passed log]
:return: list
"""
file_list.sort()
try:
with open(os.path.join(root, file_list[1])) as passed_file:
passed = passed_file.readlines()
passed = list(filter(None, [line.strip() for line in passed]))
with open(os.path.join(root, file_list[0])) as failed_file:
failed = failed_file.readlines()
failed = list(filter(None, [line.strip() for line in failed]))
except OSError as e:
log.error(e)
return None
if "Done. Your build exited with 0." not in passed[-1]:
# error-condition, skip classification
if "Done. Your build exited with 0." not in failed[-1]:
return None
else:
# passed and failed got interchanged
return passed
return failed
def detect_lang(failed_log, quiet):
build_lang = None
py_version = None
if type(failed_log) is not list:
print(failed_log)
for line in failed_log:
if type(line) is not str:
print(line)
continue
if "Build language: java" in line:
build_lang = 'java'
break
elif "Build language: python" in line:
build_lang = 'python'
py_version = None
if build_lang == 'python' and re.search(r"Python ([\d\.]+)", line):
py_version = re.search(r"Python ([\d\.]+)", line).groups()[0]
break
if build_lang == 'java':
if not quiet:
print("Lang is java")
# java processing
return 0, {'language': "java"}
elif build_lang == 'python':
# python processing
if not quiet:
print("Lang is python")
if py_version:
if not quiet:
print("Version is ", py_version)
return 0, {'language': "python", "version": py_version}
return 0, {'language': "python"}
else:
if not quiet:
print("Error: build language not retrieved. Exiting")
return -1, None
def update_error_dict(build_lang, err, regex, line, error_list, user_defined, non_std_list, error_dict):
if build_lang == "python" and re.search(r"except " + regex, line):
# Adding exception for python
return
for e in err:
if e in error_list or e in user_defined or e in non_std_list:
error_dict[e] = error_dict.get(e, 0) + 1
elif e not in not_errors:
user_defined.add(e)
error_dict[e] = 1
# For code errors: detects all exceptions or errors (see err_regex) in failed Java log
def get_java_error_data(failed_log: list, error_list: list, non_std_list: list):
"""
:param failed_log: failed_log contents as a list
:param error_list: list of standard Java errors
:param non_std_list: list of nonstandard Java errors
:return: error_dict, user_defined, std_error, common_error, user_error
Finds exceptions/errors that cause test failures in Java programs (using Maven, Gradle, or Ant).
These consist of all errors directly preceded by an error indicator such as "<<< ERROR!",
and all subsequent errors in the corresponding stack trace (preceded by "Caused by:").
For example, the following has 1 IOException and 1 NullPointerException that would be counted:
testSomethingOrOther(foo.bar.FooBar) Time elapsed: 3.703 sec <<< ERROR!
java.io.IOException: [...]
at [...]
Caused by: java.lang.NullPointerException: [...]
at [...]
"""
build_lang = 'java'
error_dict = dict()
user_defined = set()
std_error = common_error = user_error = 0
basic_err_regex = r"[A-Za-z\.\$]+(\.|\$)([A-Za-z]+)(: |; |:$|\s*$| at )"
err_indicator = [r"<<< ERROR!\s*\Z",
r"<<< FAILURE!\s*\Z",
r"\S+ FAILED\s*\Z",
r"\[junit\]\s+Caused an ERROR\s*\Z",
r"\[junit\]\s+FAILED\s*\Z",
r"An exception has occurred in the compiler"]
err_regex = [r"^\s*" + basic_err_regex,
r"(ThreadDeath)([^\w\.]|$)",
r"^\s*Caused by: " + basic_err_regex,
r"\[[A-Za-z]+\]\s*" + basic_err_regex,
r"\[[A-Za-z]+\]\s*Caused by: " + basic_err_regex]
count_causedbys = False
saved_err = []
line_idx = 0
while line_idx < len(failed_log):
line = failed_log[line_idx]
# Count errors preceded by an error indicator ("<<< ERROR!" or equivalent)
for regex in err_indicator:
if line_idx + 1 >= len(failed_log) or not re.search(regex, line):
continue
# Since there is an error indicator, a stack trace has started. Start counting exceptions preceded by
# 'Caused by:'.
count_causedbys = True
for r in err_regex:
# Special case: Ant puts the exception name 2 lines after the error indicator, not 1.
if (regex == err_indicator[3] or regex == err_indicator[4]) and line_idx + 2 < len(failed_log):
e = re.search(r, failed_log[line_idx + 2])
if e:
line_idx += 1
# Default case (Maven and Gradle)
else:
e = re.search(r, failed_log[line_idx + 1])
if e:
# If the last stack trace ended with java.lang.Exception or java.lang.Error, add it to the dict
if saved_err:
update_error_dict(build_lang, saved_err, regex, failed_log[line_idx + 1], error_list,
user_defined, non_std_list,
error_dict)
e = [e.groups()[1]]
# Don't count java.lang.Exception or java.lang.Error unless it's at the end of a stack trace
if e == ['Exception'] or e == ['Error']:
saved_err = e
else:
saved_err = []
update_error_dict(build_lang, e, regex, failed_log[line_idx + 1], error_list, user_defined,
non_std_list,
error_dict)
line_idx += 2
break
if line_idx >= len(failed_log):
break
line = failed_log[line_idx]
# Look for "Caused by:" errors and errors that don't cause a test failure
for regex in err_regex:
e = re.search(regex, line)
# Count errors preceded by "Caused by:",
# but only if they are part of a stacktrace headed by an error indicator
if count_causedbys and re.search(r"Caused by:", line):
# Special case: Gradle puts the "Caused by:" on its own line, and the actual exception on the next line
if not e and line_idx + 1 < len(failed_log):
e = re.search(regex, failed_log[line_idx + 1])
if e:
line_idx += 1
line = failed_log[line_idx]
if e:
e = [e.groups()[1]]
# Don't count java.lang.Exception or java.lang.Error unless it's at the end of a stack trace
if e == ['Exception'] or e == ['Error']:
saved_err = e
else:
saved_err = []
update_error_dict(build_lang, e, regex, line, error_list, user_defined, non_std_list,
error_dict)
break
# An error not preceded by "Caused by:" indicates a new stacktrace.
# Since it wasn't caught by the first FOR loop, it doesn't have an error indicator.
# Therefore, don't count it or any "Caused by:" errors after it.
elif e:
# If the last stack trace ended with java.lang.Exception or java.lang.Error, add it to the dict
if saved_err:
update_error_dict(build_lang, saved_err, regex, line, error_list, user_defined, non_std_list,
error_dict)
count_causedbys = False
line_idx += 1
# If the last stack trace ended with java.lang.Exception or java.lang.Error, add it to the dict
if saved_err:
update_error_dict(build_lang, saved_err, regex, line, error_list, user_defined, non_std_list, error_dict)
return error_dict, user_defined, std_error, common_error, user_error
# For code errors: detects all exceptions or errors (see err_regex) in failed Python log
def get_python_error_data(failed_log: list, error_list: list, non_std_list: list):
"""
:param failed_log: failed_log contents as a list
:param error_list: list of standard Python errors
:param non_std_list: list of nonstandard Python errors
:return: error_dict, user_defined, std_error, common_error, user_error
Finds exceptions/errors that cause test failures in Python programs (using unittest or pytest).
These consist of all errors listed in unittest "ERROR" and "FAILURE" traces, and
all errors in the "=== ERRORS ===" and "=== FAILURES ===" sections of pytest logs.
For example, the following has 1 UnboundLocalError that would be counted:
======================================================================
ERROR: test_CRYPT (gluon.tests.test_validators.TestValidators)
----------------------------------------------------------------------
Traceback (most recent call last):
[...]
UnboundLocalError: local variable 'v' referenced before assignment
NOTE: This does NOT count exceptions that are only found in pytest's captured
stdout/stderr calls. While they do sometimes provide useful information, they
are also a source of many false positives (e.g. test exceptions) that we'd
prefer to avoid.
"""
build_lang = 'python'
error_dict = dict()
user_defined = set()
std_error = common_error = user_error = 0
# Strip ANSI color codes from lines to make the regex simpler
# Taken from https://stackoverflow.com/a/14693789
ansi_escape = re.compile(r'\x1B[@-_][0-?]*[ -/]*[@-~]', re.M)
noansi_log = [ansi_escape.sub('', line) for line in failed_log]
# This regex matches any valid Python identifier: any string of word characters
# (alphanumerics and the underscore) that does not start with a digit
identifier_regex = r"(?!\d)\w+"
err_indicator = [r"^ERROR: ",
r"^FAIL: ",
r"E\s+Traceback \(most recent call last\):",
r"data: .*\.test:\d+:\Z",
r"^>\s+.+$\Z",
r"^\.?Traceback \(most recent call last\):"]
sameline_err_indicator = [r"\S*\.[a-z]+:\d+: " + identifier_regex + r"\Z"]
err_collecting_indicator = [r"^(E\s+)?([A-Za-z]+Error)"]
err_regex = [r"^(" + identifier_regex + r"\.)*(" + identifier_regex + r")(: |:?\Z)",
r"^E\s+(" + identifier_regex + r"\.)*(" + identifier_regex + r")(: |\Z)",
r":\d+: ()(" + identifier_regex + r")\Z",
r"^()(ImportError) while importing"]
look_for_err = False
sameline_err = False
failed_tests_started = False
err_found_this_test = False
found_err = False
err_collecting = False
line_idx = -1
while line_idx + 1 < len(noansi_log):
line_idx += 1
line = noansi_log[line_idx]
# If the line starts with 'Traceback (most recent call last):'
if re.search(err_indicator[-1], line):
found_err = True
if not failed_tests_started and not found_err:
failed_tests_started = bool(re.search(r"={35}( FAILURES |= ERRORS =)?={35}", line))
continue
# This regex indicates the start of a failed pytest test. There is a specific error indicator that we should
# only consider if no errors have been found in a specific test; otherwise, that error is redundant.
if re.search(r"^_* (\[doctest\] )?(?!summary)[\w\.\/]+(\[.+\])?\s?_*\Z", line):
err_found_this_test = False
err_collecting = False
continue
# This regex matches the start of a part of a pytest log indicating that pytest encountered an error collecting
# a test. (This is usually due to a SyntaxError or an ImportError.)
# The errors listed in this part of a log use some special syntax, and the regex that captures them (found in
# err_collecting_indicator) is too broad to be used elsewhere, so it is only considered if err_collecting is
# True.
if re.search(r"^_* ERROR collecting [\w\.\/]+(\[.+\])?\s?_*\Z", line):
err_collecting = True
continue
all_indicators = err_indicator + sameline_err_indicator + (err_collecting_indicator if err_collecting else [])
for regex in all_indicators:
if not re.search(regex, line) or line_idx + 1 >= len(noansi_log) or (
regex in sameline_err_indicator and err_found_this_test):
continue
if regex == err_indicator[-1] and failed_tests_started:
continue
if regex in (sameline_err_indicator + err_collecting_indicator):
sameline_err = True
else:
line_idx += 1
look_for_err = True
break
line = noansi_log[line_idx]
try:
if look_for_err:
for regex in err_regex:
e = re.search(regex, line)
if e:
e = [e.groups()[1]]
err_found_this_test = True
update_error_dict(build_lang, e, regex, line, error_list, user_defined, non_std_list,
error_dict)
if not (line_idx + 1 < len(noansi_log) and noansi_log[line_idx + 1] ==
'Traceback (most recent call last):'):
look_for_err = sameline_err = found_err = False
break
else:
if sameline_err:
# The line matched a regex in sameline_err_indicator, but it couldn't find a valid exception
# on that line. Continuing to look for exceptions on subsequent lines may cause false positives.
look_for_err = sameline_err = False
except IndexError:
pass
return error_dict, user_defined, std_error, common_error, user_error
# For code errors: detects all exceptions or errors (see err_regex) in failed log
def process_error(build_lang: str = None, failed_log: list = None):
"""
:param build_lang: python or java
:param failed_log: failed_log contents as a list
:return: error_dict, userdefined, confidence
Finds exceptions/errors that cause a test failure.
See get_java_error_data() or get_python_error_data() for specifics.
"""
if not build_lang or not failed_log:
return -1, -1
exception_dict = {
'python': [python_exceptions, python_nonstd],
'java': [java_all, java_nonstd]
}
# error_list = exception_dict[build_lang['language']]
error_list = exception_dict[build_lang][0]
# non_std_list = exception_dict[build_lang['version']]
non_std_list = exception_dict[build_lang][1]
user_defined = set()
error_dict = dict()
std_error = common_error = user_error = 0
if build_lang == 'java':
error_dict, user_defined, std_error, common_error, user_error = get_java_error_data(failed_log, error_list,
non_std_list)
elif build_lang == 'python':
error_dict, user_defined, std_error, common_error, user_error = get_python_error_data(failed_log, error_list,
non_std_list)
for e in error_dict:
if e in error_list:
std_error += 1 # error_dict.get(e,0)
elif e in non_std_list:
common_error += 1 # error_dict.get(e,0)
elif e in user_defined:
user_error += 1 # error_dict.get(e,0)
total_count = std_error + common_error + user_error
if total_count > 0:
confidence = (std_error + (0.6 * common_error) + (0.3 * user_error)) / total_count
else:
confidence = 0.0
return error_dict, list(user_defined), confidence # notdetected
# Detects language of repo, as well as version (if python)
def main(args=None):
args = dict() if not args else args
t_start = time.time()
bugswarm_sandbox_path = os.getenv('HOME') + procutils.CONTAINER_SANDBOX
final_classification = dict()
final_error_artifact = {'python': dict(), 'java': dict()}
all_user_defined = {'python': dict(), 'java': dict()}
filter_count = 0
processed_count = 0
# Reset all result files
files = [
'results/test/not_test',
'results/test/reports_test',
'results/test/reports_test.tsv',
'results/build/not_build',
'results/build/reports_build',
'results/build/reports_build.tsv',
'results/code/reports_code.tsv',
'results/code/not_code',
'results/code/not_processed']
for file in files:
try:
os.remove(file)
except FileNotFoundError:
pass
filtered_tags_file = args.get('filter') or 'tags/filter_tags'
with open(filtered_tags_file) as f:
filtered_tags = f.readlines()
filtered_tags = [tag.strip() for tag in filtered_tags]
for root, dirs, files in os.walk(bugswarm_sandbox_path):
if not root.count("/") == 4: # checking depth
if not args.get('quiet'):
print("Incorrect depth: {} not processed".format(root))
continue
if not files:
if not args.get('quiet'):
print("{} doesn't contain files ".format(root))
continue
elif "diff.txt" not in files:
if not args.get('quiet'):
print("{} doesn't contain diff.txt".format(root))
continue
elif "cloc.csv" not in files:
if not args.get('quiet'):
print("{} doesn't contain cloc.csv".format(root))
continue
image_tag = re.sub(bugswarm_sandbox_path + "/", '', root)
# Filter out tags outside of list
if image_tag not in filtered_tags:
filter_count += 1
continue
processed_count += 1
# Extract data from files
files_changed, files_deleted, files_added = process_diff(root + "/diff.txt")
failed_log = process_logs(root, files)
if not failed_log:
if not args.get('quiet'):
print(image_tag + " not processed, no failed log detected.")
continue
error, build_lang = detect_lang(failed_log, quiet=args.get('quiet'))
main_sloc, sloc, num_main_files, num_files = process_loc(root + "/cloc.csv",
lang=build_lang.get('language', None))
# CLASSIFICATION
files_modified = []
files_modified.extend(files_changed)
files_modified.extend(files_deleted)
files_modified.extend(files_added)
files_modified = list(filter(lambda x: '.git' not in x, files_modified))
is_test, test_confidence, remain_files = classify_test(files_modified)
is_build, build_confidence, remain_files = classify_build(remain_files, files_modified)
is_code, code_confidence = classify_code(remain_files, files_modified)
error_dict, userdefined, confidence = process_error(build_lang.get('language', None), failed_log)
# Add to error lists
for e in userdefined:
all_user_defined[build_lang.get('language')][e] = all_user_defined[build_lang.get('language')].get(e, 0) + 1
for e in error_dict:
final_error_artifact[build_lang.get('language')][e] = final_error_artifact[build_lang.get('language')].get(
e, 0) + 1
# Add to final classification file
final_classification[image_tag] = dict()
final_classification[image_tag]['language'] = build_lang.get('language', None)
final_classification[image_tag]['type'] = dict()
final_classification[image_tag]['diffcount'] = len(files_changed + files_deleted + files_added)
final_classification[image_tag]['lang_loc'] = main_sloc
final_classification[image_tag]['total_loc'] = sloc
final_classification[image_tag]['lang_files'] = num_main_files
final_classification[image_tag]['total_files'] = num_files
if is_test:
final_classification[image_tag]['type']['TEST'] = {'name': 'TEST', 'value': test_confidence}
if is_build:
final_classification[image_tag]['type']['BUILD'] = {'name': 'BUILD', 'value': build_confidence}
if is_code:
if args.get('exclude_build') and build_confidence == 1:
pass
elif args.get('exclude_test') and test_confidence == 1:
pass
else:
final_classification[image_tag]['type']['CODE'] = {'name': 'CODE', 'value': code_confidence,
'errors': error_dict}
t_end = time.time()
print("{} tags filtered out and {} tags processed".format(filter_count, processed_count))
print('Running all images took {}s'.format(t_end - t_start))
# Write all results to file
# Final output file
final_classification_filename = args.get('output') or 'final_results/classification.json'
with open(final_classification_filename, 'w') as f:
json.dump(final_classification, f)
# All errors detected with count
with open('final_results/error_artifact.json', 'w') as f:
json.dump(final_error_artifact, f)
# Same info in tsv format
with open('final_results/errors_artifact.tsv', 'w') as f:
for lang in final_error_artifact:
for e in final_error_artifact[lang]:
f.write("{}\t{}\t{}\n".format(lang, e, final_error_artifact[lang][e]))
# only standard errors
with open('final_results/errors_artifact_standard.tsv', 'w') as f:
for lang in final_error_artifact:
for e in final_error_artifact[lang]:
if e in python_exceptions or e in java_all:
f.write("{}\t{}\t{}\n".format(lang, e, final_error_artifact[lang][e]))
# Only userdefined/non-standard errors
with open('final_results/userdefined_errors.tsv', 'w') as f:
for lang in all_user_defined:
for e in all_user_defined[lang]:
f.write("{}\t{}\t{}\n".format(lang, e, all_user_defined[lang][e]))
# Final overall results
with open('final_results/results.tsv', 'w') as f:
f.write("IMAGE_TAG\tCATEGORY")
for image_tag in final_classification:
classes = list(filter(None, [category for category in final_classification[image_tag]['type']]))
f.write("\n{}\t{}".format(image_tag, ','.join(classes)))
with open('final_results/results_details.tsv', 'w') as f:
f.write("IMAGE_TAG\tLanguage\tTEST\tBUILD\tCODE\t")
for image_tag in final_classification:
test_confidence = 0
build_confidence = 0
code_confidence = 0
exception_list = list()
for category in final_classification[image_tag]['type']:
category = final_classification[image_tag]['type'][category]
if category.get('name') == 'TEST':
test_confidence = category.get('value')
elif category.get('name') == 'BUILD':
build_confidence = category.get('value')
elif category.get('name') == 'CODE':
code_confidence = category.get('value')
exception_list = category.get('errors', list())
f.write(
"\n{}\t{}\t{}\t{}\t{}".format(image_tag, final_classification[image_tag]['language'], test_confidence,
build_confidence, code_confidence, ', '.join(exception_list)))
print("All results written to file. Exiting. ")
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('-t', '--exclude-test', action='store_true', default=False,
help="Excludes 100%% test results from code")
parser.add_argument('-b', '--exclude-build', action='store_true', default=False,
help="Excludes 100%% build results from code")
parser.add_argument('-o', '--output', default=None, help="Specify name of output file")
parser.add_argument('-f', '--filter', default=None, help="File containing all filtered tags.")
parser.add_argument('-q', '--quiet', action='store_true', default=False,
help=" Will suppress all outputs except running time")
args = parser.parse_args()
sys.exit(main(vars(args)))
| 43.389851 | 121 | 0.583474 |
7b05c60e6d4fdf73165d7d39f2c0d7b402a0ad05 | 58 | py | Python | spikewidgets/widgets/agreementmatrixwidget/__init__.py | KnierimLab/spikewidgets | 5ee37a43df21676db646942141c60e9bde95362c | [
"MIT"
] | 6 | 2019-01-23T03:51:31.000Z | 2021-02-15T07:54:39.000Z | spikewidgets/widgets/agreementmatrixwidget/__init__.py | KnierimLab/spikewidgets | 5ee37a43df21676db646942141c60e9bde95362c | [
"MIT"
] | 52 | 2019-01-23T10:10:30.000Z | 2021-06-27T10:23:10.000Z | spikewidgets/widgets/agreementmatrixwidget/__init__.py | KnierimLab/spikewidgets | 5ee37a43df21676db646942141c60e9bde95362c | [
"MIT"
] | 7 | 2019-01-23T10:06:03.000Z | 2020-10-29T18:38:37.000Z | from .agreementmatrixwidget import plot_agreement_matrix
| 19.333333 | 56 | 0.896552 |
f0d9b41edc277fc7ab50190a6e4a9e94a1d795a2 | 618 | py | Python | contrib/qt_translations.py | dacash-official/dacash | 4022fbce0220a472f4ae39f06771750db446d083 | [
"MIT"
] | 1 | 2020-04-09T19:46:22.000Z | 2020-04-09T19:46:22.000Z | contrib/qt_translations.py | dacash-official/dacash | 4022fbce0220a472f4ae39f06771750db446d083 | [
"MIT"
] | 1 | 2020-05-04T02:02:15.000Z | 2020-05-04T02:02:15.000Z | contrib/qt_translations.py | dacash-official/dacash | 4022fbce0220a472f4ae39f06771750db446d083 | [
"MIT"
] | 4 | 2018-06-08T20:38:36.000Z | 2021-03-22T08:37:12.000Z | #!/usr/bin/env python
# Helpful little script that spits out a comma-separated list of
# language codes for Qt icons that should be included
# in binary DACash Core distributions
import glob
import os
import re
import sys
if len(sys.argv) != 3:
sys.exit("Usage: %s $QTDIR/translations $BITCOINDIR/src/qt/locale"%sys.argv[0])
d1 = sys.argv[1]
d2 = sys.argv[2]
l1 = set([ re.search(r'qt_(.*).qm', f).group(1) for f in glob.glob(os.path.join(d1, 'qt_*.qm')) ])
l2 = set([ re.search(r'dacash_(.*).qm', f).group(1) for f in glob.glob(os.path.join(d2, 'dacash_*.qm')) ])
print ",".join(sorted(l1.intersection(l2)))
| 26.869565 | 106 | 0.68123 |
72ebdee7be85a17b654fb8b655cf6dd87efa90e6 | 1,346 | py | Python | server/schemata/main_schema.py | fostroll/modelsrv0 | 0debc1d64734aafd5d4286397f9db530c7dd8719 | [
"CC0-1.0"
] | null | null | null | server/schemata/main_schema.py | fostroll/modelsrv0 | 0debc1d64734aafd5d4286397f9db530c7dd8719 | [
"CC0-1.0"
] | null | null | null | server/schemata/main_schema.py | fostroll/modelsrv0 | 0debc1d64734aafd5d4286397f9db530c7dd8719 | [
"CC0-1.0"
] | null | null | null | #from enum import Enum
from ipaddress import IPv4Address
#import os
from pydantic import DirectoryPath, FilePath, root_validator, validator
from typing import Dict, List, Union
from .base_schema import _BaseModel
from .user_schema import Users
from .model_schema import Model
config = {}
#class FormatEnum(str, Enum):
# torch = 'torch'
class Config(_BaseModel):
host: IPv4Address
port: int
'''model_directory: DirectoryPath
model_format: FormatEnum
model_name: Union[DirectoryPath, FilePath]
model_device: str'''
model: Union[FilePath, Dict]
users: Union[FilePath, Dict]
password_hash_schemes: Union[str, List[str]]
jwt_secret_key: str
jwt_algorithm: str
jwt_expire_minutes: int
@validator('password_hash_schemes')
def _validator_password_hash_schemes(cls, value):
return value if isinstance(value, list) else [value]
@validator('users')
def _validator_users(cls, value):
return Users.parse(value).__root__
@validator('model')
def _validator_model(cls, value):
return Model.parse(value)
'''@root_validator(pre=True)
def _root_validator(cls, values):
values['model_name'] = \
os.path.join(values.get('model_directory', ''), \
values.get('model_name', ''))
return values'''
| 24.925926 | 71 | 0.684993 |
4dd1678f6b2eb3c53f9d97692c3f105d3b2917da | 133 | py | Python | chapter_05_mathematics/section_5_1_decimal/5_7_decimal_precision.py | wuxiaofeng8764/P3SL_Example | 8ce1877af7372211b20836f799a8c44679577b7c | [
"MIT"
] | 3 | 2018-08-14T09:33:52.000Z | 2022-03-21T12:31:58.000Z | chapter_05_mathematics/section_5_1_decimal/5_7_decimal_precision.py | wuxiaofeng8764/P3SL_Example | 8ce1877af7372211b20836f799a8c44679577b7c | [
"MIT"
] | null | null | null | chapter_05_mathematics/section_5_1_decimal/5_7_decimal_precision.py | wuxiaofeng8764/P3SL_Example | 8ce1877af7372211b20836f799a8c44679577b7c | [
"MIT"
] | null | null | null | import decimal
d = decimal.Decimal('0.123456')
for i in range(1, 5):
decimal.getcontext().prec = i
print(i, ':', d, d * 1)
| 16.625 | 33 | 0.593985 |
b17fb018764726c0651da7567419b278c9eac416 | 488 | py | Python | rh_pathfinding/src/rh_pathfinding/ros/rosConstants.py | RhinohawkUAV/rh_ros | e13077060bdfcc231adee9731ebfddadcd8d6b4a | [
"MIT"
] | 4 | 2020-05-13T19:34:27.000Z | 2021-09-20T09:01:10.000Z | rh_pathfinding/src/rh_pathfinding/ros/rosConstants.py | RhinohawkUAV/rh_ros | e13077060bdfcc231adee9731ebfddadcd8d6b4a | [
"MIT"
] | null | null | null | rh_pathfinding/src/rh_pathfinding/ros/rosConstants.py | RhinohawkUAV/rh_ros | e13077060bdfcc231adee9731ebfddadcd8d6b4a | [
"MIT"
] | 2 | 2019-09-14T14:45:09.000Z | 2020-11-22T01:46:59.000Z | ROS_QUEUE_SIZE = 10
PATHFINDER_NODE_ID = "pathfinder"
PATHFINDER_SERVER_NODE = "action"
PATHFINDER_SERVER = "%s/%s" % (PATHFINDER_NODE_ID, PATHFINDER_SERVER_NODE)
# PATHFINDER_SERVER = "/rh/%s/%s" % (PATHFINDER_NODE_ID, PATHFINDER_SERVER_NODE)
PATHFINDER_INPUT_TOPIC = "%s/input" % PATHFINDER_NODE_ID
PATHFINDER_DEBUG_TOPIC = "%s/debug" % PATHFINDER_NODE_ID
SUBMIT_PROBLEM_SERVICE = "%s/submitProblem" % PATHFINDER_NODE_ID
STEP_PROBLEM_SERVICE = "%s/stepProblem" % PATHFINDER_NODE_ID
| 34.857143 | 80 | 0.795082 |
5b1ea51a4c5192c5a8961c52874a45304677a105 | 2,074 | py | Python | scripts/analytics/user_domain_events.py | gaybro8777/osf.io | 30408511510a40bc393565817b343ef5fd76ab14 | [
"Apache-2.0"
] | 628 | 2015-01-15T04:33:22.000Z | 2022-03-30T06:40:10.000Z | scripts/analytics/user_domain_events.py | gaybro8777/osf.io | 30408511510a40bc393565817b343ef5fd76ab14 | [
"Apache-2.0"
] | 4,712 | 2015-01-02T01:41:53.000Z | 2022-03-30T14:18:40.000Z | scripts/analytics/user_domain_events.py | Johnetordoff/osf.io | de10bf249c46cede04c78f7e6f7e352c69e6e6b5 | [
"Apache-2.0"
] | 371 | 2015-01-12T16:14:08.000Z | 2022-03-31T18:58:29.000Z | import pytz
import logging
from dateutil.parser import parse
from datetime import datetime, timedelta
from django.db.models import Q
from osf.models import OSFUser
from website.app import init_app
from framework.database import paginated
from scripts.analytics.base import EventAnalytics
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
class UserDomainEvents(EventAnalytics):
@property
def collection_name(self):
return 'user_domain_events'
def get_events(self, date):
""" Get all node logs from a given date for a 24 hour period,
ending at the date given.
"""
super(UserDomainEvents, self).get_events(date)
# In the end, turn the date back into a datetime at midnight for queries
date = datetime(date.year, date.month, date.day).replace(tzinfo=pytz.UTC)
logger.info('Gathering user domains between {} and {}'.format(
date, (date + timedelta(days=1)).isoformat()
))
user_query = (Q(date_confirmed__lt=date + timedelta(days=1)) &
Q(date_confirmed__gte=date) &
Q(username__isnull=False))
users = paginated(OSFUser, query=user_query)
user_domain_events = []
for user in users:
user_date = user.date_confirmed.replace(tzinfo=pytz.UTC)
event = {
'keen': {'timestamp': user_date.isoformat()},
'date': user_date.isoformat(),
'domain': user.username.split('@')[-1]
}
user_domain_events.append(event)
logger.info('User domains collected. {} users and their email domains.'.format(len(user_domain_events)))
return user_domain_events
def get_class():
return UserDomainEvents
if __name__ == '__main__':
init_app()
user_domain_events = UserDomainEvents()
args = user_domain_events.parse_args()
date = parse(args.date).date() if args.date else None
events = user_domain_events.get_events(date)
user_domain_events.send_events(events)
| 32.40625 | 112 | 0.66297 |
8ed67a03f2b5f8df19aed737eb8cc82e126650c3 | 11,056 | py | Python | openrasp_iast/core/model/new_request_model.py | r3aker/iast | 52e5689c371c29db6e18233be5597093c378774d | [
"Apache-2.0"
] | null | null | null | openrasp_iast/core/model/new_request_model.py | r3aker/iast | 52e5689c371c29db6e18233be5597093c378774d | [
"Apache-2.0"
] | null | null | null | openrasp_iast/core/model/new_request_model.py | r3aker/iast | 52e5689c371c29db6e18233be5597093c378774d | [
"Apache-2.0"
] | null | null | null | #!/usr/bin/env python3
# -*- coding: UTF-8 -*-
"""
Copyright 2017-2019 Baidu Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import os
import time
import peewee
import asyncio
import peewee_async
from core.model import base_model
from core.components import common
from core.components import exceptions
from core.components import rasp_result
from core.components.logger import Logger
from core.components.config import Config
from core.components.communicator import Communicator
class NewRequestModel(base_model.BaseModel):
def __init__(self, *args, **kwargs):
"""
初始化
"""
super(NewRequestModel, self).__init__(*args, **kwargs)
self._init_start_id()
def _create_model(self, db, table_prefix):
"""
创建数据model
"""
meta_dict = {
"database": db,
"table_name": table_prefix + "_" + "ResultList"
}
meta = type("Meta", (object, ), meta_dict)
model_dict = {
"id": peewee.AutoField(),
"data": self.LongTextField(),
# utf8mb4 编码下 1 char = 4 bytes，会导致peewee创建过长的列导致MariaDB产生 1071, Specified key was too long; 错误, max_length不使用255
"data_hash": peewee.CharField(unique=True, max_length=63),
# scan_status含义： 未扫描：0, 已扫描：1, 正在扫描：2, 扫描中出现错误: 3
"scan_status": peewee.IntegerField(default=0),
"time": peewee.IntegerField(default=common.get_timestamp),
"Meta": meta
}
self.ResultList = type("ResultList", (peewee.Model, ), model_dict)
return self.ResultList
def _init_start_id(self):
"""
初始化start_id为未扫描的最小id，未扫描时，值为0
Raises:
exceptions.DatabaseError - 数据库错误引发此异常
"""
query = self.ResultList.select(peewee.fn.MIN(self.ResultList.id)).where(
self.ResultList.scan_status != 1
)
try:
result = query.scalar()
except Exception as e:
Logger().critical("DB error in method _init_start_id!", exc_info=e)
if result is None:
self.start_id = 0
else:
self.start_id = result - 1
def reset_unscanned_item(self):
"""
重置未扫描的item的status为初始状态码(0)
Raises:
exceptions.DatabaseError - 数据库错误引发此异常
"""
try:
self.ResultList.update(scan_status=0).where(
self.ResultList.scan_status > 1).execute()
except Exception as e:
Logger().critical("DB error in method reset_unscanned_item!", exc_info=e)
def get_start_id(self):
"""
获取当前start_id
Returns:
start_id, int类型
"""
return self.start_id
async def put(self, rasp_result_ins):
"""
将rasp_result_ins序列化并插入数据表
Returns:
插入成功返回True, 重复返回False
Raises:
exceptions.DatabaseError - 数据库错误引发此异常
"""
try:
data = {
"data": rasp_result_ins.dump(),
"data_hash": rasp_result_ins.get_hash()
}
await peewee_async.create_object(self.ResultList, **data)
except peewee.IntegrityError as e:
return False
except asyncio.CancelledError as e:
raise e
except Exception as e:
Logger().critical("DB error in method put!", exc_info=e)
else:
return True
async def get_new_scan(self, count=1):
"""
获取多条未扫描的请求数据
Parameters:
count - 最大获取条数，默认为1
Returns:
获取的数据组成的list,每个item为一个dict, [{id:数据id, data:请求数据的json字符串} ... ]
Raises:
exceptions.DatabaseError - 数据库错误引发此异常
"""
result = []
try:
# 获取未扫描的最小id
query = self.ResultList.select(peewee.fn.MIN(self.ResultList.id)).where((
self.ResultList.id > self.start_id) & (
self.ResultList.scan_status == 0)
)
fetch_star_id = await peewee_async.scalar(query)
if fetch_star_id is None:
return []
# 将要获取的记录标记为扫描中
query = self.ResultList.update(
{self.ResultList.scan_status: 2}
).where((
self.ResultList.scan_status == 0) & (
self.ResultList.id > self.start_id)
).order_by(
self.ResultList.id
).limit(count)
row_count = await peewee_async.execute(query)
if (row_count == 0):
return result
# 获取标记的记录
query = self.ResultList.select().where((
self.ResultList.id >= fetch_star_id) & (
self.ResultList.scan_status == 2)
).order_by(
self.ResultList.id
).limit(row_count)
data = await peewee_async.execute(query)
for line in data:
result.append({
"id": line.id,
"data": rasp_result.RaspResult(line.data)
})
return result
except asyncio.CancelledError as e:
raise e
except Exception as e:
self._handle_exception("DB error in method get_new_scan!", e)
async def mark_result(self, last_id, failed_list):
"""
将id 小于等于 last_id的result标记为已扫描，更新star_id, 将failed_list中的id标记为失败
Parameters:
last_id - 已扫描的最大id
failed_list - 扫描中出现连接失败的url
Raises:
exceptions.DatabaseError - 数据库错误引发此异常
"""
if last_id > self.start_id:
try:
# 标记失败的扫描记录
query = self.ResultList.update({self.ResultList.scan_status: 3}).where((
self.ResultList.id <= last_id) & (
self.ResultList.id > self.start_id) & (
self.ResultList.id << failed_list)
)
await peewee_async.execute(query)
# 标记已扫描的记录
query = self.ResultList.update({self.ResultList.scan_status: 1}).where((
self.ResultList.id <= last_id) & (
self.ResultList.id > self.start_id) & (
self.ResultList.scan_status == 2)
)
await peewee_async.execute(query)
# 更新start_id
query = self.ResultList.select(peewee.fn.MAX(self.ResultList.id)).where((
self.ResultList.id > self.start_id) & (
self.ResultList.scan_status == 1)
)
result = await peewee_async.scalar(query)
except asyncio.CancelledError as e:
raise e
except Exception as e:
self._handle_exception("DB error in method mark_result!", e)
if result is not None:
self.start_id = result
async def get_scan_count(self):
"""
获取扫描进度
Returns:
total, count 均为int类型，total为数据总数，count为已扫描条数
Raises:
exceptions.DatabaseError - 数据库错误引发此异常
"""
try:
query = self.ResultList.select(
peewee.fn.COUNT(self.ResultList.id)).where(
self.ResultList.scan_status == 1)
result = await peewee_async.scalar(query)
if result is None:
scanned = 0
else:
scanned = result
query = self.ResultList.select(
peewee.fn.COUNT(self.ResultList.id)).where(
self.ResultList.scan_status == 3)
result = await peewee_async.scalar(query)
if result is None:
failed = 0
else:
failed = result
query = self.ResultList.select(
peewee.fn.COUNT(self.ResultList.id))
result = await peewee_async.scalar(query)
if result is None:
total = 0
else:
total = result
except asyncio.CancelledError as e:
raise e
except Exception as e:
self._handle_exception("DB error in method get_scan_count!", e)
return total, scanned, failed
async def get_last_time(self):
"""
获取最近一条记录的时间戳, 无记录时返回0
Returns:
int, 时间戳
Raises:
exceptions.DatabaseError - 数据库错误引发此异常
"""
query = self.ResultList.select().order_by(self.ResultList.time.desc()).limit(1)
try:
result = await peewee_async.execute(query)
data = await peewee_async.execute(query)
except asyncio.CancelledError as e:
raise e
except Exception as e:
self._handle_exception("DB error in method get_last_time!", e)
if len(data) == 0:
return 0
else:
return data[0].time
async def get_urls(self, page=1, status=0):
"""
获取指定状态的的url列表
Parameters:
page - int, 获取的页数，每页10条
status - int, url的状态 未扫描：0, 已扫描：1, 正在扫描：2, 扫描中出现错误: 3
Returns:
total, urls - total为数据总数, int类型，urls为已扫描的url, list类型, item形式为tuple (url对应id, url字符串)
Raises:
exceptions.DatabaseError - 数据库错误引发此异常
"""
if page <= 0:
page = 1
try:
query = self.ResultList.select(
peewee.fn.COUNT(self.ResultList.id)).where(
self.ResultList.scan_status == status)
result = await peewee_async.scalar(query)
if result is None:
total = 0
else:
total = result
query = self.ResultList.select().where(
self.ResultList.scan_status == status
).order_by(
self.ResultList.id
).offset((page - 1) * 10).limit(10)
data = await peewee_async.execute(query)
urls = []
for line in data:
url_id = line.id
rasp_result_ins = rasp_result.RaspResult(line.data)
url = rasp_result_ins.get_url()
urls.append((url_id, url))
return total, urls
except asyncio.CancelledError as e:
raise e
except Exception as e:
self._handle_exception("DB error in method get_urls!", e)
def drop_table(self):
"""
删除表时更新表状态
"""
super().drop_table()
Communicator().update_target_list_status()
| 30.4573 | 124 | 0.54839 |
94da8f6bb679e54501d4f59b626384e29f77cbc1 | 5,496 | py | Python | py/wiod/emissions.py | sonya/eea | b09502354eb6ce7975a21aa97dd3c812852b0626 | [
"Apache-2.0"
] | 1 | 2020-08-12T19:42:45.000Z | 2020-08-12T19:42:45.000Z | py/wiod/emissions.py | sonya/eea | b09502354eb6ce7975a21aa97dd3c812852b0626 | [
"Apache-2.0"
] | null | null | null | py/wiod/emissions.py | sonya/eea | b09502354eb6ce7975a21aa97dd3c812852b0626 | [
"Apache-2.0"
] | null | null | null | #
# Copyright 2012 Sonya Huang
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import common.config as common_config
from wiod import common, config
from common import matrixutils, sqlhelper
from common.plotutils import GNUPlot
env_series = "CO2"
plots = {}
marginal_plots = {}
series_specs = {
"CONS/Y": {
"title": "Total personal consumption / GDP",
"style": 'pointtype 8 linetype rgb "blue"', # empty triangle
},
"CONS/e": {
"title": "Emissions due to personal consumption / total emissions",
"style": 'pointtype 9 linetype rgb "blue"', # solid triangle
},
"EXP/Y": {
"title": "Gross exports / GDP",
"style": 'pointtype 6 linetype rgb "red"', # empty circle
},
"EXP/e": {
"title": "Emissions due to gross exports / total emissions",
"style": 'pointtype 7 linetype rgb "red"', # solid circle
},
}
mseries_specs = {
"pce": {
"title": "Direct emissions / per $ households",
"style": 'pointtype 8 linetype rgb "blue"', # empty triangle
},
"pce+": {
"title": "Direct + indirect / per $ households",
"style": 'pointtype 9 linetype rgb "blue"', # solid triangle
},
"exports": {
"title": "Direct emissions / $ gross export",
"style": 'pointtype 6 linetype rgb "red"', # empty circle
},
"exports+": {
"title": "Direct+indirect / $ gross export",
"style": 'pointtype 7 linetype rgb "red"', # solid circle
},
}
for year in config.STUDY_YEARS:
# show some output since this script takes awhile
print(year)
iogen = common.iogen_for_year(year)
envgen = common.envgen_for_year(year)
env_sectors = common.env_sectors_for_year(year)
for (country, country_name) in config.countries.items():
if country not in plots:
plots[country] = GNUPlot(
"%s_%s" % (env_series, country),
"%s in %s" % (env_series, country_name),
"%s-totals" % env_series)
plot = plots[country]
for (series, specs) in series_specs.items():
plot.set_series_style(specs["title"], specs["style"])
marginal_plots[country] = GNUPlot(
"%s_%s" % (env_series, country),
"%s in %s" % (env_series, country_name),
env_series)
mplot = marginal_plots[country]
for (series, specs) in mseries_specs.items():
mplot.set_series_style(specs["title"], specs["style"])
else:
mplot = marginal_plots[country]
plot = plots[country]
iogen.set_condition_args(country)
envgen.set_condition_args(country)
envgen.set_sectors(env_sectors)
sectors = iogen.get_sectors()
x = iogen.get_x(True)
L = iogen.get_L()
Y = iogen.get_Y(use_exchange_rate=True)
E = envgen.get_env_vector(env_series)
sel = common.get_io_harmonizer(iogen)
# let J be intensity vector
# for sectors that exist in env data but not in io data
# (primarily "households with employed persons") just ignore
J = E.divide(sel.matrix_mult(x), ignore_zero_denom=True)
JsL = J.square_matrix_from_diag().matrix_mult(sel).matrix_mult(L)
total_emissions = JsL.matrix_mult(Y.get_total()).sum()
pce_emissions = JsL.matrix_mult(Y.get_pce())
export_emissions = JsL.matrix_mult(Y.get_exports())
gdp = Y.get_total().sum()
plot.set_value(series_specs["CONS/Y"]["title"],
year, Y.get_pce().sum() / gdp)
plot.set_value(series_specs["EXP/Y"]["title"],
year, Y.get_exports().sum() / gdp)
plot.set_value(series_specs["CONS/e"]["title"],
year, pce_emissions.sum() / total_emissions)
plot.set_value(series_specs["EXP/e"]["title"],
year, export_emissions.sum() / total_emissions)
# averages
pce_intensity = sel.matrix_mult(Y.get_marginal_pce()).mult(J)
export_intensity = sel.matrix_mult(Y.get_marginal_export()).mult(J)
mplot.set_value(mseries_specs["pce"]["title"],
year, pce_intensity.sum())
mplot.set_value(mseries_specs["exports"]["title"],
year, export_intensity.sum())
iY = Y.matrix_postmult(L)
pce_intensity = sel.matrix_mult(iY.get_marginal_pce()).mult(J)
export_intensity = sel.matrix_mult(iY.get_marginal_export()).mult(J)
mplot.set_value(mseries_specs["pce+"]["title"],
year, pce_intensity.sum())
mplot.set_value(mseries_specs["exports+"]["title"],
year, export_intensity.sum())
for (country, plot) in plots.items():
plot.write_tables()
plot.generate_plot()
for (country, plot) in marginal_plots.items():
plot.write_tables()
plot.generate_plot()
| 36.157895 | 76 | 0.606441 |
7d0d7545292693e131ccd73278a575d1e3ea75fc | 1,852 | py | Python | screws/numerical/_3d_space/Jacobian_31.py | mathischeap/mifem | 3242e253fb01ca205a76568eaac7bbdb99e3f059 | [
"MIT"
] | 1 | 2020-10-14T12:48:35.000Z | 2020-10-14T12:48:35.000Z | screws/numerical/_3d_space/Jacobian_31.py | mathischeap/mifem | 3242e253fb01ca205a76568eaac7bbdb99e3f059 | [
"MIT"
] | null | null | null | screws/numerical/_3d_space/Jacobian_31.py | mathischeap/mifem | 3242e253fb01ca205a76568eaac7bbdb99e3f059 | [
"MIT"
] | null | null | null |
from abc import ABC
import numpy as np
from screws.numerical._1d_space.derivative import NumericalDerivative_fx
class NumericalJacobian_xyz_t_31(ABC):
"""
For a mapping: ``XY(t) = (x, y, z) = (X(t), Y(t), Z(t))``, we compute ``dx/dt``, ``dy/dt``, and ``dz/dt``.
"""
def __init__(self, func31):
""" """
self._func31_ = func31
def ___evaluate_func31_for_x_t___(self, t):
return self._func31_(t)[0]
def ___evaluate_func31_for_y_t___(self, t):
return self._func31_(t)[1]
def ___evaluate_func31_for_z_t___(self, t):
return self._func31_(t)[2]
def scipy_derivative(self, t, dt=1e-6, n=1, order=3):
Xt = NumericalDerivative_fx(self.___evaluate_func31_for_x_t___, t,
dx=dt, n=n, order=order).scipy_derivative()
Yt = NumericalDerivative_fx(self.___evaluate_func31_for_y_t___, t,
dx=dt, n=n, order=order).scipy_derivative()
Zt = NumericalDerivative_fx(self.___evaluate_func31_for_z_t___, t,
dx=dt, n=n, order=order).scipy_derivative()
return Xt, Yt, Zt
def check_Jacobian(self, Jacobian, t, tolerance=1e-6):
"""Check if ``Jacobian(t) == self.scipy_derivative(t)`` at nodes ``t``."""
self_J = self.scipy_derivative(t)
give_J = Jacobian(t)
result = [None, None, None]
for i in range(3):
absolute_error = np.max(np.abs(self_J[i]-give_J[i]))
if absolute_error < tolerance:
result[i] = True
else:
relative_error = np.max(np.abs((self_J[i]-give_J[i])/self_J[i]))
if relative_error < tolerance:
result[i] = True
else:
result[i] = False
return tuple(result) | 37.795918 | 110 | 0.571274 |
3fd655839f952ec078beb82e83d4658cd715c49e | 436 | py | Python | binderhub/config.py | jupyterhub/builderhub | 37551212e47f515186b62fa02443f50b6e7b5839 | [
"BSD-3-Clause"
] | null | null | null | binderhub/config.py | jupyterhub/builderhub | 37551212e47f515186b62fa02443f50b6e7b5839 | [
"BSD-3-Clause"
] | null | null | null | binderhub/config.py | jupyterhub/builderhub | 37551212e47f515186b62fa02443f50b6e7b5839 | [
"BSD-3-Clause"
] | null | null | null | from .base import BaseHandler
class ConfigHandler(BaseHandler):
"""Serve config"""
def generate_config(self):
config = dict()
for repo_provider_class_alias, repo_provider_class in self.settings[
"repo_providers"
].items():
config[repo_provider_class_alias] = repo_provider_class.labels
return config
async def get(self):
self.write(self.generate_config())
| 25.647059 | 76 | 0.66055 |
fc5a039d7e12cae6e0f3c33eb62714e68b69f684 | 32,296 | py | Python | api/src/tests/application/functional_tests/housing_units/test_endpoints.py | iliaskaras/housing-units | 2b0d78fcb42629ce7530b2da556ebd550cc7bec8 | [
"MIT"
] | null | null | null | api/src/tests/application/functional_tests/housing_units/test_endpoints.py | iliaskaras/housing-units | 2b0d78fcb42629ce7530b2da556ebd550cc7bec8 | [
"MIT"
] | null | null | null | api/src/tests/application/functional_tests/housing_units/test_endpoints.py | iliaskaras/housing-units | 2b0d78fcb42629ce7530b2da556ebd550cc7bec8 | [
"MIT"
] | null | null | null | import pytest
from fastapi.testclient import TestClient
from tests.application.functional_tests.housing_units.utils import get_cleaned_housing_units_response
from application.main import app
client = TestClient(app)
@pytest.mark.asyncio
async def test_filter_housing_units_get_request(
populate_users, populate_housing_units, stub_housing_units, admin_jwt_token
):
response = client.get("/housing-units", headers={"Authorization": "Bearer {}".format(admin_jwt_token)})
assert response.status_code == 200
response_json = response.json()
total: int = response_json.get('total')
assert total == len(stub_housing_units)
housing_units = get_cleaned_housing_units_response(response_json.get('housing_units'))
assert housing_units == [
{
'project_id': 'project id 1', 'street_name': 'street name test 1', 'borough': 'Queens', 'postcode': 1,
'reporting_construction_type': 'construction type test 1', 'total_units': 2
},
{
'project_id': 'project id 2', 'street_name': 'street name test 2', 'borough': 'Brooklyn', 'postcode': 2,
'reporting_construction_type': 'construction type test 2', 'total_units': 4
},
{
'project_id': 'project id 3', 'street_name': 'street name test 3', 'borough': 'Staten Island',
'postcode': 3, 'reporting_construction_type': 'construction type test 3', 'total_units': 6
},
{
'project_id': 'project id 4', 'street_name': 'street name test 4', 'borough': 'Manhattan', 'postcode': 4,
'reporting_construction_type': 'construction type test 4', 'total_units': 8
},
{
'project_id': 'project id 5', 'street_name': 'street name test 5', 'borough': 'Bronx', 'postcode': 5,
'reporting_construction_type': 'construction type test 5', 'total_units': 10
},
{
'project_id': 'project id 6', 'street_name': 'street name test 1', 'borough': 'Queens', 'postcode': 1,
'reporting_construction_type': 'construction type test 1', 'total_units': 12
},
{
'project_id': 'project id 7', 'street_name': 'street name test 2', 'borough': 'Brooklyn', 'postcode': 2,
'reporting_construction_type': 'construction type test 2', 'total_units': 14
},
{
'project_id': 'project id 11', 'street_name': 'street name test 1', 'borough': 'Queens', 'postcode': 1,
'reporting_construction_type': 'construction type test 1', 'total_units': 16
},
{
'project_id': 'project id 8', 'street_name': 'street name test 3', 'borough': 'Staten Island',
'postcode': 3, 'reporting_construction_type': 'construction type test 3', 'total_units': 16
},
{
'project_id': 'project id 9', 'street_name': 'street name test 4', 'borough': 'Manhattan', 'postcode': 4,
'reporting_construction_type': 'construction type test 4', 'total_units': 18
},
{
'project_id': 'project id 10', 'street_name': 'street name test 5', 'borough': 'Bronx', 'postcode': 5,
'reporting_construction_type': 'construction type test 5', 'total_units': 20
},
{
'project_id': 'project id 12', 'street_name': 'street name test 1', 'borough': 'Queens', 'postcode': 1,
'reporting_construction_type': 'construction type test 1', 'total_units': 25
},
{
'project_id': 'project id 12', 'street_name': 'street name test 1', 'borough': 'Queens', 'postcode': 1,
'reporting_construction_type': 'construction type test 1', 'total_units': 25
}
]
@pytest.mark.asyncio
async def test_filter_housing_units_get_request_called_by_customer(
populate_users, populate_housing_units, stub_housing_units, customer_jwt_token
):
response = client.get(
"/housing-units?street_name=street name test 5&num_units_min=15",
headers={"Authorization": "Bearer {}".format(customer_jwt_token)},
)
assert response.status_code == 200
response_json = response.json()
total: int = response_json.get('total')
assert total == 1
housing_units = get_cleaned_housing_units_response(response_json.get('housing_units'))
assert housing_units == [
{
'project_id': 'project id 10', 'street_name': 'street name test 5', 'borough': 'Bronx', 'postcode': 5,
'reporting_construction_type': 'construction type test 5', 'total_units': 20
}
]
@pytest.mark.asyncio
async def test_filter_housing_units_get_request_called_by_admin(
populate_users, populate_housing_units, stub_housing_units, admin_jwt_token
):
response = client.get(
"/housing-units?street_name=street name test 5&num_units_min=15",
headers={"Authorization": "Bearer {}".format(admin_jwt_token)},
)
assert response.status_code == 200
response_json = response.json()
total: int = response_json.get('total')
assert total == 1
housing_units = get_cleaned_housing_units_response(response_json.get('housing_units'))
assert housing_units == [
{
'project_id': 'project id 10', 'street_name': 'street name test 5', 'borough': 'Bronx', 'postcode': 5,
'reporting_construction_type': 'construction type test 5', 'total_units': 20
}
]
@pytest.mark.asyncio
async def test_filter_housing_units_get_request_raise_authorization_error_when_jwt_not_provided(
populate_users, populate_housing_units, stub_housing_units
):
response = client.get(
"/housing-units?street_name=street name test 5&num_units_min=15"
)
assert response.status_code == 403
assert response.json() == {'detail': 'Not authenticated'}
@pytest.mark.asyncio
async def test_filter_housing_units_get_request_raise_error_when_num_units_min_is_greater_than_max(
populate_users, populate_housing_units, stub_housing_units, admin_jwt_token
):
response = client.get(
"/housing-units?street_name=street name test 5&num_units_min=15&num_units_max=10",
headers={"Authorization": "Bearer {}".format(admin_jwt_token)},
)
assert response.status_code == 400
assert response.json() == {
"Detail": "The provided number of maximum units can't be smaller than the number of minimum units",
"Type": "ValidationError"
}
@pytest.mark.asyncio
async def test_retrieve_housing_unit_get_request_called_by_customer(
populate_users, populate_housing_units, stub_housing_units, customer_jwt_token
):
response = client.get(
"/housing-units/{}".format(stub_housing_units[0].uuid),
headers={"Authorization": "Bearer {}".format(customer_jwt_token)}
)
assert response.status_code == 200
response_json = response.json()
assert response_json == {
'uuid': stub_housing_units[0].uuid,
'project_id': 'project id 1', 'street_name': 'street name test 1', 'borough': 'Queens', 'postcode': 1,
'reporting_construction_type': 'construction type test 1', 'total_units': 2, 'project_name': 'project name 1',
'project_start_date': '2018-12-25T11:27:53', 'project_completion_date': None,
'building_id': None, 'house_number': None, 'bbl': None, 'bin': None, 'community_board': 'community board 1',
'council_district': None, 'census_tract': None, 'neighborhood_tabulation_area': None, 'latitude': None,
'longitude': None, 'latitude_internal': None, 'longitude_internal': None, 'building_completion_date': None,
'extended_affordability_status': 'extended affordability status 1',
'prevailing_wage_status': 'prevailing wage status 1', 'extremely_low_income_units': 0,
'very_low_income_units': 0, 'low_income_units': 0, 'moderate_income_units': 0, 'middle_income_units': 2,
'other_income_units': 0, 'studio_units': 0, 'one_br_units': 1, 'two_br_units': 0, 'three_br_units': 1,
'four_br_units': 0, 'five_br_units': 0, 'six_br_units': 0, 'unknown_br_units': 0, 'counted_rental_units': 1,
'counted_homeownership_units': 1, 'all_counted_units': 2
}
@pytest.mark.asyncio
async def test_retrieve_housing_unit_get_request_called_by_admin(
populate_users, populate_housing_units, stub_housing_units, admin_jwt_token
):
response = client.get(
"/housing-units/{}".format(stub_housing_units[0].uuid),
headers={"Authorization": "Bearer {}".format(admin_jwt_token)}
)
assert response.status_code == 200
response_json = response.json()
assert response_json == {
'uuid': stub_housing_units[0].uuid,
'project_id': 'project id 1', 'street_name': 'street name test 1', 'borough': 'Queens', 'postcode': 1,
'reporting_construction_type': 'construction type test 1', 'total_units': 2, 'project_name': 'project name 1',
'project_start_date': '2018-12-25T11:27:53', 'project_completion_date': None,
'building_id': None, 'house_number': None, 'bbl': None, 'bin': None, 'community_board': 'community board 1',
'council_district': None, 'census_tract': None, 'neighborhood_tabulation_area': None, 'latitude': None,
'longitude': None, 'latitude_internal': None, 'longitude_internal': None, 'building_completion_date': None,
'extended_affordability_status': 'extended affordability status 1',
'prevailing_wage_status': 'prevailing wage status 1', 'extremely_low_income_units': 0,
'very_low_income_units': 0, 'low_income_units': 0, 'moderate_income_units': 0, 'middle_income_units': 2,
'other_income_units': 0, 'studio_units': 0, 'one_br_units': 1, 'two_br_units': 0, 'three_br_units': 1,
'four_br_units': 0, 'five_br_units': 0, 'six_br_units': 0, 'unknown_br_units': 0, 'counted_rental_units': 1,
'counted_homeownership_units': 1, 'all_counted_units': 2
}
@pytest.mark.asyncio
async def test_retrieve_housing_unit_get_request_raise_authorization_error_when_jwt_not_provided(
populate_users, populate_housing_units, stub_housing_units
):
response = client.get(
"/housing-units/{}".format(stub_housing_units[0].uuid),
)
assert response.status_code == 403
assert response.json() == {'detail': 'Not authenticated'}
@pytest.mark.asyncio
async def test_post_housing_unit_request_called_by_admin(
populate_users, populate_housing_units, stub_housing_units, admin_jwt_token, full_housing_unit_request_body
):
response = client.post(
"/housing-units/",
headers={"Authorization": "Bearer {}".format(admin_jwt_token)},
json=full_housing_unit_request_body
)
assert response.status_code == 200
response_json = response.json()
assert response_json.get('uuid', None)
response_json.pop('uuid')
assert response_json == full_housing_unit_request_body
@pytest.mark.asyncio
async def test_post_housing_unit_request_called_by_customer(
populate_users, populate_housing_units, stub_housing_units, customer_jwt_token, full_housing_unit_request_body
):
response = client.post(
"/housing-units/",
headers={"Authorization": "Bearer {}".format(customer_jwt_token)},
json=full_housing_unit_request_body
)
assert response.status_code == 200
response_json = response.json()
assert response_json.get('uuid', None)
response_json.pop('uuid')
assert response_json == full_housing_unit_request_body
@pytest.mark.asyncio
async def test_post_housing_unit_request_raise_authorization_error_when_jwt_not_provided(
populate_users, populate_housing_units, stub_housing_units
):
response = client.post(
"/housing-units/",
)
assert response.status_code == 403
assert response.json() == {'detail': 'Not authenticated'}
@pytest.mark.asyncio
async def test_post_housing_unit_request_raise_unprocessable_entity_errors(
populate_users,
populate_housing_units,
stub_housing_units,
admin_jwt_token,
full_housing_unit_request_body
):
# Remove project_id which is required.
full_housing_unit_request_body.pop('project_id')
# Add a wrong formatted date to date fields.
full_housing_unit_request_body['project_completion_date'] = 'not_correct_date'
full_housing_unit_request_body['building_completion_date'] = 'not_correct_date'
full_housing_unit_request_body['project_start_date'] = 'not_correct_date'
# Add string to integer and float fields.
full_housing_unit_request_body['postcode'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['total_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['building_id'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['bbl'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['bin'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['council_district'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['latitude'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['longitude'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['latitude_internal'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['longitude_internal'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['extremely_low_income_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['very_low_income_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['low_income_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['moderate_income_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['middle_income_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['other_income_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['studio_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['one_br_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['unknown_br_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['counted_rental_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['counted_homeownership_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['all_counted_units'] = 'not_correct_integer_or_float'
response = client.post(
"/housing-units/",
headers={"Authorization": "Bearer {}".format(admin_jwt_token)},
json=full_housing_unit_request_body
)
assert response.status_code == 422
assert response.json() == {
'detail': [
{'loc': ['body', 'one_br_units'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'project_id'], 'msg': 'field required', 'type': 'value_error.missing'},
{'loc': ['body', 'building_id'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'bbl'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'bin'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'council_district'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'latitude'], 'msg': 'value is not a valid float', 'type': 'type_error.float'},
{'loc': ['body', 'longitude'], 'msg': 'value is not a valid float', 'type': 'type_error.float'},
{'loc': ['body', 'latitude_internal'], 'msg': 'value is not a valid float', 'type': 'type_error.float'},
{'loc': ['body', 'longitude_internal'], 'msg': 'value is not a valid float', 'type': 'type_error.float'},
{'loc': ['body', 'extremely_low_income_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'very_low_income_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'low_income_units'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'moderate_income_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'middle_income_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'other_income_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'studio_units'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'unknown_br_units'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'counted_rental_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'counted_homeownership_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'all_counted_units'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'postcode'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'total_units'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'project_start_date'], 'msg': 'invalid datetime format', 'type': 'value_error.datetime'},
{'loc': ['body', 'project_completion_date'], 'msg': 'invalid datetime format',
'type': 'value_error.datetime'},
{'loc': ['body', 'building_completion_date'], 'msg': 'invalid datetime format',
'type': 'value_error.datetime'}
]
}
@pytest.mark.asyncio
async def test_put_housing_unit_request_called_by_admin(
populate_users, populate_housing_units, stub_housing_units, admin_jwt_token
):
put_request_body = {
"project_id": "44223",
"street_name": "RALPH AVENUE TEST",
"borough": "Brooklyn",
"postcode": None,
"reporting_construction_type": "New Construction TEST",
"total_units": 10,
"project_name": "ROCHESTER SUYDAM PHASE 1",
"project_start_date": "2021-06-30T00:00:00",
"project_completion_date": None,
"building_id": 977564,
"house_number": "329/331",
"bbl": None,
"bin": None,
"community_board": "BK-03",
"council_district": 977564,
"census_tract": None,
"neighborhood_tabulation_area": None,
"latitude": None,
"longitude": None,
"latitude_internal": None,
"longitude_internal": None,
"building_completion_date": None,
"extended_affordability_status": "No",
"prevailing_wage_status": "Non Prevailing Wage",
"extremely_low_income_units": 0,
"very_low_income_units": 0,
"low_income_units": 0,
"moderate_income_units": 10,
"middle_income_units": 0,
"other_income_units": 0,
"studio_units": 0,
"one_br_units": 3,
"two_br_units": 7,
"three_br_units": 0,
"four_br_units": 0,
"five_br_units": 0,
"six_br_units": 0,
"unknown_br_units": 0,
"counted_rental_units": 0,
"counted_homeownership_units": 10,
"all_counted_units": 10
}
response = client.put(
"/housing-units/{}".format(stub_housing_units[0].uuid),
headers={"Authorization": "Bearer {}".format(admin_jwt_token)},
json=put_request_body
)
assert response.status_code == 200
response_json = response.json()
assert response_json.get('uuid', None)
response_json.pop('uuid')
assert response_json == {
'project_id': '44223', 'street_name': 'RALPH AVENUE TEST', 'borough': 'Brooklyn', 'postcode': None,
'reporting_construction_type': 'New Construction TEST', 'total_units': 10,
'project_name': 'ROCHESTER SUYDAM PHASE 1', 'project_start_date': '2021-06-30T00:00:00',
'project_completion_date': None, 'building_id': 977564, 'house_number': '329/331', 'bbl': None,
'bin': None, 'community_board': 'BK-03', 'council_district': 977564, 'census_tract': None,
'neighborhood_tabulation_area': None, 'latitude': None, 'longitude': None, 'latitude_internal': None,
'longitude_internal': None, 'building_completion_date': None,
'extended_affordability_status': 'No', 'prevailing_wage_status': 'Non Prevailing Wage',
'extremely_low_income_units': 0, 'very_low_income_units': 0, 'low_income_units': 0,
'moderate_income_units': 10, 'middle_income_units': 0, 'other_income_units': 0, 'studio_units': 0,
'one_br_units': 3, 'two_br_units': 7, 'three_br_units': 0, 'four_br_units': 0, 'five_br_units': 0,
'six_br_units': 0, 'unknown_br_units': 0, 'counted_rental_units': 0, 'counted_homeownership_units': 10,
'all_counted_units': 10
}
@pytest.mark.asyncio
async def test_put_housing_unit_request_called_by_customer(
populate_users, populate_housing_units, stub_housing_units, customer_jwt_token
):
put_request_body = {
"project_id": "44223",
"street_name": "RALPH AVENUE TEST",
"borough": "Brooklyn",
"postcode": None,
"reporting_construction_type": "New Construction TEST",
"total_units": 10,
"project_name": "ROCHESTER SUYDAM PHASE 1",
"project_start_date": "2021-06-30T00:00:00",
"project_completion_date": None,
"building_id": 977564,
"house_number": "329/331",
"bbl": None,
"bin": None,
"community_board": "BK-03",
"council_district": 977564,
"census_tract": None,
"neighborhood_tabulation_area": None,
"latitude": None,
"longitude": None,
"latitude_internal": None,
"longitude_internal": None,
"building_completion_date": None,
"extended_affordability_status": "No",
"prevailing_wage_status": "Non Prevailing Wage",
"extremely_low_income_units": 0,
"very_low_income_units": 0,
"low_income_units": 0,
"moderate_income_units": 10,
"middle_income_units": 0,
"other_income_units": 0,
"studio_units": 0,
"one_br_units": 3,
"two_br_units": 7,
"three_br_units": 0,
"four_br_units": 0,
"five_br_units": 0,
"six_br_units": 0,
"unknown_br_units": 0,
"counted_rental_units": 0,
"counted_homeownership_units": 10,
"all_counted_units": 10
}
response = client.put(
"/housing-units/{}".format(stub_housing_units[0].uuid),
headers={"Authorization": "Bearer {}".format(customer_jwt_token)},
json=put_request_body
)
assert response.status_code == 200
response_json = response.json()
assert response_json.get('uuid', None)
response_json.pop('uuid')
assert response_json == {
'project_id': '44223', 'street_name': 'RALPH AVENUE TEST', 'borough': 'Brooklyn', 'postcode': None,
'reporting_construction_type': 'New Construction TEST', 'total_units': 10,
'project_name': 'ROCHESTER SUYDAM PHASE 1', 'project_start_date': '2021-06-30T00:00:00',
'project_completion_date': None, 'building_id': 977564, 'house_number': '329/331', 'bbl': None,
'bin': None, 'community_board': 'BK-03', 'council_district': 977564, 'census_tract': None,
'neighborhood_tabulation_area': None, 'latitude': None, 'longitude': None, 'latitude_internal': None,
'longitude_internal': None, 'building_completion_date': None,
'extended_affordability_status': 'No', 'prevailing_wage_status': 'Non Prevailing Wage',
'extremely_low_income_units': 0, 'very_low_income_units': 0, 'low_income_units': 0,
'moderate_income_units': 10, 'middle_income_units': 0, 'other_income_units': 0, 'studio_units': 0,
'one_br_units': 3, 'two_br_units': 7, 'three_br_units': 0, 'four_br_units': 0, 'five_br_units': 0,
'six_br_units': 0, 'unknown_br_units': 0, 'counted_rental_units': 0, 'counted_homeownership_units': 10,
'all_counted_units': 10
}
@pytest.mark.asyncio
async def test_put_housing_unit_request_raise_authorization_error_when_jwt_not_provided(
populate_users, populate_housing_units, stub_housing_units
):
response = client.put(
"/housing-units/{}".format(stub_housing_units[0].uuid),
)
assert response.status_code == 403
assert response.json() == {'detail': 'Not authenticated'}
@pytest.mark.asyncio
async def test_put_housing_unit_request_raise_unprocessable_entity_errors(
populate_users,
populate_housing_units,
stub_housing_units,
admin_jwt_token,
full_housing_unit_request_body
):
# Remove project_id which is required.
full_housing_unit_request_body.pop('project_id')
# Add a wrong formatted date to date fields.
full_housing_unit_request_body['project_completion_date'] = 'not_correct_date'
full_housing_unit_request_body['building_completion_date'] = 'not_correct_date'
full_housing_unit_request_body['project_start_date'] = 'not_correct_date'
# Add string to integer and float fields.
full_housing_unit_request_body['postcode'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['total_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['building_id'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['bbl'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['bin'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['council_district'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['latitude'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['longitude'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['latitude_internal'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['longitude_internal'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['extremely_low_income_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['very_low_income_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['low_income_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['moderate_income_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['middle_income_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['other_income_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['studio_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['one_br_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['unknown_br_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['counted_rental_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['counted_homeownership_units'] = 'not_correct_integer_or_float'
full_housing_unit_request_body['all_counted_units'] = 'not_correct_integer_or_float'
response = client.put(
"/housing-units/{}".format(stub_housing_units[0].uuid),
headers={"Authorization": "Bearer {}".format(admin_jwt_token)},
json=full_housing_unit_request_body
)
assert response.status_code == 422
assert response.json() == {
'detail': [
{'loc': ['body', 'one_br_units'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'project_id'], 'msg': 'field required', 'type': 'value_error.missing'},
{'loc': ['body', 'building_id'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'bbl'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'bin'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'council_district'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'latitude'], 'msg': 'value is not a valid float', 'type': 'type_error.float'},
{'loc': ['body', 'longitude'], 'msg': 'value is not a valid float', 'type': 'type_error.float'},
{'loc': ['body', 'latitude_internal'], 'msg': 'value is not a valid float', 'type': 'type_error.float'},
{'loc': ['body', 'longitude_internal'], 'msg': 'value is not a valid float', 'type': 'type_error.float'},
{'loc': ['body', 'extremely_low_income_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'very_low_income_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'low_income_units'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'moderate_income_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'middle_income_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'other_income_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'studio_units'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'unknown_br_units'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'counted_rental_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'counted_homeownership_units'], 'msg': 'value is not a valid integer',
'type': 'type_error.integer'},
{'loc': ['body', 'all_counted_units'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'postcode'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'total_units'], 'msg': 'value is not a valid integer', 'type': 'type_error.integer'},
{'loc': ['body', 'project_start_date'], 'msg': 'invalid datetime format', 'type': 'value_error.datetime'},
{'loc': ['body', 'project_completion_date'], 'msg': 'invalid datetime format',
'type': 'value_error.datetime'},
{'loc': ['body', 'building_completion_date'], 'msg': 'invalid datetime format',
'type': 'value_error.datetime'}
]
}
@pytest.mark.asyncio
async def test_delete_housing_unit_get_request_called_by_customer(
populate_users, populate_housing_units, stub_housing_units, customer_jwt_token
):
response = client.delete(
"/housing-units/{}".format(stub_housing_units[0].uuid),
headers={"Authorization": "Bearer {}".format(customer_jwt_token)}
)
assert response.status_code == 200
response_json = response.json()
assert response_json == {'status': 'deleted', 'uuid': stub_housing_units[0].uuid}
@pytest.mark.asyncio
async def test_delete_housing_unit_get_request_called_by_admin(
populate_users, populate_housing_units, stub_housing_units, admin_jwt_token
):
response = client.delete(
"/housing-units/{}".format(stub_housing_units[0].uuid),
headers={"Authorization": "Bearer {}".format(admin_jwt_token)}
)
assert response.status_code == 200
response_json = response.json()
assert response_json == {'status': 'deleted', 'uuid': stub_housing_units[0].uuid}
@pytest.mark.asyncio
async def test_delete_housing_unit_get_request_raise_authorization_error_when_jwt_not_provided(
populate_users, populate_housing_units, stub_housing_units
):
response = client.get(
"/housing-units/{}".format(stub_housing_units[0].uuid),
)
assert response.status_code == 403
assert response.json() == {'detail': 'Not authenticated'}
| 51.92283 | 120 | 0.672839 |
97f5d537a26eef1c2a0b9557a676b297b8beb19e | 17,129 | py | Python | yolact/layers/backbone.py | masszhou/mod_yolcat | bc4a658674fccaaf0ed545403892c3c3d8816d24 | [
"MIT"
] | null | null | null | yolact/layers/backbone.py | masszhou/mod_yolcat | bc4a658674fccaaf0ed545403892c3c3d8816d24 | [
"MIT"
] | null | null | null | yolact/layers/backbone.py | masszhou/mod_yolcat | bc4a658674fccaaf0ed545403892c3c3d8816d24 | [
"MIT"
] | null | null | null | import torch
import torch.nn as nn
import pickle
from collections import OrderedDict
try:
from dcn_v2 import DCN
except ImportError:
def DCN(*args, **kwdargs):
raise Exception(
'DCN could not be imported. If you want to use YOLACT++ models, compile DCN. Check the README for instructions.')
class Bottleneck(nn.Module):
""" Adapted from torchvision.models.resnet """
expansion = 4
def __init__(self, inplanes, planes, stride=1, downsample=None, norm_layer=nn.BatchNorm2d, dilation=1,
use_dcn=False):
super(Bottleneck, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False, dilation=dilation)
self.bn1 = norm_layer(planes)
if use_dcn:
self.conv2 = DCN(planes, planes, kernel_size=3, stride=stride,
padding=dilation, dilation=dilation, deformable_groups=1)
self.conv2.bias.data.zero_()
self.conv2.conv_offset_mask.weight.data.zero_()
self.conv2.conv_offset_mask.bias.data.zero_()
else:
self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
padding=dilation, bias=False, dilation=dilation)
self.bn2 = norm_layer(planes)
self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False, dilation=dilation)
self.bn3 = norm_layer(planes * 4)
self.relu = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
def forward(self, x):
residual = x
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.bn2(out)
out = self.relu(out)
out = self.conv3(out)
out = self.bn3(out)
if self.downsample is not None:
residual = self.downsample(x)
out += residual
out = self.relu(out)
return out
class ResNetBackbone(nn.Module):
""" Adapted from torchvision.models.resnet """
def __init__(self, layers, dcn_layers=[0, 0, 0, 0], dcn_interval=1, atrous_layers=[], block=Bottleneck,
norm_layer=nn.BatchNorm2d):
super().__init__()
# These will be populated by _make_layer
self.num_base_layers = len(layers)
self.layers = nn.ModuleList()
self.channels = []
self.norm_layer = norm_layer
self.dilation = 1
self.atrous_layers = atrous_layers
# From torchvision.models.resnet.Resnet
self.inplanes = 64
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = norm_layer(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self._make_layer(block, 64, layers[0], dcn_layers=dcn_layers[0], dcn_interval=dcn_interval)
self._make_layer(block, 128, layers[1], stride=2, dcn_layers=dcn_layers[1], dcn_interval=dcn_interval)
self._make_layer(block, 256, layers[2], stride=2, dcn_layers=dcn_layers[2], dcn_interval=dcn_interval)
self._make_layer(block, 512, layers[3], stride=2, dcn_layers=dcn_layers[3], dcn_interval=dcn_interval)
# This contains every module that should be initialized by loading in pretrained weights.
# Any extra layers added onto this that won't be initialized by init_backbone will not be
# in this list. That way, Yolact::init_weights knows which backbone weights to initialize
# with xavier, and which ones to leave alone.
self.backbone_modules = [m for m in self.modules() if isinstance(m, nn.Conv2d)]
def _make_layer(self, block, planes, blocks, stride=1, dcn_layers=0, dcn_interval=1):
""" Here one layer means a string of n Bottleneck blocks. """
downsample = None
# This is actually just to create the connection between layers, and not necessarily to
# downsample. Even if the second condition is met, it only downsamples when stride != 1
if stride != 1 or self.inplanes != planes * block.expansion:
if len(self.layers) in self.atrous_layers:
self.dilation += 1
stride = 1
downsample = nn.Sequential(
nn.Conv2d(self.inplanes, planes * block.expansion,
kernel_size=1, stride=stride, bias=False,
dilation=self.dilation),
self.norm_layer(planes * block.expansion),
)
layers = []
use_dcn = (dcn_layers >= blocks)
layers.append(block(self.inplanes, planes, stride, downsample, self.norm_layer, self.dilation, use_dcn=use_dcn))
self.inplanes = planes * block.expansion
for i in range(1, blocks):
use_dcn = ((i + dcn_layers) >= blocks) and (i % dcn_interval == 0)
layers.append(block(self.inplanes, planes, norm_layer=self.norm_layer, use_dcn=use_dcn))
layer = nn.Sequential(*layers)
self.channels.append(planes * block.expansion)
self.layers.append(layer)
return layer
def forward(self, x):
""" Returns a list of convouts for each layer. """
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
x = self.maxpool(x)
outs = []
for layer in self.layers:
x = layer(x)
outs.append(x)
return tuple(outs)
def init_backbone(self, path):
""" Initializes the backbone weights for training. """
state_dict = torch.load(path)
# Replace layer1 -> layers.0 etc.
keys = list(state_dict)
for key in keys:
if key.startswith('layer'):
idx = int(key[5])
new_key = 'layers.' + str(idx - 1) + key[6:]
state_dict[new_key] = state_dict.pop(key)
# Note: Using strict=False is berry scary. Triple check this.
self.load_state_dict(state_dict, strict=False)
def add_layer(self, conv_channels=1024, downsample=2, depth=1, block=Bottleneck):
""" Add a downsample layer to the backbone as per what SSD does. """
self._make_layer(block, conv_channels // block.expansion, blocks=depth, stride=downsample)
class ResNetBackboneGN(ResNetBackbone):
def __init__(self, layers, num_groups=32):
super().__init__(layers, norm_layer=lambda x: nn.GroupNorm(num_groups, x))
def init_backbone(self, path):
""" The path here comes from detectron. So we load it differently. """
with open(path, 'rb') as f:
state_dict = pickle.load(f, encoding='latin1') # From the detectron source
state_dict = state_dict['blobs']
our_state_dict_keys = list(self.state_dict().keys())
new_state_dict = {}
gn_trans = lambda x: ('gn_s' if x == 'weight' else 'gn_b')
layeridx2res = lambda x: 'res' + str(int(x) + 2)
block2branch = lambda x: 'branch2' + ('a', 'b', 'c')[int(x[-1:]) - 1]
# Transcribe each Detectron weights name to a Yolact weights name
for key in our_state_dict_keys:
parts = key.split('.')
transcribed_key = ''
if (parts[0] == 'conv1'):
transcribed_key = 'conv1_w'
elif (parts[0] == 'bn1'):
transcribed_key = 'conv1_' + gn_trans(parts[1])
elif (parts[0] == 'layers'):
if int(parts[1]) >= self.num_base_layers: continue
transcribed_key = layeridx2res(parts[1])
transcribed_key += '_' + parts[2] + '_'
if parts[3] == 'downsample':
transcribed_key += 'branch1_'
if parts[4] == '0':
transcribed_key += 'w'
else:
transcribed_key += gn_trans(parts[5])
else:
transcribed_key += block2branch(parts[3]) + '_'
if 'conv' in parts[3]:
transcribed_key += 'w'
else:
transcribed_key += gn_trans(parts[4])
new_state_dict[key] = torch.Tensor(state_dict[transcribed_key])
# strict=False because we may have extra unitialized layers at this point
self.load_state_dict(new_state_dict, strict=False)
def darknetconvlayer(in_channels, out_channels, *args, **kwdargs):
"""
Implements a conv, activation, then batch norm.
Arguments are passed into the conv layer.
"""
return nn.Sequential(
nn.Conv2d(in_channels, out_channels, *args, **kwdargs, bias=False),
nn.BatchNorm2d(out_channels),
# Darknet uses 0.1 here.
# See https://github.com/pjreddie/darknet/blob/680d3bde1924c8ee2d1c1dea54d3e56a05ca9a26/src/activations.h#L39
nn.LeakyReLU(0.1, inplace=True)
)
class DarkNetBlock(nn.Module):
""" Note: channels is the lesser of the two. The output will be expansion * channels. """
expansion = 2
def __init__(self, in_channels, channels):
super().__init__()
self.conv1 = darknetconvlayer(in_channels, channels, kernel_size=1)
self.conv2 = darknetconvlayer(channels, channels * self.expansion, kernel_size=3, padding=1)
def forward(self, x):
return self.conv2(self.conv1(x)) + x
class DarkNetBackbone(nn.Module):
"""
An implementation of YOLOv3's Darnet53 in
https://pjreddie.com/media/files/papers/YOLOv3.pdf
This is based off of the implementation of Resnet above.
"""
def __init__(self, layers=[1, 2, 8, 8, 4], block=DarkNetBlock):
super().__init__()
# These will be populated by _make_layer
self.num_base_layers = len(layers)
self.layers = nn.ModuleList()
self.channels = []
self._preconv = darknetconvlayer(3, 32, kernel_size=3, padding=1)
self.in_channels = 32
self._make_layer(block, 32, layers[0])
self._make_layer(block, 64, layers[1])
self._make_layer(block, 128, layers[2])
self._make_layer(block, 256, layers[3])
self._make_layer(block, 512, layers[4])
# This contains every module that should be initialized by loading in pretrained weights.
# Any extra layers added onto this that won't be initialized by init_backbone will not be
# in this list. That way, Yolact::init_weights knows which backbone weights to initialize
# with xavier, and which ones to leave alone.
self.backbone_modules = [m for m in self.modules() if isinstance(m, nn.Conv2d)]
def _make_layer(self, block, channels, num_blocks, stride=2):
""" Here one layer means a string of n blocks. """
layer_list = []
# The downsample layer
layer_list.append(
darknetconvlayer(self.in_channels, channels * block.expansion,
kernel_size=3, padding=1, stride=stride))
# Each block inputs channels and outputs channels * expansion
self.in_channels = channels * block.expansion
layer_list += [block(self.in_channels, channels) for _ in range(num_blocks)]
self.channels.append(self.in_channels)
self.layers.append(nn.Sequential(*layer_list))
def forward(self, x):
""" Returns a list of convouts for each layer. """
x = self._preconv(x)
outs = []
for layer in self.layers:
x = layer(x)
outs.append(x)
return tuple(outs)
def add_layer(self, conv_channels=1024, stride=2, depth=1, block=DarkNetBlock):
""" Add a downsample layer to the backbone as per what SSD does. """
self._make_layer(block, conv_channels // block.expansion, num_blocks=depth, stride=stride)
def init_backbone(self, path):
""" Initializes the backbone weights for training. """
# Note: Using strict=False is berry scary. Triple check this.
self.load_state_dict(torch.load(path), strict=False)
class VGGBackbone(nn.Module):
"""
Args:
- cfg: A list of layers given as lists. Layers can be either 'M' signifying
a max pooling layer, a number signifying that many feature maps in
a conv layer, or a tuple of 'M' or a number and a kwdargs dict to pass
into the function that creates the layer (e.g. nn.MaxPool2d for 'M').
- extra_args: A list of lists of arguments to pass into add_layer.
- norm_layers: Layers indices that need to pass through an l2norm layer.
"""
def __init__(self, cfg, extra_args=[], norm_layers=[]):
super().__init__()
self.channels = []
self.layers = nn.ModuleList()
self.in_channels = 3
self.extra_args = list(reversed(extra_args)) # So I can use it as a stack
# Keeps track of what the corresponding key will be in the state dict of the
# pretrained model. For instance, layers.0.2 for us is 2 for the pretrained
# model but layers.1.1 is 5.
self.total_layer_count = 0
self.state_dict_lookup = {}
for idx, layer_cfg in enumerate(cfg):
self._make_layer(layer_cfg)
self.norms = nn.ModuleList([nn.BatchNorm2d(self.channels[l]) for l in norm_layers])
self.norm_lookup = {l: idx for idx, l in enumerate(norm_layers)}
# These modules will be initialized by init_backbone,
# so don't overwrite their initialization later.
self.backbone_modules = [m for m in self.modules() if isinstance(m, nn.Conv2d)]
def _make_layer(self, cfg):
"""
Each layer is a sequence of conv layers usually preceded by a max pooling.
Adapted from torchvision.models.vgg.make_layers.
"""
layers = []
for v in cfg:
# VGG in SSD requires some special layers, so allow layers to be tuples of
# (<M or num_features>, kwdargs dict)
args = None
if isinstance(v, tuple):
args = v[1]
v = v[0]
# v should be either M or a number
if v == 'M':
# Set default arguments
if args is None:
args = {'kernel_size': 2, 'stride': 2}
layers.append(nn.MaxPool2d(**args))
else:
# See the comment in __init__ for an explanation of this
cur_layer_idx = self.total_layer_count + len(layers)
self.state_dict_lookup[cur_layer_idx] = '%d.%d' % (len(self.layers), len(layers))
# Set default arguments
if args is None:
args = {'kernel_size': 3, 'padding': 1}
# Add the layers
layers.append(nn.Conv2d(self.in_channels, v, **args))
layers.append(nn.ReLU(inplace=True))
self.in_channels = v
self.total_layer_count += len(layers)
self.channels.append(self.in_channels)
self.layers.append(nn.Sequential(*layers))
def forward(self, x):
""" Returns a list of convouts for each layer. """
outs = []
for idx, layer in enumerate(self.layers):
x = layer(x)
# Apply an l2norm module to the selected layers
# Note that this differs from the original implemenetation
if idx in self.norm_lookup:
x = self.norms[self.norm_lookup[idx]](x)
outs.append(x)
return tuple(outs)
def transform_key(self, k):
""" Transform e.g. features.24.bias to layers.4.1.bias """
vals = k.split('.')
layerIdx = self.state_dict_lookup[int(vals[0])]
return 'layers.%s.%s' % (layerIdx, vals[1])
def init_backbone(self, path):
""" Initializes the backbone weights for training. """
state_dict = torch.load(path)
state_dict = OrderedDict([(self.transform_key(k), v) for k, v in state_dict.items()])
self.load_state_dict(state_dict, strict=False)
def add_layer(self, conv_channels=128, downsample=2):
""" Add a downsample layer to the backbone as per what SSD does. """
if len(self.extra_args) > 0:
conv_channels, downsample = self.extra_args.pop()
padding = 1 if downsample > 1 else 0
layer = nn.Sequential(
nn.Conv2d(self.in_channels, conv_channels, kernel_size=1),
nn.ReLU(inplace=True),
nn.Conv2d(conv_channels, conv_channels * 2, kernel_size=3, stride=downsample, padding=padding),
nn.ReLU(inplace=True)
)
self.in_channels = conv_channels * 2
self.channels.append(self.in_channels)
self.layers.append(layer)
def construct_backbone(cfg):
""" Constructs a backbone given a backbone config object (see config.py). """
backbone = cfg.type(*cfg.args)
# Add downsampling layers until we reach the number we need
num_layers = max(cfg.selected_layers) + 1
while len(backbone.layers) < num_layers:
backbone.add_layer()
return backbone
| 38.064444 | 125 | 0.608267 |
18465d42af265b14f17e384d6faaa9017c7e37c3 | 1,226 | py | Python | examples/tanner/parse_test.py | yrrapt/genetic_algorithm_optimiser | 74f86bc60978ba21dd62e3db00f719ec6641ad88 | [
"MIT"
] | null | null | null | examples/tanner/parse_test.py | yrrapt/genetic_algorithm_optimiser | 74f86bc60978ba21dd62e3db00f719ec6641ad88 | [
"MIT"
] | null | null | null | examples/tanner/parse_test.py | yrrapt/genetic_algorithm_optimiser | 74f86bc60978ba21dd62e3db00f719ec6641ad88 | [
"MIT"
] | null | null | null | import re
# input_file_location = "schematic_oscillator_tb_n1a_tb_TSP/schematic_oscillator_tb_n1a_tb_TSP.measure"
# input_file_location = "schematic_oscillator_tb_n1a_tb_TSP/schematic_oscillator_tb_n1a_tb_TSP.log"
input_file_location = "_data/schematic_oscillator_tb_n1a_tb_TSP/schematic_oscillator_tb_n1a_tb_TSP.measure"
""" Open the operating point file to begin parsing """
input_file = open(input_file_location)
# loop through each line in the text
period = []
for line_number, line in enumerate(input_file):
print(line)
# tm results
if line_number == 1:
print(line)
period.append( float( re.findall(re.compile("[\d\.]+"), line)[0] ) * 1e-9 )
# search for a number in scientific notation
match = re.findall(re.compile("([+-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+))$"), line)
# a matching regex has been found
if match:
print(line)
period.append( float(match[0]) )
# covert to normalised difference
error = []
for _ in period[1:]:
print("-"*100)
print(_)
print( _ - period[0])
print(period[0])
print( (_ - period[0]) / period[0] )
error.append( abs((_ - period[0]) / period[0]) )
print(period)
print(error)
# return the largest error
fitness = max(error)
print("Fitness = ", fitness)
| 26.652174 | 107 | 0.707178 |
bd46bc729d96ed03466160b3a4201456f4f8d67d | 2,796 | py | Python | mindspore/python/mindspore/ops/composite/multitype_ops/ones_like_impl.py | AK391/mindspore | f5aeaa9172dcd647885774e7f657593c81b79fc6 | [
"Apache-2.0"
] | null | null | null | mindspore/python/mindspore/ops/composite/multitype_ops/ones_like_impl.py | AK391/mindspore | f5aeaa9172dcd647885774e7f657593c81b79fc6 | [
"Apache-2.0"
] | null | null | null | mindspore/python/mindspore/ops/composite/multitype_ops/ones_like_impl.py | AK391/mindspore | f5aeaa9172dcd647885774e7f657593c81b79fc6 | [
"Apache-2.0"
] | null | null | null | # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
#
# Copyright 2020 Huawei Technologies Co., Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""Implementation for internal polymorphism `ones_like_leaf` operations."""
from ...composite import base
from ... import functional as F
from ... import operations as P
ones_like_leaf = base.MultitypeFuncGraph('ones_like_leaf', True)
"""
`ones_like_leaf` is a metafuncgraph object which will generate a tensor filled with one according to its input type
using ".register" decorator.
"""
@ones_like_leaf.register("TypeType")
def _ones_like_type_type(x):
"""Returns x because x is a type. This is usually used in backprop progress."""
return x
@ones_like_leaf.register("Number")
def _ones_like_scalar(x):
"""Returns 1 which has the same dtype as x where x is a scalar."""
t = F.typeof(x)
return F.scalar_cast(1.0, t)
@ones_like_leaf.register("Tensor")
def _ones_like_tensor(x):
"""Returns a tensor with the same shape and dtype as x and all elements ars 1."""
return P.Fill()(P.DType()(x), P.Shape()(x), 1.0)
@ones_like_leaf.register("COOTensor")
def _ones_like_coo_tensor(x):
"""Returns a tensor with the same shape and dtype as x and all elements are 1."""
values_ = F.coo_tensor_get_values(x)
values = P.Fill()(P.DType()(values_),
P.Shape()(values_),
1.0)
return F.make_coo_tensor(F.coo_tensor_get_indices(x), values, F.coo_tensor_get_dense_shape(x))
@ones_like_leaf.register("Function")
def _ones_like_func(x):
"""
Derivation of a function.
Args:
x (Function): x
Returns:
A instance of EnvType.
"""
# Unused parameters are placeholders.
return F.environ_create()
ones_like = base.HyperMap(ones_like_leaf)
"""
`ones_like` is a function which can generate a graph of `ones_like` operation according to input tensor dtype.
Example:
>>> input = Tensor([2, 3], mindspore.int32)
>>> ones = ones_like(input) # The dtype of ones is mindspore.int32
>>> input = Tensor([2, 3], mindspore.float16)
>>> ones = ones_like(input) # The dtype of ones is mindspore.float16
"""
| 32.511628 | 115 | 0.685622 |
1d994f8ad0341ad3d8215255e317e5d9cbd6101c | 5,834 | py | Python | spk/subliminal/src/app/application/direct.py | BKSteve/spksrc | fc1982b27311eccf15767961955cee954cb409ee | [
"BSD-3-Clause"
] | 2,211 | 2015-01-02T11:47:37.000Z | 2022-03-31T11:24:09.000Z | spk/subliminal/src/app/application/direct.py | BKSteve/spksrc | fc1982b27311eccf15767961955cee954cb409ee | [
"BSD-3-Clause"
] | 3,572 | 2015-01-01T02:44:58.000Z | 2022-03-31T18:13:33.000Z | spk/subliminal/src/app/application/direct.py | StrannikS/spksrc | 97df932beab2fd5817f33ed647d452f33b89de8b | [
"BSD-3-Clause"
] | 1,227 | 2015-01-03T15:05:10.000Z | 2022-03-30T05:52:34.000Z | from babelfish import Language
from configobj import ConfigObj
from datetime import timedelta
from db import *
from pyextdirect.configuration import (create_configuration, expose, LOAD,
STORE_READ, STORE_CUD, SUBMIT)
from validate import Validator
import os
import shutil
import subliminal
import subprocess
import tempfile
__all__ = ['Base', 'Directories', 'Subliminal']
Base = create_configuration()
class Directories(Base):
def __init__(self):
self.session = Session()
@expose(kind=STORE_CUD)
def create(self, data):
results = []
for record in data:
directory = Directory(name=record['name'], path=record['path'])
self.session.add(directory)
self.session.commit()
results.append({'id': directory.id, 'name': directory.name, 'path': directory.path})
return results
@expose(kind=STORE_READ)
def read(self):
results = []
for directory in self.session.query(Directory).all():
results.append({'id': directory.id, 'name': directory.name, 'path': directory.path})
return results
@expose(kind=STORE_CUD)
def update(self, data):
results = []
for record in data:
directory = self.session.query(Directory).get(record['id'])
directory.name = record['name']
directory.path = record['path']
results.append({'id': directory.id, 'name': directory.name, 'path': directory.path})
self.session.commit()
return results
@expose(kind=STORE_CUD)
def destroy(self, data):
results = []
for directory_id in data:
directory = self.session.query(Directory).get(directory_id)
self.session.delete(directory)
results.append(directory.id)
self.session.commit()
return results
@expose
def scan(self, directory_id):
with open(os.devnull, 'w') as devnull:
subprocess.call(['/usr/local/subliminal/app/scanner.py', str(directory_id)], stdin=devnull, stdout=devnull, stderr=devnull)
class Subliminal(Base):
config_path = '/usr/local/subliminal/var/config.ini'
def __init__(self):
self.session = Session()
self.config = ConfigObj(self.config_path, configspec='/usr/local/subliminal/app/application/config.spec', encoding='utf-8')
self.config_validator = Validator()
self.config.validate(self.config_validator)
def setup(self):
self.config.validate(self.config_validator, copy=True)
self.config.write()
@expose(kind=LOAD)
def load(self):
result = {'languages': self.config['General']['languages'], 'providers': self.config['General']['providers'],
'single': self.config['General']['single'], 'hearing_impaired': self.config['General']['hearing_impaired'],
'min_score': self.config['General']['min_score'], 'dsm_notifications': self.config['General']['dsm_notifications'],
'task': self.config['Task']['enable'], 'age': self.config['Task']['age'],
'hour': self.config['Task']['hour'], 'minute': self.config['Task']['minute']}
return result
@expose(kind=SUBMIT)
def save(self, languages=None, providers=None, single=None, hearing_impaired=None, min_score=None, dsm_notifications=None, task=None, age=None, hour=None, minute=None):
self.config['General']['languages'] = languages if isinstance(languages, list) else [languages]
self.config['General']['providers'] = providers if isinstance(providers, list) else [providers]
self.config['General']['single'] = bool(single)
self.config['General']['hearing_impaired'] = bool(hearing_impaired)
self.config['General']['min_score'] = int(min_score)
self.config['General']['dsm_notifications'] = bool(dsm_notifications)
self.config['Task']['enable'] = bool(task)
self.config['Task']['age'] = int(age)
self.config['Task']['hour'] = int(hour)
self.config['Task']['minute'] = int(minute)
if not self.config.validate(self.config_validator):
return
self.config.write()
def scan(self):
paths = [directory.path for directory in self.session.query(Directory).all() if os.path.exists(directory.path)]
if not paths:
return
results = scan(paths, self.config)
if self.config['General']['dsm_notifications']:
notify('Downloaded %d subtitle(s) for %d video(s) in all directories' % (sum([len(s) for s in results.itervalues()]), len(results)))
return results
def scan(paths, config):
subliminal.cache_region.configure('dogpile.cache.dbm', arguments={'filename': '/usr/local/subliminal/cache/cachefile.dbm'})
languageset=set(Language(language) for language in config['General']['languages'])
single=True
if not config.get('General').as_bool('single') or len(languageset) > 1:
single=False
hearing_impaired=None
if config.get('General').as_bool('hearing_impaired'):
hearing_impaired=True
videos = subliminal.scan_videos(paths, subtitles=True, embedded_subtitles=True, age=timedelta(days=config.get('Task').as_int('age')))
subtitles = subliminal.api.download_best_subtitles(videos, languages=languageset, providers=config['General']['providers'], provider_configs=None,
single=single, min_score=config.get('General').as_int('min_score'),
hearing_impaired=hearing_impaired)
return subtitles
def notify(message):
with open(os.devnull, 'w') as devnull:
subprocess.call(['synodsmnotify', '@administrators', 'Subliminal', message], stdin=devnull, stdout=devnull, stderr=devnull)
| 42.897059 | 172 | 0.645355 |
a3289a5ae5b1d585a08796c49b7d71cc959ea5ea | 90,450 | py | Python | tensorflow/python/ops/resource_variable_ops.py | AdamHillier/tensorflow | 6780ebf4858a56fd0745f03fa5a61b249559f3cd | [
"Apache-2.0"
] | 9 | 2019-06-05T06:48:07.000Z | 2020-09-29T07:08:02.000Z | tensorflow/python/ops/resource_variable_ops.py | AdamHillier/tensorflow | 6780ebf4858a56fd0745f03fa5a61b249559f3cd | [
"Apache-2.0"
] | 7 | 2021-11-10T20:21:23.000Z | 2022-03-22T19:18:39.000Z | tensorflow/python/ops/resource_variable_ops.py | AdamHillier/tensorflow | 6780ebf4858a56fd0745f03fa5a61b249559f3cd | [
"Apache-2.0"
] | 5 | 2016-11-07T21:17:45.000Z | 2020-05-31T00:16:59.000Z | # Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Ops to use variables as resources."""
# pylint: disable=g-bad-name
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import contextlib
import functools
import weakref
import numpy as np
from tensorflow.core.framework import attr_value_pb2
from tensorflow.core.framework import variable_pb2
from tensorflow.python.client import pywrap_tf_session
from tensorflow.python.eager import context
from tensorflow.python.eager import tape
from tensorflow.python.framework import auto_control_deps_utils as acd
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import cpp_shape_inference_pb2
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import errors
from tensorflow.python.framework import ops
from tensorflow.python.framework import tensor_shape
from tensorflow.python.framework import tensor_spec
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import gen_array_ops
from tensorflow.python.ops import gen_resource_variable_ops
from tensorflow.python.ops import gen_state_ops
from tensorflow.python.ops import handle_data_util
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import state_ops
from tensorflow.python.ops import variables
# go/tf-wildcard-import
# pylint: disable=wildcard-import
from tensorflow.python.ops.gen_resource_variable_ops import *
# pylint: enable=wildcard-import
from tensorflow.python.training.tracking import base as trackable
from tensorflow.python.types import core
from tensorflow.python.util import _pywrap_utils
from tensorflow.python.util import compat
from tensorflow.python.util.deprecation import deprecated
from tensorflow.python.util.tf_export import tf_export
acd.register_read_only_resource_op("ReadVariableOp")
acd.register_read_only_resource_op("VariableShape")
acd.register_read_only_resource_op("ResourceGather")
acd.register_read_only_resource_op("ResourceGatherNd")
acd.register_read_only_resource_op("_ReadVariablesOp")
# TODO(allenl): Remove this alias and migrate callers.
get_resource_handle_data = handle_data_util.get_resource_handle_data
def get_eager_safe_handle_data(handle):
"""Get the data handle from the Tensor `handle`."""
assert isinstance(handle, ops.Tensor)
if isinstance(handle, ops.EagerTensor):
return handle._handle_data # pylint: disable=protected-access
else:
return get_resource_handle_data(handle)
def _set_handle_shapes_and_types(tensor, handle_data, graph_mode):
"""Sets the shape inference result HandleData on tensor.
Args:
tensor: A `Tensor` or `EagerTensor`.
handle_data: A `CppShapeInferenceResult.HandleData`.
graph_mode: A python bool.
"""
tensor._handle_data = handle_data # pylint: disable=protected-access
if not graph_mode:
return
# Not an EagerTensor, so a graph tensor.
shapes, types = zip(*[(pair.shape, pair.dtype)
for pair in handle_data.shape_and_type])
ranks = [len(s.dim) if not s.unknown_rank else -1 for s in shapes]
shapes = [
[d.size for d in s.dim] # pylint: disable=g-complex-comprehension
if not s.unknown_rank else None for s in shapes
]
pywrap_tf_session.TF_GraphSetOutputHandleShapesAndTypes_wrapper(
tensor._op._graph._c_graph, # pylint: disable=protected-access
tensor._as_tf_output(), # pylint: disable=protected-access
shapes,
ranks,
types)
def _combine_handle_data(handle, initial_value):
"""Concats HandleData from tensors `handle` and `initial_value`.
Args:
handle: A `Tensor` of dtype `resource`.
initial_value: A `Tensor`.
Returns:
A `CppShapeInferenceResult.HandleData`. If `initial_value` has dtype
`variant`, the `HandleData` contains the concatenation of the shape_and_type
from both `handle` and `initial_value`.
Raises:
RuntimeError: If handle, which was returned by VarHandleOp, either has
no handle data, or its len(handle_data.shape_and_type) != 1.
"""
assert handle.dtype == dtypes.resource
variable_handle_data = get_eager_safe_handle_data(handle)
if initial_value.dtype != dtypes.variant:
return variable_handle_data
extra_handle_data = get_eager_safe_handle_data(initial_value)
if extra_handle_data is not None and extra_handle_data.is_set:
if (variable_handle_data is None or not variable_handle_data.is_set or
len(variable_handle_data.shape_and_type) != 1):
raise RuntimeError(
"Expected VarHandleOp to return a length==1 shape_and_type, "
"but saw: '%s'" % (variable_handle_data,))
variable_handle_data.shape_and_type.extend(extra_handle_data.shape_and_type)
return variable_handle_data
def _variable_handle_from_shape_and_dtype(shape,
dtype,
shared_name,
name,
graph_mode,
initial_value=None):
"""Create a variable handle, copying in handle data from `initial_value`."""
container = ops.get_default_graph()._container # pylint: disable=protected-access
if container is None:
container = ""
shape = tensor_shape.as_shape(shape)
dtype = dtypes.as_dtype(dtype)
if not graph_mode:
if shared_name is not None:
raise errors.InternalError(
"Using an explicit shared_name is not supported executing eagerly.")
shared_name = context.shared_name()
handle = gen_resource_variable_ops.var_handle_op(
shape=shape,
dtype=dtype,
shared_name=shared_name,
name=name,
container=container)
if initial_value is None:
initial_value = handle
if graph_mode:
full_handle_data = _combine_handle_data(handle, initial_value)
_set_handle_shapes_and_types(handle, full_handle_data, graph_mode)
return handle
else:
handle_data = cpp_shape_inference_pb2.CppShapeInferenceResult.HandleData()
handle_data.is_set = True
handle_data.shape_and_type.append(
cpp_shape_inference_pb2.CppShapeInferenceResult.HandleShapeAndType(
shape=shape.as_proto(), dtype=dtype.as_datatype_enum))
if initial_value is not None and initial_value.dtype == dtypes.variant:
extra_handle_data = get_eager_safe_handle_data(initial_value)
if extra_handle_data is not None and extra_handle_data.is_set:
if (not handle_data.is_set or len(handle_data.shape_and_type) != 1):
raise RuntimeError(
"Expected VarHandleOp to return a length==1 shape_and_type, "
"but saw: '%s'" % (handle_data,))
handle_data.shape_and_type.extend(extra_handle_data.shape_and_type)
_set_handle_shapes_and_types(handle, handle_data, graph_mode)
return handle
def eager_safe_variable_handle(initial_value, shape, shared_name, name,
graph_mode):
"""Creates a variable handle with information to do shape inference.
The dtype is read from `initial_value` and stored in the returned
resource tensor's handle data.
If `initial_value.dtype == tf.variant`, we additionally extract the handle
data (if any) from `initial_value` and append it to the `handle_data`.
In this case, the returned tensor's handle data is in the form
```
is_set: true
shape_and_type {
shape {
// initial_value.shape
}
dtype: DT_VARIANT
}
shape_and_type {
// handle_data(initial_value).shape_and_type[0]
}
shape_and_type {
// handle_data(initial_value).shape_and_type[1]
}
...
```
Ops that read from this tensor, such as `ReadVariableOp` and
`AssignVariableOp`, know that `handle_data(handle).shape_and_type[1:]`
correspond to the handle data of the variant(s) stored in the Variable.
Args:
initial_value: A `Tensor`.
shape: The shape of the handle data. Can be `TensorShape(None)` (i.e.
unknown shape).
shared_name: A string.
name: A string.
graph_mode: A python bool.
Returns:
The handle, a `Tensor` of type `resource`.
"""
dtype = initial_value.dtype.base_dtype
return _variable_handle_from_shape_and_dtype(shape, dtype, shared_name, name,
graph_mode, initial_value)
@contextlib.contextmanager
def _handle_graph(handle):
# Note: might have an eager tensor but not be executing eagerly when building
# functions.
if (context.executing_eagerly() or isinstance(handle, ops.EagerTensor) or
ops.has_default_graph()):
yield
else:
with handle.graph.as_default():
yield
class EagerResourceDeleter(object):
"""An object which cleans up a resource handle.
An alternative to defining a __del__ method on an object. The intended use is
that ResourceVariables or other objects with resource handles will maintain a
single reference to this object. When the parent object is collected, this
object will be too. Even if the parent object is part of a reference cycle,
the cycle will be collectable.
"""
__slots__ = ["_handle", "_handle_device", "_context"]
def __init__(self, handle, handle_device):
if not isinstance(handle, ops.Tensor):
raise ValueError(
("Passed handle=%s to EagerResourceDeleter. Was expecting a handle "
"Tensor." % (handle,)))
self._handle = handle
self._handle_device = handle_device
# This is held since the __del__ function runs an op, and if the context()
# is collected before this object, there will be a segfault when running the
# op.
self._context = context.context()
def __del__(self):
# Resources follow object-identity when executing eagerly, so it is safe to
# delete the resource we have a handle to.
try:
# A packed EagerTensor doesn't own any resource.
if isinstance(self._handle, ops.EagerTensor) and self._handle.is_packed:
return
# This resource was created in eager mode. However, this destructor may be
# running in graph mode (especially during unit tests). To clean up
# successfully, we switch back into eager mode temporarily.
with context.eager_mode():
with ops.device(self._handle_device):
gen_resource_variable_ops.destroy_resource_op(
self._handle, ignore_lookup_error=True)
except TypeError:
# Suppress some exceptions, mainly for the case when we're running on
# module deletion. Things that can go wrong include the context module
# already being unloaded, self._handle._handle_data no longer being
# valid, and so on. Printing warnings in these cases is silly
# (exceptions raised from __del__ are printed as warnings to stderr).
pass # 'NoneType' object is not callable when the handle has been
# partially unloaded.
except AttributeError:
pass # 'NoneType' object has no attribute 'eager_mode' when context has
# been unloaded. Will catch other module unloads as well.
def shape_safe_assign_variable_handle(handle, shape, value, name=None):
"""Helper that checks shape compatibility and assigns variable."""
with _handle_graph(handle):
value_tensor = ops.convert_to_tensor(value)
shape.assert_is_compatible_with(value_tensor.shape)
return gen_resource_variable_ops.assign_variable_op(
handle, value_tensor, name=name)
def _maybe_set_handle_data(dtype, handle, tensor):
if dtype == dtypes.variant:
# For DT_VARIANT types, the handle's shape_and_type[1:] stores the
# variant's handle data. Extract it.
handle_data = get_eager_safe_handle_data(handle)
if handle_data.is_set and len(handle_data.shape_and_type) > 1:
tensor._handle_data = ( # pylint: disable=protected-access
cpp_shape_inference_pb2.CppShapeInferenceResult.HandleData(
is_set=True, shape_and_type=handle_data.shape_and_type[1:]))
def variable_accessed(variable):
"""Records that `variable` was accessed for the tape and FuncGraph."""
if hasattr(ops.get_default_graph(), "watch_variable"):
ops.get_default_graph().watch_variable(variable)
if variable.trainable:
tape.variable_accessed(variable)
class BaseResourceVariable(variables.VariableV1, core.Tensor):
"""A python variable from an existing handle."""
# TODO(wangpeng): Deprecate `constraint` when callers no long pass it in.
def __init__( # pylint: disable=super-init-not-called
self,
trainable=None,
shape=None,
dtype=None,
handle=None,
constraint=None,
synchronization=None,
aggregation=None,
distribute_strategy=None,
name=None,
unique_id=None,
handle_name=None,
graph_element=None,
initial_value=None,
initializer_op=None,
is_initialized_op=None,
cached_value=None,
save_slice_info=None,
handle_deleter=None,
caching_device=None,
**unused_kwargs):
"""Creates a variable from a handle.
Args:
trainable: If `True`, GradientTapes automatically watch uses of this
Variable.
shape: The variable's shape.
dtype: The variable's dtype.
handle: The variable's handle
constraint: An optional projection function to be applied to the variable
after being updated by an `Optimizer` (e.g. used to implement norm
constraints or value constraints for layer weights). The function must
take as input the unprojected Tensor representing the value of the
variable and return the Tensor for the projected value (which must have
the same shape). Constraints are not safe to use when doing asynchronous
distributed training.
synchronization: Indicates when a distributed a variable will be
aggregated. Accepted values are constants defined in the class
`tf.VariableSynchronization`. By default the synchronization is set to
`AUTO` and the current `DistributionStrategy` chooses when to
synchronize.
aggregation: Indicates how a distributed variable will be aggregated.
Accepted values are constants defined in the class
`tf.VariableAggregation`.
distribute_strategy: The distribution strategy this variable was created
under.
name: The name for this variable.
unique_id: Internal. Unique ID for this variable's handle.
handle_name: The name for the variable's handle.
graph_element: Optional, required only in session.run-mode. Pre-created
tensor which reads this variable's value.
initial_value: Optional. Variable's initial value.
initializer_op: Operation which assigns the variable's initial value.
is_initialized_op: Pre-created operation to check whether this variable is
initialized.
cached_value: Pre-created operation to read this variable in a specific
device.
save_slice_info: Metadata for variable partitioning.
handle_deleter: EagerResourceDeleter responsible for cleaning up the
handle.
caching_device: Optional device string or function describing where the
Variable should be cached for reading. Defaults to the Variable's
device. If not `None`, caches on another device. Typical use is to
cache on the device where the Ops using the Variable reside, to
deduplicate copying through `Switch` and other conditional statements.
"""
with ops.init_scope():
self._in_graph_mode = not context.executing_eagerly()
synchronization, aggregation, trainable = (
variables.validate_synchronization_aggregation_trainable(
synchronization, aggregation, trainable, name))
self._trainable = trainable
self._synchronization = synchronization
self._aggregation = aggregation
self._save_slice_info = save_slice_info
self._initial_value = initial_value
self._initializer_op = initializer_op
self._is_initialized_op = is_initialized_op
self._graph_element = graph_element
self._caching_device = caching_device
self._cached_value = cached_value
self._distribute_strategy = distribute_strategy
# Store the graph key so optimizers know how to only retrieve variables from
# this graph. Guaranteed to be the same as the eager graph_key.
self._graph_key = ops.get_default_graph()._graph_key # pylint: disable=protected-access
self._shape = tensor_shape.as_shape(shape)
self._dtype = dtypes.as_dtype(dtype)
self._handle = handle
self._unique_id = unique_id
self._handle_name = handle_name + ":0"
self._constraint = constraint
# After the handle has been created, set up a way to clean it up when
# executing eagerly. We'll hold the only reference to the deleter, so that
# when this object is garbage collected the deleter will be too. This
# means ResourceVariables can be part of reference cycles without those
# cycles being uncollectable.
if not self._in_graph_mode:
if handle_deleter is None:
handle_deleter = EagerResourceDeleter(
handle=self._handle, handle_device=self._handle.device)
self._handle_deleter = handle_deleter
self._cached_shape_as_list = None
def __repr__(self):
if context.executing_eagerly() and not self._in_graph_mode:
# If we cannot read the value for any reason, still produce a __repr__.
try:
value_text = ops.numpy_text(self.read_value(), is_repr=True)
except: # pylint: disable=bare-except
value_text = "<unavailable>"
return "<tf.Variable '%s' shape=%s dtype=%s, numpy=%s>" % (
self.name, self.get_shape(), self.dtype.name, value_text)
else:
return "<tf.Variable '%s' shape=%s dtype=%s>" % (
self.name, self.get_shape(), self.dtype.name)
@contextlib.contextmanager
def _assign_dependencies(self):
"""Makes assignments depend on the cached value, if any.
This prevents undefined behavior with reads not ordered wrt writes.
Yields:
None.
"""
if self._cached_value is not None:
with ops.control_dependencies([self._cached_value]):
yield
else:
yield
def __array__(self):
"""Allows direct conversion to a numpy array.
>>> np.array(tf.Variable([1.0]))
array([1.], dtype=float32)
Returns:
The variable value as a numpy array.
"""
# You can't return `self.numpy()` here because for scalars
# that raises:
# ValueError: object __array__ method not producing an array
# Even `self.read_value().__array__()` and `self.read_value()._numpy()` give
# the same error. The `EagerTensor` class must be doing something behind the
# scenes to make `np.array(tf.constant(1))` work.
return np.asarray(self.numpy())
def __nonzero__(self):
return self.__bool__()
def __bool__(self):
return bool(self.read_value())
def __copy__(self):
return self
def __deepcopy__(self, memo):
if not context.executing_eagerly():
raise NotImplementedError(
"__deepcopy__() is only available when eager execution is enabled.")
copied_variable = ResourceVariable(
initial_value=self.read_value(),
trainable=self._trainable,
constraint=self._constraint,
dtype=self._dtype,
name=self._shared_name,
distribute_strategy=self._distribute_strategy,
synchronization=self.synchronization,
aggregation=self.aggregation)
memo[self._unique_id] = copied_variable
return copied_variable
@property
def dtype(self):
"""The dtype of this variable."""
return self._dtype
@property
def device(self):
"""The device this variable is on."""
return self._handle.device
@property
def graph(self):
"""The `Graph` of this variable."""
return self._handle.graph
@property
def name(self):
"""The name of the handle for this variable."""
return self._handle_name
@property
def shape(self):
"""The shape of this variable."""
return self._shape
def set_shape(self, shape):
self._shape = self._shape.merge_with(shape)
def _shape_as_list(self):
if self.shape.ndims is None:
return None
return [dim.value for dim in self.shape.dims]
def _shape_tuple(self):
shape = self._shape_as_list()
if shape is None:
return None
return tuple(shape)
@property
def create(self):
"""The op responsible for initializing this variable."""
if not self._in_graph_mode:
raise RuntimeError("Calling create is not supported when eager execution"
" is enabled.")
return self._initializer_op
@property
def handle(self):
"""The handle by which this variable can be accessed."""
return self._handle
def value(self):
"""A cached operation which reads the value of this variable."""
if self._cached_value is not None:
return self._cached_value
with ops.colocate_with(None, ignore_existing=True):
return self._read_variable_op()
def _as_graph_element(self):
"""Conversion function for Graph.as_graph_element()."""
return self._graph_element
@property
def initializer(self):
"""The op responsible for initializing this variable."""
return self._initializer_op
@property
def initial_value(self):
"""Returns the Tensor used as the initial value for the variable."""
if context.executing_eagerly():
raise RuntimeError("initial_value not supported in EAGER mode.")
return self._initial_value
@property
def constraint(self):
"""Returns the constraint function associated with this variable.
Returns:
The constraint function that was passed to the variable constructor.
Can be `None` if no constraint was passed.
"""
return self._constraint
@property
def op(self):
"""The op for this variable."""
return self._handle.op
@property
def trainable(self):
return self._trainable
@property
def synchronization(self):
return self._synchronization
@property
def aggregation(self):
return self._aggregation
def eval(self, session=None):
"""Evaluates and returns the value of this variable."""
if context.executing_eagerly():
raise RuntimeError("Trying to eval in EAGER mode")
return self._graph_element.eval(session=session)
def numpy(self):
if context.executing_eagerly():
return self.read_value().numpy()
raise NotImplementedError(
"numpy() is only available when eager execution is enabled.")
@deprecated(None, "Prefer Dataset.range instead.")
def count_up_to(self, limit):
"""Increments this variable until it reaches `limit`.
When that Op is run it tries to increment the variable by `1`. If
incrementing the variable would bring it above `limit` then the Op raises
the exception `OutOfRangeError`.
If no error is raised, the Op outputs the value of the variable before
the increment.
This is essentially a shortcut for `count_up_to(self, limit)`.
Args:
limit: value at which incrementing the variable raises an error.
Returns:
A `Tensor` that will hold the variable value before the increment. If no
other Op modifies this variable, the values produced will all be
distinct.
"""
return gen_state_ops.resource_count_up_to(
self.handle, limit=limit, T=self.dtype)
def _map_resources(self, save_options):
"""For implementing `Trackable`."""
new_variable = None
if save_options.experimental_variable_policy._save_variable_devices(): # pylint:disable=protected-access
with ops.device(self.device):
new_variable = copy_to_graph_uninitialized(self)
else:
new_variable = copy_to_graph_uninitialized(self)
obj_map = {self: new_variable}
resource_map = {self._handle: new_variable.handle}
return obj_map, resource_map
def _read_variable_op(self):
variable_accessed(self)
def read_and_set_handle():
result = gen_resource_variable_ops.read_variable_op(
self._handle, self._dtype)
_maybe_set_handle_data(self._dtype, self._handle, result)
return result
if getattr(self, "_caching_device", None) is not None:
with ops.colocate_with(None, ignore_existing=True):
with ops.device(self._caching_device):
result = read_and_set_handle()
else:
result = read_and_set_handle()
if not context.executing_eagerly():
# Note that if a control flow context is active the input of the read op
# might not actually be the handle. This line bypasses it.
tape.record_operation(
"ReadVariableOp", [result], [self._handle],
backward_function=lambda x: [x],
forward_function=lambda x: [x])
return result
def read_value(self):
"""Constructs an op which reads the value of this variable.
Should be used when there are multiple reads, or when it is desirable to
read the value only after some condition is true.
Returns:
the read operation.
"""
with ops.name_scope("Read"):
value = self._read_variable_op()
# Return an identity so it can get placed on whatever device the context
# specifies instead of the device where the variable is.
return array_ops.identity(value)
def sparse_read(self, indices, name=None):
"""Reads the value of this variable sparsely, using `gather`."""
with ops.name_scope("Gather" if name is None else name) as name:
variable_accessed(self)
value = gen_resource_variable_ops.resource_gather(
self._handle, indices, dtype=self._dtype, name=name)
if self._dtype == dtypes.variant:
# For DT_VARIANT types, the handle's shape_and_type[1:] stores the
# variant's handle data. Extract it.
handle_data = get_eager_safe_handle_data(self._handle)
if handle_data.is_set and len(handle_data.shape_and_type) > 1:
value._handle_data = ( # pylint: disable=protected-access
cpp_shape_inference_pb2.CppShapeInferenceResult.HandleData(
is_set=True, shape_and_type=handle_data.shape_and_type[1:]))
return array_ops.identity(value)
def gather_nd(self, indices, name=None):
"""Reads the value of this variable sparsely, using `gather_nd`."""
with ops.name_scope("GatherNd" if name is None else name) as name:
if self.trainable:
variable_accessed(self)
value = gen_resource_variable_ops.resource_gather_nd(
self._handle, indices, dtype=self._dtype, name=name)
return array_ops.identity(value)
def to_proto(self, export_scope=None):
"""Converts a `ResourceVariable` to a `VariableDef` protocol buffer.
Args:
export_scope: Optional `string`. Name scope to remove.
Raises:
RuntimeError: If run in EAGER mode.
Returns:
A `VariableDef` protocol buffer, or `None` if the `Variable` is not
in the specified name scope.
"""
if context.executing_eagerly():
raise RuntimeError("to_proto not supported in EAGER mode.")
if export_scope is None or self.handle.name.startswith(export_scope):
var_def = variable_pb2.VariableDef()
var_def.variable_name = ops.strip_name_scope(self.handle.name,
export_scope)
if self._initial_value is not None:
# This is inside an if-statement for backwards compatibility, since
# self._initial_value might be None for variables constructed from old
# protos.
var_def.initial_value_name = ops.strip_name_scope(
self._initial_value.name, export_scope)
var_def.initializer_name = ops.strip_name_scope(self.initializer.name,
export_scope)
if self._cached_value is not None:
var_def.snapshot_name = ops.strip_name_scope(self._cached_value.name,
export_scope)
else:
# Store the graph_element here
var_def.snapshot_name = ops.strip_name_scope(self._graph_element.name,
export_scope)
var_def.is_resource = True
var_def.trainable = self.trainable
var_def.synchronization = self.synchronization.value
var_def.aggregation = self.aggregation.value
if self._save_slice_info:
var_def.save_slice_info_def.MergeFrom(
self._save_slice_info.to_proto(export_scope=export_scope))
return var_def
else:
return None
@staticmethod
def from_proto(variable_def, import_scope=None):
if context.executing_eagerly():
raise RuntimeError("from_proto not supported in EAGER mode.")
return ResourceVariable(
variable_def=variable_def, import_scope=import_scope)
__array_priority__ = 100
def is_initialized(self, name=None):
"""Checks whether a resource variable has been initialized.
Outputs boolean scalar indicating whether the tensor has been initialized.
Args:
name: A name for the operation (optional).
Returns:
A `Tensor` of type `bool`.
"""
# TODO(b/169792703): The current device placement logic never overrides an
# explicit placement with a custom device, causing `v.is_initalized()` to
# fail under a non-custom device context if `v` is in a custom device. The
# explicit placement below makes this work, but should not be necessary once
# the logic is updated to handle cases like this.
with ops.device(self.device):
return gen_resource_variable_ops.var_is_initialized_op(self.handle, name)
def assign_sub(self, delta, use_locking=None, name=None, read_value=True):
"""Subtracts a value from this variable.
Args:
delta: A `Tensor`. The value to subtract from this variable.
use_locking: If `True`, use locking during the operation.
name: The name to use for the operation.
read_value: A `bool`. Whether to read and return the new value of the
variable or not.
Returns:
If `read_value` is `True`, this method will return the new value of the
variable after the assignment has completed. Otherwise, when in graph mode
it will return the `Operation` that does the assignment, and when in eager
mode it will return `None`.
"""
# TODO(apassos): this here and below is not atomic. Consider making it
# atomic if there's a way to do so without a performance cost for those who
# don't need it.
with _handle_graph(self.handle), self._assign_dependencies():
assign_sub_op = gen_resource_variable_ops.assign_sub_variable_op(
self.handle,
ops.convert_to_tensor(delta, dtype=self.dtype),
name=name)
if read_value:
return self._lazy_read(assign_sub_op)
return assign_sub_op
def assign_add(self, delta, use_locking=None, name=None, read_value=True):
"""Adds a value to this variable.
Args:
delta: A `Tensor`. The value to add to this variable.
use_locking: If `True`, use locking during the operation.
name: The name to use for the operation.
read_value: A `bool`. Whether to read and return the new value of the
variable or not.
Returns:
If `read_value` is `True`, this method will return the new value of the
variable after the assignment has completed. Otherwise, when in graph mode
it will return the `Operation` that does the assignment, and when in eager
mode it will return `None`.
"""
with _handle_graph(self.handle), self._assign_dependencies():
assign_add_op = gen_resource_variable_ops.assign_add_variable_op(
self.handle,
ops.convert_to_tensor(delta, dtype=self.dtype),
name=name)
if read_value:
return self._lazy_read(assign_add_op)
return assign_add_op
def _lazy_read(self, op):
variable_accessed(self)
return _UnreadVariable(
handle=self._handle,
dtype=self.dtype,
shape=self._shape,
in_graph_mode=self._in_graph_mode,
deleter=self._handle_deleter if not self._in_graph_mode else None,
parent_op=op,
unique_id=self._unique_id)
def assign(self, value, use_locking=None, name=None, read_value=True):
"""Assigns a new value to this variable.
Args:
value: A `Tensor`. The new value for this variable.
use_locking: If `True`, use locking during the assignment.
name: The name to use for the assignment.
read_value: A `bool`. Whether to read and return the new value of the
variable or not.
Returns:
If `read_value` is `True`, this method will return the new value of the
variable after the assignment has completed. Otherwise, when in graph mode
it will return the `Operation` that does the assignment, and when in eager
mode it will return `None`.
"""
# Note: not depending on the cached value here since this can be used to
# initialize the variable.
with _handle_graph(self.handle):
value_tensor = ops.convert_to_tensor(value, dtype=self.dtype)
if not self._shape.is_compatible_with(value_tensor.shape):
if self.name is None:
tensor_name = ""
else:
tensor_name = " " + str(self.name)
raise ValueError(
("Cannot assign to variable%s due to variable shape %s and value "
"shape %s are incompatible") %
(tensor_name, self._shape, value_tensor.shape))
assign_op = gen_resource_variable_ops.assign_variable_op(
self.handle, value_tensor, name=name)
if read_value:
return self._lazy_read(assign_op)
return assign_op
def __reduce__(self):
# The implementation mirrors that of __deepcopy__.
return functools.partial(
ResourceVariable,
initial_value=self.numpy(),
trainable=self.trainable,
name=self._shared_name,
dtype=self.dtype,
constraint=self.constraint,
distribute_strategy=self._distribute_strategy), ()
def scatter_sub(self, sparse_delta, use_locking=False, name=None):
"""Subtracts `tf.IndexedSlices` from this variable.
Args:
sparse_delta: `tf.IndexedSlices` to be subtracted from this variable.
use_locking: If `True`, use locking during the operation.
name: the name of the operation.
Returns:
The updated variable.
Raises:
TypeError: if `sparse_delta` is not an `IndexedSlices`.
"""
if not isinstance(sparse_delta, ops.IndexedSlices):
raise TypeError("sparse_delta is not IndexedSlices: %s" % sparse_delta)
return self._lazy_read(
gen_resource_variable_ops.resource_scatter_sub(
self.handle,
sparse_delta.indices,
ops.convert_to_tensor(sparse_delta.values, self.dtype),
name=name))
def scatter_add(self, sparse_delta, use_locking=False, name=None):
"""Adds `tf.IndexedSlices` to this variable.
Args:
sparse_delta: `tf.IndexedSlices` to be added to this variable.
use_locking: If `True`, use locking during the operation.
name: the name of the operation.
Returns:
The updated variable.
Raises:
TypeError: if `sparse_delta` is not an `IndexedSlices`.
"""
if not isinstance(sparse_delta, ops.IndexedSlices):
raise TypeError("sparse_delta is not IndexedSlices: %s" % sparse_delta)
return self._lazy_read(
gen_resource_variable_ops.resource_scatter_add(
self.handle,
sparse_delta.indices,
ops.convert_to_tensor(sparse_delta.values, self.dtype),
name=name))
def scatter_max(self, sparse_delta, use_locking=False, name=None):
"""Updates this variable with the max of `tf.IndexedSlices` and itself.
Args:
sparse_delta: `tf.IndexedSlices` to use as an argument of max with this
variable.
use_locking: If `True`, use locking during the operation.
name: the name of the operation.
Returns:
The updated variable.
Raises:
TypeError: if `sparse_delta` is not an `IndexedSlices`.
"""
if not isinstance(sparse_delta, ops.IndexedSlices):
raise TypeError("sparse_delta is not IndexedSlices: %s" % sparse_delta)
return self._lazy_read(
gen_resource_variable_ops.resource_scatter_max(
self.handle,
sparse_delta.indices,
ops.convert_to_tensor(sparse_delta.values, self.dtype),
name=name))
def scatter_min(self, sparse_delta, use_locking=False, name=None):
"""Updates this variable with the min of `tf.IndexedSlices` and itself.
Args:
sparse_delta: `tf.IndexedSlices` to use as an argument of min with this
variable.
use_locking: If `True`, use locking during the operation.
name: the name of the operation.
Returns:
The updated variable.
Raises:
TypeError: if `sparse_delta` is not an `IndexedSlices`.
"""
if not isinstance(sparse_delta, ops.IndexedSlices):
raise TypeError("sparse_delta is not IndexedSlices: %s" % sparse_delta)
return self._lazy_read(
gen_resource_variable_ops.resource_scatter_min(
self.handle,
sparse_delta.indices,
ops.convert_to_tensor(sparse_delta.values, self.dtype),
name=name))
def scatter_mul(self, sparse_delta, use_locking=False, name=None):
"""Multiply this variable by `tf.IndexedSlices`.
Args:
sparse_delta: `tf.IndexedSlices` to multiply this variable by.
use_locking: If `True`, use locking during the operation.
name: the name of the operation.
Returns:
The updated variable.
Raises:
TypeError: if `sparse_delta` is not an `IndexedSlices`.
"""
if not isinstance(sparse_delta, ops.IndexedSlices):
raise TypeError("sparse_delta is not IndexedSlices: %s" % sparse_delta)
return self._lazy_read(
gen_resource_variable_ops.resource_scatter_mul(
self.handle,
sparse_delta.indices,
ops.convert_to_tensor(sparse_delta.values, self.dtype),
name=name))
def scatter_div(self, sparse_delta, use_locking=False, name=None):
"""Divide this variable by `tf.IndexedSlices`.
Args:
sparse_delta: `tf.IndexedSlices` to divide this variable by.
use_locking: If `True`, use locking during the operation.
name: the name of the operation.
Returns:
The updated variable.
Raises:
TypeError: if `sparse_delta` is not an `IndexedSlices`.
"""
if not isinstance(sparse_delta, ops.IndexedSlices):
raise TypeError("sparse_delta is not IndexedSlices: %s" % sparse_delta)
return self._lazy_read(
gen_resource_variable_ops.resource_scatter_div(
self.handle,
sparse_delta.indices,
ops.convert_to_tensor(sparse_delta.values, self.dtype),
name=name))
def scatter_update(self, sparse_delta, use_locking=False, name=None):
"""Assigns `tf.IndexedSlices` to this variable.
Args:
sparse_delta: `tf.IndexedSlices` to be assigned to this variable.
use_locking: If `True`, use locking during the operation.
name: the name of the operation.
Returns:
The updated variable.
Raises:
TypeError: if `sparse_delta` is not an `IndexedSlices`.
"""
if not isinstance(sparse_delta, ops.IndexedSlices):
raise TypeError("sparse_delta is not IndexedSlices: %s" % sparse_delta)
return self._lazy_read(
gen_resource_variable_ops.resource_scatter_update(
self.handle,
sparse_delta.indices,
ops.convert_to_tensor(sparse_delta.values, self.dtype),
name=name))
def batch_scatter_update(self, sparse_delta, use_locking=False, name=None):
"""Assigns `tf.IndexedSlices` to this variable batch-wise.
Analogous to `batch_gather`. This assumes that this variable and the
sparse_delta IndexedSlices have a series of leading dimensions that are the
same for all of them, and the updates are performed on the last dimension of
indices. In other words, the dimensions should be the following:
`num_prefix_dims = sparse_delta.indices.ndims - 1`
`batch_dim = num_prefix_dims + 1`
`sparse_delta.updates.shape = sparse_delta.indices.shape + var.shape[
batch_dim:]`
where
`sparse_delta.updates.shape[:num_prefix_dims]`
`== sparse_delta.indices.shape[:num_prefix_dims]`
`== var.shape[:num_prefix_dims]`
And the operation performed can be expressed as:
`var[i_1, ..., i_n,
sparse_delta.indices[i_1, ..., i_n, j]] = sparse_delta.updates[
i_1, ..., i_n, j]`
When sparse_delta.indices is a 1D tensor, this operation is equivalent to
`scatter_update`.
To avoid this operation one can looping over the first `ndims` of the
variable and using `scatter_update` on the subtensors that result of slicing
the first dimension. This is a valid option for `ndims = 1`, but less
efficient than this implementation.
Args:
sparse_delta: `tf.IndexedSlices` to be assigned to this variable.
use_locking: If `True`, use locking during the operation.
name: the name of the operation.
Returns:
The updated variable.
Raises:
TypeError: if `sparse_delta` is not an `IndexedSlices`.
"""
if not isinstance(sparse_delta, ops.IndexedSlices):
raise TypeError("sparse_delta is not IndexedSlices: %s" % sparse_delta)
return self._lazy_read(
state_ops.batch_scatter_update(
self,
sparse_delta.indices,
sparse_delta.values,
use_locking=use_locking,
name=name))
def scatter_nd_sub(self, indices, updates, name=None):
"""Applies sparse subtraction to individual values or slices in a Variable.
`ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
`indices` must be integer tensor, containing indices into `ref`.
It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
The innermost dimension of `indices` (with length `K`) corresponds to
indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
dimension of `ref`.
`updates` is `Tensor` of rank `Q-1+P-K` with shape:
```
[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
```
For example, say we want to add 4 scattered elements to a rank-1 tensor to
8 elements. In Python, that update would look like this:
```python
ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
indices = tf.constant([[4], [3], [1] ,[7]])
updates = tf.constant([9, 10, 11, 12])
op = ref.scatter_nd_sub(indices, updates)
with tf.compat.v1.Session() as sess:
print sess.run(op)
```
The resulting update to ref would look like this:
[1, -9, 3, -6, -6, 6, 7, -4]
See `tf.scatter_nd` for more details about how to make updates to
slices.
Args:
indices: The indices to be used in the operation.
updates: The values to be used in the operation.
name: the name of the operation.
Returns:
The updated variable.
"""
return self._lazy_read(
gen_state_ops.resource_scatter_nd_sub(
self.handle,
indices,
ops.convert_to_tensor(updates, self.dtype),
name=name))
def scatter_nd_add(self, indices, updates, name=None):
"""Applies sparse addition to individual values or slices in a Variable.
`ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
`indices` must be integer tensor, containing indices into `ref`.
It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
The innermost dimension of `indices` (with length `K`) corresponds to
indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
dimension of `ref`.
`updates` is `Tensor` of rank `Q-1+P-K` with shape:
```
[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
```
For example, say we want to add 4 scattered elements to a rank-1 tensor to
8 elements. In Python, that update would look like this:
```python
ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
indices = tf.constant([[4], [3], [1] ,[7]])
updates = tf.constant([9, 10, 11, 12])
add = ref.scatter_nd_add(indices, updates)
with tf.compat.v1.Session() as sess:
print sess.run(add)
```
The resulting update to ref would look like this:
[1, 13, 3, 14, 14, 6, 7, 20]
See `tf.scatter_nd` for more details about how to make updates to
slices.
Args:
indices: The indices to be used in the operation.
updates: The values to be used in the operation.
name: the name of the operation.
Returns:
The updated variable.
"""
return self._lazy_read(
gen_state_ops.resource_scatter_nd_add(
self.handle,
indices,
ops.convert_to_tensor(updates, self.dtype),
name=name))
def scatter_nd_update(self, indices, updates, name=None):
"""Applies sparse assignment to individual values or slices in a Variable.
`ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
`indices` must be integer tensor, containing indices into `ref`.
It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
The innermost dimension of `indices` (with length `K`) corresponds to
indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
dimension of `ref`.
`updates` is `Tensor` of rank `Q-1+P-K` with shape:
```
[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
```
For example, say we want to add 4 scattered elements to a rank-1 tensor to
8 elements. In Python, that update would look like this:
```python
ref = tf.Variable([1, 2, 3, 4, 5, 6, 7, 8])
indices = tf.constant([[4], [3], [1] ,[7]])
updates = tf.constant([9, 10, 11, 12])
op = ref.scatter_nd_update(indices, updates)
with tf.compat.v1.Session() as sess:
print sess.run(op)
```
The resulting update to ref would look like this:
[1, 11, 3, 10, 9, 6, 7, 12]
See `tf.scatter_nd` for more details about how to make updates to
slices.
Args:
indices: The indices to be used in the operation.
updates: The values to be used in the operation.
name: the name of the operation.
Returns:
The updated variable.
"""
return self._lazy_read(
gen_state_ops.resource_scatter_nd_update(
self.handle,
indices,
ops.convert_to_tensor(updates, self.dtype),
name=name))
def scatter_nd_max(self, indices, updates, name=None):
"""Updates this variable with the max of `tf.IndexedSlices` and itself.
`ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
`indices` must be integer tensor, containing indices into `ref`.
It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
The innermost dimension of `indices` (with length `K`) corresponds to
indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
dimension of `ref`.
`updates` is `Tensor` of rank `Q-1+P-K` with shape:
```
[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
```
See `tf.scatter_nd` for more details about how to make updates to
slices.
Args:
indices: The indices to be used in the operation.
updates: The values to be used in the operation.
name: the name of the operation.
Returns:
The updated variable.
"""
return self._lazy_read(
gen_state_ops.resource_scatter_nd_max(
self.handle,
indices,
ops.convert_to_tensor(updates, self.dtype),
name=name))
def scatter_nd_min(self, indices, updates, name=None):
"""Updates this variable with the min of `tf.IndexedSlices` and itself.
`ref` is a `Tensor` with rank `P` and `indices` is a `Tensor` of rank `Q`.
`indices` must be integer tensor, containing indices into `ref`.
It must be shape `[d_0, ..., d_{Q-2}, K]` where `0 < K <= P`.
The innermost dimension of `indices` (with length `K`) corresponds to
indices into elements (if `K = P`) or slices (if `K < P`) along the `K`th
dimension of `ref`.
`updates` is `Tensor` of rank `Q-1+P-K` with shape:
```
[d_0, ..., d_{Q-2}, ref.shape[K], ..., ref.shape[P-1]].
```
See `tf.scatter_nd` for more details about how to make updates to
slices.
Args:
indices: The indices to be used in the operation.
updates: The values to be used in the operation.
name: the name of the operation.
Returns:
The updated variable.
"""
return self._lazy_read(
gen_state_ops.resource_scatter_nd_min(
self.handle,
indices,
ops.convert_to_tensor(updates, self.dtype),
name=name))
def _strided_slice_assign(self, begin, end, strides, value, name, begin_mask,
end_mask, ellipsis_mask, new_axis_mask,
shrink_axis_mask):
with _handle_graph(self.handle), self._assign_dependencies():
return self._lazy_read(
gen_array_ops.resource_strided_slice_assign(
ref=self.handle,
begin=begin,
end=end,
strides=strides,
value=ops.convert_to_tensor(value, dtype=self.dtype),
name=name,
begin_mask=begin_mask,
end_mask=end_mask,
ellipsis_mask=ellipsis_mask,
new_axis_mask=new_axis_mask,
shrink_axis_mask=shrink_axis_mask))
def __complex__(self):
return complex(self.value().numpy())
def __int__(self):
return int(self.value().numpy())
def __long__(self):
return long(self.value().numpy())
def __float__(self):
return float(self.value().numpy())
def _dense_var_to_tensor(self, dtype=None, name=None, as_ref=False):
del name
if dtype is not None and not dtype.is_compatible_with(self.dtype):
raise ValueError(
"Incompatible type conversion requested to type {!r} for variable "
"of type {!r}".format(dtype.name, self.dtype.name))
if as_ref:
return self.read_value().op.inputs[0]
else:
return self.value()
def __iadd__(self, unused_other):
raise RuntimeError("Variable += value not supported. Use "
"variable.assign_add(value) to modify the variable "
"value and variable = variable + value to get a new "
"Tensor object.")
def __isub__(self, unused_other):
raise RuntimeError("Variable -= value not supported. Use "
"variable.assign_sub(value) to modify the variable "
"value and variable = variable - value to get a new "
"Tensor object.")
def __imul__(self, unused_other):
raise RuntimeError("Variable *= value not supported. Use "
"`var.assign(var * value)` to modify the variable or "
"`var = var * value` to get a new Tensor object.")
def __idiv__(self, unused_other):
raise RuntimeError("Variable /= value not supported. Use "
"`var.assign(var / value)` to modify the variable or "
"`var = var / value` to get a new Tensor object.")
def __itruediv__(self, unused_other):
raise RuntimeError("Variable /= value not supported. Use "
"`var.assign(var / value)` to modify the variable or "
"`var = var / value` to get a new Tensor object.")
def __irealdiv__(self, unused_other):
raise RuntimeError("Variable /= value not supported. Use "
"`var.assign(var / value)` to modify the variable or "
"`var = var / value` to get a new Tensor object.")
def __ipow__(self, unused_other):
raise RuntimeError("Variable **= value not supported. Use "
"`var.assign(var ** value)` to modify the variable or "
"`var = var ** value` to get a new Tensor object.")
class ResourceVariable(BaseResourceVariable):
"""Variable based on resource handles.
See the [Variables How To](https://tensorflow.org/guide/variables)
for a high level overview.
A `ResourceVariable` allows you to maintain state across subsequent calls to
session.run.
The `ResourceVariable` constructor requires an initial value for the variable,
which can be a `Tensor` of any type and shape. The initial value defines the
type and shape of the variable. After construction, the type and shape of
the variable are fixed. The value can be changed using one of the assign
methods.
Just like any `Tensor`, variables created with
`tf.Variable(use_resource=True)` can be used as inputs for other Ops in the
graph. Additionally, all the operators overloaded for the `Tensor` class are
carried over to variables, so you can also add nodes to the graph by just
doing arithmetic on variables.
Unlike ref-based variable, a ResourceVariable has well-defined semantics. Each
usage of a ResourceVariable in a TensorFlow graph adds a read_value operation
to the graph. The Tensors returned by a read_value operation are guaranteed to
see all modifications to the value of the variable which happen in any
operation on which the read_value depends on (either directly, indirectly, or
via a control dependency) and guaranteed to not see any modification to the
value of the variable from operations that depend on the read_value operation.
Updates from operations that have no dependency relationship to the read_value
operation might or might not be visible to read_value.
For example, if there is more than one assignment to a ResourceVariable in
a single session.run call there is a well-defined value for each operation
which uses the variable's value if the assignments and the read are connected
by edges in the graph. Consider the following example, in which two writes
can cause tf.Variable and tf.ResourceVariable to behave differently:
```python
a = tf.Variable(1.0, use_resource=True)
a.initializer.run()
assign = a.assign(2.0)
with tf.control_dependencies([assign]):
b = a.read_value()
with tf.control_dependencies([b]):
other_assign = a.assign(3.0)
with tf.control_dependencies([other_assign]):
# Will print 2.0 because the value was read before other_assign ran. If
# `a` was a tf.Variable instead, 2.0 or 3.0 could be printed.
tf.compat.v1.Print(b, [b]).eval()
```
"""
def __init__(
self, # pylint: disable=super-init-not-called
initial_value=None,
trainable=None,
collections=None,
validate_shape=True, # pylint: disable=unused-argument
caching_device=None,
name=None,
dtype=None,
variable_def=None,
import_scope=None,
constraint=None,
distribute_strategy=None,
synchronization=None,
aggregation=None,
shape=None):
"""Creates a variable.
Args:
initial_value: A `Tensor`, or Python object convertible to a `Tensor`,
which is the initial value for the Variable. Can also be a callable with
no argument that returns the initial value when called. (Note that
initializer functions from init_ops.py must first be bound to a shape
before being used here.)
trainable: If `True`, the default, also adds the variable to the graph
collection `GraphKeys.TRAINABLE_VARIABLES`. This collection is used as
the default list of variables to use by the `Optimizer` classes.
Defaults to `True`, unless `synchronization` is set to `ON_READ`, in
which case it defaults to `False`.
collections: List of graph collections keys. The new variable is added to
these collections. Defaults to `[GraphKeys.GLOBAL_VARIABLES]`.
validate_shape: Ignored. Provided for compatibility with tf.Variable.
caching_device: Optional device string or function describing where the
Variable should be cached for reading. Defaults to the Variable's
device. If not `None`, caches on another device. Typical use is to
cache on the device where the Ops using the Variable reside, to
deduplicate copying through `Switch` and other conditional statements.
name: Optional name for the variable. Defaults to `'Variable'` and gets
uniquified automatically.
dtype: If set, initial_value will be converted to the given type. If None,
either the datatype will be kept (if initial_value is a Tensor) or
float32 will be used (if it is a Python object convertible to a Tensor).
variable_def: `VariableDef` protocol buffer. If not None, recreates the
`ResourceVariable` object with its contents. `variable_def` and other
arguments (except for import_scope) are mutually exclusive.
import_scope: Optional `string`. Name scope to add to the
ResourceVariable. Only used when `variable_def` is provided.
constraint: An optional projection function to be applied to the variable
after being updated by an `Optimizer` (e.g. used to implement norm
constraints or value constraints for layer weights). The function must
take as input the unprojected Tensor representing the value of the
variable and return the Tensor for the projected value (which must have
the same shape). Constraints are not safe to use when doing asynchronous
distributed training.
distribute_strategy: The tf.distribute.Strategy this variable is being
created inside of.
synchronization: Indicates when a distributed a variable will be
aggregated. Accepted values are constants defined in the class
`tf.VariableSynchronization`. By default the synchronization is set to
`AUTO` and the current `DistributionStrategy` chooses when to
synchronize.
aggregation: Indicates how a distributed variable will be aggregated.
Accepted values are constants defined in the class
`tf.VariableAggregation`.
shape: (optional) The shape of this variable. If None, the shape of
`initial_value` will be used. When setting this argument to
`tf.TensorShape(None)` (representing an unspecified shape), the variable
can be assigned with values of different shapes.
Raises:
ValueError: If the initial value is not specified, or does not have a
shape and `validate_shape` is `True`.
@compatibility(eager)
When Eager Execution is enabled, the default for the `collections` argument
is `None`, which signifies that this `Variable` will not be added to any
collections.
@end_compatibility
"""
if variable_def:
if initial_value is not None:
raise ValueError("variable_def and initial_value are mutually "
"exclusive.")
if context.executing_eagerly():
raise ValueError("Creating ResourceVariable from variable_def is "
"not supported when eager execution is enabled.")
self._init_from_proto(variable_def, import_scope=import_scope)
else:
self._init_from_args(
initial_value=initial_value,
trainable=trainable,
collections=collections,
caching_device=caching_device,
name=name,
dtype=dtype,
constraint=constraint,
synchronization=synchronization,
aggregation=aggregation,
shape=shape,
distribute_strategy=distribute_strategy)
def _init_from_args(self,
initial_value=None,
trainable=None,
collections=None,
caching_device=None,
name=None,
dtype=None,
constraint=None,
synchronization=None,
aggregation=None,
distribute_strategy=None,
shape=None):
"""Creates a variable.
Args:
initial_value: A `Tensor`, or Python object convertible to a `Tensor`,
which is the initial value for the Variable. The initial value must have
a shape specified unless `validate_shape` is set to False. Can also be a
callable with no argument that returns the initial value when called.
(Note that initializer functions from init_ops.py must first be bound to
a shape before being used here.)
trainable: If `True`, the default, also adds the variable to the graph
collection `GraphKeys.TRAINABLE_VARIABLES`. This collection is used as
the default list of variables to use by the `Optimizer` classes.
Defaults to `True`, unless `synchronization` is set to `ON_READ`, in
which case it defaults to `False`.
collections: List of graph collections keys. The new variable is added to
these collections. Defaults to `[GraphKeys.GLOBAL_VARIABLES]`.
caching_device: Optional device string or function describing where the
Variable should be cached for reading. Defaults to the Variable's
device. If not `None`, caches on another device. Typical use is to
cache on the device where the Ops using the Variable reside, to
deduplicate copying through `Switch` and other conditional statements.
name: Optional name for the variable. Defaults to `'Variable'` and gets
uniquified automatically.
dtype: If set, initial_value will be converted to the given type. If None,
either the datatype will be kept (if initial_value is a Tensor) or
float32 will be used (if it is a Python object convertible to a Tensor).
constraint: An optional projection function to be applied to the variable
after being updated by an `Optimizer` (e.g. used to implement norm
constraints or value constraints for layer weights). The function must
take as input the unprojected Tensor representing the value of the
variable and return the Tensor for the projected value (which must have
the same shape). Constraints are not safe to use when doing asynchronous
distributed training.
synchronization: Indicates when a distributed a variable will be
aggregated. Accepted values are constants defined in the class
`tf.VariableSynchronization`. By default the synchronization is set to
`AUTO` and the current `DistributionStrategy` chooses when to
synchronize.
aggregation: Indicates how a distributed variable will be aggregated.
Accepted values are constants defined in the class
`tf.VariableAggregation`.
distribute_strategy: DistributionStrategy under which this variable was
created.
shape: (optional) The shape of this variable. If None, the shape of
`initial_value` will be used. When setting this argument to
`tf.TensorShape(None)` (representing an unspecified shape), the variable
can be assigned with values of different shapes.
Raises:
ValueError: If the initial value is not specified, or does not have a
shape and `validate_shape` is `True`.
@compatibility(eager)
When Eager Execution is enabled, variables are never added to collections.
It is not implicitly added to the `GLOBAL_VARIABLES` or
`TRAINABLE_VARIABLES` collections, and the `collections` argument is
ignored.
@end_compatibility
"""
synchronization, aggregation, trainable = (
variables.validate_synchronization_aggregation_trainable(
synchronization, aggregation, trainable, name))
if initial_value is None:
raise ValueError("initial_value must be specified.")
init_from_fn = callable(initial_value)
if isinstance(initial_value, ops.Tensor) and hasattr(
initial_value, "graph") and initial_value.graph.building_function:
raise ValueError("Tensor-typed variable initializers must either be "
"wrapped in an init_scope or callable "
"(e.g., `tf.Variable(lambda : "
"tf.truncated_normal([10, 40]))`) when building "
"functions. Please file a feature request if this "
"restriction inconveniences you.")
if collections is None:
collections = [ops.GraphKeys.GLOBAL_VARIABLES]
if not isinstance(collections, (list, tuple, set)):
raise ValueError(
"collections argument to Variable constructor must be a list, tuple, "
"or set. Got %s of type %s" % (collections, type(collections)))
if constraint is not None and not callable(constraint):
raise ValueError("The `constraint` argument must be a callable.")
if trainable and ops.GraphKeys.TRAINABLE_VARIABLES not in collections:
collections = list(collections) + [ops.GraphKeys.TRAINABLE_VARIABLES]
with ops.init_scope():
self._in_graph_mode = not context.executing_eagerly()
with ops.name_scope(
name,
"Variable", [] if init_from_fn else [initial_value],
skip_on_eager=False) as name:
# pylint: disable=protected-access
handle_name = ops.name_from_scope_name(name)
if self._in_graph_mode:
shared_name = handle_name
unique_id = shared_name
else:
# When in eager mode use a uid for the shared_name, to prevent
# accidental sharing.
unique_id = "%s_%d" % (handle_name, ops.uid())
shared_name = None # Never shared
# Use attr_scope and device(None) to simulate the behavior of
# colocate_with when the variable we want to colocate with doesn't
# yet exist.
device_context_manager = (
ops.device if self._in_graph_mode else ops.NullContextmanager)
attr = attr_value_pb2.AttrValue(
list=attr_value_pb2.AttrValue.ListValue(
s=[compat.as_bytes("loc:@%s" % handle_name)]))
with ops.get_default_graph()._attr_scope({"_class": attr}):
with ops.name_scope("Initializer"), device_context_manager(None):
if init_from_fn:
initial_value = initial_value()
if isinstance(initial_value, trackable.CheckpointInitialValue):
self._maybe_initialize_trackable()
self._update_uid = initial_value.checkpoint_position.restore_uid
initial_value = initial_value.wrapped_value
initial_value = ops.convert_to_tensor(initial_value,
name="initial_value",
dtype=dtype)
if shape is not None:
if not initial_value.shape.is_compatible_with(shape):
raise ValueError(
"The initial value's shape (%s) is not compatible with "
"the explicitly supplied `shape` argument (%s)." %
(initial_value.shape, shape))
else:
shape = initial_value.shape
handle = eager_safe_variable_handle(
initial_value=initial_value,
shape=shape,
shared_name=shared_name,
name=name,
graph_mode=self._in_graph_mode)
# pylint: disable=protected-access
if (self._in_graph_mode and initial_value is not None and
initial_value.op._get_control_flow_context() is not None):
raise ValueError(
"Initializer for variable %s is from inside a control-flow "
"construct, such as a loop or conditional. When creating a "
"variable inside a loop or conditional, use a lambda as the "
"initializer." % name)
# pylint: enable=protected-access
dtype = initial_value.dtype.base_dtype
if self._in_graph_mode:
with ops.name_scope("IsInitialized"):
is_initialized_op = (
gen_resource_variable_ops.var_is_initialized_op(handle))
if initial_value is not None:
# pylint: disable=g-backslash-continuation
with ops.name_scope("Assign") as n, \
ops.colocate_with(None, ignore_existing=True), \
ops.device(handle.device):
# pylint: disable=protected-access
initializer_op = (
gen_resource_variable_ops.assign_variable_op(
handle,
variables._try_guard_against_uninitialized_dependencies(
name, initial_value),
name=n))
# pylint: enable=protected-access
# pylint: enable=g-backslash-continuation
with ops.name_scope("Read"):
# Manually assign reads to the handle's device to avoid log
# messages.
with ops.device(handle.device):
value = gen_resource_variable_ops.read_variable_op(handle, dtype)
_maybe_set_handle_data(dtype, handle, value)
graph_element = value
if caching_device is not None:
# Variables may be created in a tf.device() or ops.colocate_with()
# context. At the same time, users would expect caching device to
# be independent of this context, and/or would not expect the
# current device context to be merged with the caching device
# spec. Therefore we reset the colocation stack before creating
# the cached value. Note that resetting the colocation stack will
# also reset the device stack.
with ops.colocate_with(None, ignore_existing=True):
with ops.device(caching_device):
cached_value = array_ops.identity(value)
else:
cached_value = None
else:
gen_resource_variable_ops.assign_variable_op(handle, initial_value)
is_initialized_op = None
initializer_op = None
graph_element = None
if caching_device:
with ops.device(caching_device):
cached_value = gen_resource_variable_ops.read_variable_op(
handle, dtype)
_maybe_set_handle_data(dtype, handle, cached_value)
else:
cached_value = None
if cached_value is not None:
# Store the variable object so that the original variable can be
# accessed to generate functions that are compatible with SavedModel.
cached_value._cached_variable = weakref.ref(self) # pylint: disable=protected-access
if not context.executing_eagerly():
# Eager variables are only added to collections if they are part of an
# eager variable store (otherwise in an interactive session they would
# hog memory and cause OOM). This is done in ops/variable_scope.py.
ops.add_to_collections(collections, self)
elif ops.GraphKeys.GLOBAL_STEP in collections:
ops.add_to_collections(ops.GraphKeys.GLOBAL_STEP, self)
initial_value = initial_value if self._in_graph_mode else None
super(ResourceVariable, self).__init__(
trainable=trainable,
shape=shape,
dtype=dtype,
handle=handle,
synchronization=synchronization,
constraint=constraint,
aggregation=aggregation,
distribute_strategy=distribute_strategy,
name=name,
unique_id=unique_id,
handle_name=handle_name,
graph_element=graph_element,
initial_value=initial_value,
initializer_op=initializer_op,
is_initialized_op=is_initialized_op,
cached_value=cached_value,
caching_device=caching_device)
def _init_from_proto(self, variable_def, import_scope=None):
"""Initializes from `VariableDef` proto."""
# Note that init_from_proto is currently not supported in Eager mode.
assert not context.executing_eagerly()
self._in_graph_mode = True
assert isinstance(variable_def, variable_pb2.VariableDef)
if not variable_def.is_resource:
raise ValueError("Trying to restore Variable as ResourceVariable.")
# Create from variable_def.
g = ops.get_default_graph()
self._handle = g.as_graph_element(
ops.prepend_name_scope(
variable_def.variable_name, import_scope=import_scope))
self._shape = tensor_shape.TensorShape(self._handle.op.get_attr("shape"))
self._handle_name = self._handle.name
self._unique_id = self._handle_name
self._initializer_op = g.as_graph_element(
ops.prepend_name_scope(
variable_def.initializer_name, import_scope=import_scope))
# Check whether initial_value_name exists for backwards compatibility.
if (hasattr(variable_def, "initial_value_name") and
variable_def.initial_value_name):
self._initial_value = g.as_graph_element(
ops.prepend_name_scope(
variable_def.initial_value_name, import_scope=import_scope))
else:
self._initial_value = None
synchronization, aggregation, trainable = (
variables.validate_synchronization_aggregation_trainable(
variable_def.synchronization, variable_def.aggregation,
variable_def.trainable, variable_def.variable_name))
self._synchronization = synchronization
self._aggregation = aggregation
self._trainable = trainable
if variable_def.snapshot_name:
snapshot = g.as_graph_element(
ops.prepend_name_scope(
variable_def.snapshot_name, import_scope=import_scope))
if snapshot.op.type != "ReadVariableOp":
self._cached_value = snapshot
else:
self._cached_value = None
while snapshot.op.type != "ReadVariableOp":
snapshot = snapshot.op.inputs[0]
self._graph_element = snapshot
else:
self._cached_value = None
# Legacy case for protos without the snapshot name; assume it's the
# following.
self._graph_element = g.get_tensor_by_name(self._handle.op.name +
"/Read/ReadVariableOp:0")
if variable_def.HasField("save_slice_info_def"):
self._save_slice_info = variables.Variable.SaveSliceInfo(
save_slice_info_def=variable_def.save_slice_info_def,
import_scope=import_scope)
else:
self._save_slice_info = None
self._caching_device = None
self._dtype = dtypes.as_dtype(self._handle.op.get_attr("dtype"))
self._constraint = None
class UninitializedVariable(BaseResourceVariable):
"""A variable with no initializer."""
def __init__( # pylint: disable=super-init-not-called
self,
trainable=None,
caching_device=None,
name=None,
shape=None,
dtype=None,
constraint=None,
synchronization=None,
aggregation=None,
extra_handle_data=None,
distribute_strategy=None,
**unused_kwargs):
"""Creates the variable handle.
Args:
trainable: If `True`, GradientTapes automatically watch uses of this
Variable.
caching_device: Optional device string or function describing where the
Variable should be cached for reading. Defaults to the Variable's
device. If not `None`, caches on another device. Typical use is to
cache on the device where the Ops using the Variable reside, to
deduplicate copying through `Switch` and other conditional statements.
name: Optional name for the variable. Defaults to `'Variable'` and gets
uniquified automatically.
shape: The variable's shape.
dtype: The variable's dtype.
constraint: An optional projection function to be applied to the variable
after being updated by an `Optimizer` (e.g. used to implement norm
constraints or value constraints for layer weights). The function must
take as input the unprojected Tensor representing the value of the
variable and return the Tensor for the projected value (which must have
the same shape). Constraints are not safe to use when doing asynchronous
distributed training.
synchronization: Indicates when a distributed a variable will be
aggregated. Accepted values are constants defined in the class
`tf.VariableSynchronization`. By default the synchronization is set to
`AUTO` and the current `DistributionStrategy` chooses when to
synchronize.
aggregation: Indicates how a distributed variable will be aggregated.
Accepted values are constants defined in the class
`tf.VariableAggregation`.
extra_handle_data: Optional, another resource handle or Tensor with handle
data to merge with `shape` and `dtype`.
distribute_strategy: The tf.distribute.Strategy this variable is being
created inside of.
"""
with ops.init_scope():
self._in_graph_mode = not context.executing_eagerly()
with ops.init_scope():
with ops.name_scope(name, "Variable", skip_on_eager=False) as name:
handle_name = ops.name_from_scope_name(name)
if self._in_graph_mode:
shared_name = handle_name
unique_id = shared_name
else:
unique_id = "%s_%d" % (handle_name, ops.uid())
shared_name = None # Never shared
handle = _variable_handle_from_shape_and_dtype(
shape=shape,
dtype=dtype,
shared_name=shared_name,
name=name,
graph_mode=self._in_graph_mode,
initial_value=extra_handle_data)
if not context.executing_eagerly():
with ops.name_scope("Read"):
# Manually assign reads to the handle's device to avoid log
# messages.
with ops.device(handle.device):
value = gen_resource_variable_ops.read_variable_op(handle, dtype)
_maybe_set_handle_data(dtype, handle, value)
graph_element = value
ops.add_to_collection(ops.GraphKeys.GLOBAL_VARIABLES, self)
# Do *not* add to TRAINABLE_VARIABLES here, even if self._trainable,
# because retraining or frozen use of imported SavedModels is
# controlled at higher levels of model building.
else:
graph_element = None
super(UninitializedVariable, self).__init__(
distribute_strategy=distribute_strategy,
shape=shape,
dtype=dtype,
unique_id=unique_id,
handle_name=handle_name,
constraint=constraint,
handle=handle,
graph_element=graph_element,
trainable=trainable,
synchronization=synchronization,
aggregation=aggregation)
_pywrap_utils.RegisterType("ResourceVariable", ResourceVariable)
math_ops._resource_variable_type = ResourceVariable # pylint: disable=protected-access
def _dense_var_to_tensor(var, dtype=None, name=None, as_ref=False):
return var._dense_var_to_tensor(dtype=dtype, name=name, as_ref=as_ref) # pylint: disable=protected-access
# Register a conversion function which reads the value of the variable,
# allowing instances of the class to be used as tensors.
ops.register_tensor_conversion_function(BaseResourceVariable,
_dense_var_to_tensor)
class _UnreadVariable(BaseResourceVariable):
"""Represents a future for a read of a variable.
Pretends to be the tensor if anyone looks.
"""
def __init__(self, handle, dtype, shape, in_graph_mode, deleter, parent_op,
unique_id):
if isinstance(handle, ops.EagerTensor):
handle_name = ""
else:
handle_name = handle.name
# Only create a graph_element if we're in session.run-land as only
# session.run requires a preexisting tensor to evaluate. Otherwise we can
# avoid accidentally reading the variable.
if context.executing_eagerly() or ops.inside_function():
graph_element = None
else:
with ops.control_dependencies([parent_op]):
graph_element = gen_resource_variable_ops.read_variable_op(
handle, dtype)
_maybe_set_handle_data(dtype, handle, graph_element)
super(_UnreadVariable, self).__init__(
handle=handle,
shape=shape,
handle_name=handle_name,
unique_id=unique_id,
dtype=dtype,
handle_deleter=deleter,
graph_element=graph_element)
self._parent_op = parent_op
@property
def name(self):
if self._in_graph_mode:
return self._parent_op.name
else:
return "UnreadVariable"
def value(self):
return self._read_variable_op()
def read_value(self):
return self._read_variable_op()
def _read_variable_op(self):
with ops.control_dependencies([self._parent_op]):
result = gen_resource_variable_ops.read_variable_op(
self._handle, self._dtype)
_maybe_set_handle_data(self._dtype, self._handle, result)
return result
def assign_sub(self, delta, use_locking=None, name=None, read_value=True):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).assign_sub(delta, use_locking, name,
read_value)
def assign_add(self, delta, use_locking=None, name=None, read_value=True):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).assign_add(delta, use_locking, name,
read_value)
def assign(self, value, use_locking=None, name=None, read_value=True):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).assign(value, use_locking, name,
read_value)
def scatter_sub(self, sparse_delta, use_locking=False, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).scatter_sub(sparse_delta, use_locking,
name)
def scatter_add(self, sparse_delta, use_locking=False, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).scatter_add(sparse_delta, use_locking,
name)
def scatter_max(self, sparse_delta, use_locking=False, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).scatter_max(sparse_delta, use_locking,
name)
def scatter_min(self, sparse_delta, use_locking=False, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).scatter_min(sparse_delta, use_locking,
name)
def scatter_mul(self, sparse_delta, use_locking=False, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).scatter_mul(sparse_delta, use_locking,
name)
def scatter_div(self, sparse_delta, use_locking=False, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).scatter_div(sparse_delta, use_locking,
name)
def scatter_update(self, sparse_delta, use_locking=False, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable,
self).scatter_update(sparse_delta, use_locking, name)
def batch_scatter_update(self, sparse_delta, use_locking=False, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable,
self).batch_scatter_update(sparse_delta, use_locking, name)
def scatter_nd_sub(self, indices, updates, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).scatter_nd_sub(indices, updates, name)
def scatter_nd_add(self, indices, updates, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).scatter_nd_add(indices, updates, name)
def scatter_nd_update(self, indices, updates, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable,
self).scatter_nd_update(indices, updates, name)
def scatter_nd_max(self, indices, updates, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).scatter_nd_max(indices, updates, name)
def scatter_nd_min(self, indices, updates, name=None):
with ops.control_dependencies([self._parent_op]):
return super(_UnreadVariable, self).scatter_nd_min(indices, updates, name)
@property
def op(self):
"""The op for this variable."""
return self._parent_op
@ops.RegisterGradient("ReadVariableOp")
def _ReadGrad(_, grad):
"""Gradient for read op."""
return grad
def variable_shape(handle, out_type=dtypes.int32):
if getattr(handle, "_handle_data",
None) is None or not handle._handle_data.is_set: # pylint: disable=protected-access
return gen_resource_variable_ops.variable_shape(handle, out_type=out_type)
shape_proto = handle._handle_data.shape_and_type[0].shape # pylint: disable=protected-access
if shape_proto.unknown_rank or any(x.size == -1 for x in shape_proto.dim):
return gen_resource_variable_ops.variable_shape(handle, out_type=out_type)
return constant_op.constant([x.size for x in shape_proto.dim], dtype=out_type)
@ops.RegisterGradient("ResourceGather")
def _GatherGrad(op, grad):
"""Gradient for gather op."""
# Build appropriately shaped IndexedSlices
handle = op.inputs[0]
indices = op.inputs[1]
params_shape = variable_shape(handle)
size = array_ops.expand_dims(array_ops.size(indices), 0)
values_shape = array_ops.concat([size, params_shape[1:]], 0)
values = array_ops.reshape(grad, values_shape)
indices = array_ops.reshape(indices, size)
return (ops.IndexedSlices(values, indices, params_shape), None)
def _to_proto_fn(v, export_scope=None):
"""Converts Variable and ResourceVariable to VariableDef for collections."""
return v.to_proto(export_scope=export_scope)
def _from_proto_fn(v, import_scope=None):
"""Creates Variable or ResourceVariable from VariableDef as needed."""
if v.is_resource:
return ResourceVariable.from_proto(v, import_scope=import_scope)
return variables.Variable.from_proto(v, import_scope=import_scope)
ops.register_proto_function(
ops.GraphKeys.GLOBAL_VARIABLES,
proto_type=variable_pb2.VariableDef,
to_proto=_to_proto_fn,
from_proto=_from_proto_fn)
ops.register_proto_function(
ops.GraphKeys.TRAINABLE_VARIABLES,
proto_type=variable_pb2.VariableDef,
to_proto=_to_proto_fn,
from_proto=_from_proto_fn)
ops.register_proto_function(
ops.GraphKeys.MOVING_AVERAGE_VARIABLES,
proto_type=variable_pb2.VariableDef,
to_proto=_to_proto_fn,
from_proto=_from_proto_fn)
ops.register_proto_function(
ops.GraphKeys.LOCAL_VARIABLES,
proto_type=variable_pb2.VariableDef,
to_proto=_to_proto_fn,
from_proto=_from_proto_fn)
ops.register_proto_function(
ops.GraphKeys.MODEL_VARIABLES,
proto_type=variable_pb2.VariableDef,
to_proto=_to_proto_fn,
from_proto=_from_proto_fn)
ops.register_proto_function(
ops.GraphKeys.GLOBAL_STEP,
proto_type=variable_pb2.VariableDef,
to_proto=_to_proto_fn,
from_proto=_from_proto_fn)
ops.register_proto_function(
ops.GraphKeys.METRIC_VARIABLES,
proto_type=variable_pb2.VariableDef,
to_proto=_to_proto_fn,
from_proto=_from_proto_fn)
@tf_export("__internal__.ops.is_resource_variable", v1=[])
def is_resource_variable(var):
""""Returns True if `var` is to be considered a ResourceVariable."""
return isinstance(var, BaseResourceVariable) or hasattr(
var, "_should_act_as_resource_variable")
def copy_to_graph_uninitialized(var):
"""Copies an existing variable to a new graph, with no initializer."""
# Like ResourceVariable.__deepcopy__, but does not set an initializer on the
# new variable.
# pylint: disable=protected-access
new_variable = UninitializedVariable(
trainable=var.trainable,
constraint=var._constraint,
shape=var.shape,
dtype=var.dtype,
name=var._shared_name,
synchronization=var.synchronization,
aggregation=var.aggregation,
extra_handle_data=var.handle)
new_variable._maybe_initialize_trackable()
# pylint: enable=protected-access
return new_variable
ops.NotDifferentiable("Assert")
ops.NotDifferentiable("VarIsInitializedOp")
ops.NotDifferentiable("VariableShape")
class VariableSpec(tensor_spec.DenseSpec):
"""Describes a tf.Variable."""
__slots__ = []
value_type = property(lambda self: BaseResourceVariable)
def _to_components(self, value):
raise NotImplementedError
def _from_components(self, components):
raise NotImplementedError
def _from_compatible_tensor_list(self, tensor_list):
assert len(tensor_list) == 1
return tensor_list[0]
_pywrap_utils.RegisterType("VariableSpec", VariableSpec)
| 39.898544 | 109 | 0.681946 |
fe0124140e8dc2027f4fadfec1fb4b85b67e1042 | 4,049 | py | Python | tb_generator.py | benfild/dataScience_playground | 403f9b324f1e3f078c5d4aaea5c1b5eb97922052 | [
"MIT"
] | null | null | null | tb_generator.py | benfild/dataScience_playground | 403f9b324f1e3f078c5d4aaea5c1b5eb97922052 | [
"MIT"
] | null | null | null | tb_generator.py | benfild/dataScience_playground | 403f9b324f1e3f078c5d4aaea5c1b5eb97922052 | [
"MIT"
] | null | null | null | """
Generate synthetic TB data
Most common symptoms occuring over 80% of the time (also halmark signs):
1. Cough for two weeks or more (productive)
2. Night sweats
3. Fever
4. Weight loss
Common symptoms occuring over 50% of the time
1. Chest pain
2. Malaise
3. Difficulty breathing
Signs and their prevalences:
Malnourished - 80%
Increased Respiratory rate - 50%
Reduced air entry/fluid filled lung - 50%
Risk Factors
1. Weakened immune system* (HIV) - 62% co morbidity
2. Having diabetes - twice as likely
3. Malnutrition (Low BMI) - 80%
4. Recurrent infection of any kind - 80%
5. Substance abuse
6. Smoking
7. Contact with TB
8. History of TB in the family - 80%
Gender distributions
Female - 50%
Male - 80%
Age distribution
< 2 years - 10%
2 - 16 years - 25%
16+ - 65%
"""
# VERY IMPORTANT: You have to generate a lot of data (law of large numbers) so that they eventually converge to the probabilities
from scipy.stats import bernoulli, halfnorm, norm
import csv
import random
print("Initializing ....")
# setting the random seed
random.seed(30)
# Making the strong assumption that the chance of having TB is 50/50
# (This is a mistake because the prevalence of TB is significatly lower than this)
p = 0.5
# How many data points are we creating (number of synthetic patients)
N_records = 10000
# TB positive case statuses
cases = bernoulli.rvs(p, size=N_records)
def generate_patient(status):
"""
This function takes the status of a patient (1 = positive and 0 = negative)
and returns the expected characteristics of this patient given the status
"""
# sex is female with p=0.5 if the status is 0 and p=0.8 if status is 1
# This means its more likely the patient is male if the status is 1
sex = bernoulli.rvs(0.5) if status == 0 else bernoulli.rvs(0.8)
# symptoms
dry_cough = bernoulli.rvs(0.3) if status == 0 else bernoulli.rvs(0.6)
productive_cough = bernoulli.rvs(0.3) if status == 0 else bernoulli.rvs(0.8)
# NOTE: cough_duration should be enhanced with more stochasticity, you could be coughing for only 2 days but still be positive
cough_duration = halfnorm.rvs(0, 2) if status == 0 else norm.rvs(14, 5) # Number of days coughing
night_sweats = bernoulli.rvs(0.3) if status == 0 else bernoulli.rvs(0.8)
fever = bernoulli.rvs(0.4) if status == 0 else bernoulli.rvs(0.8)
weight_loss = bernoulli.rvs(0.3) if status == 0 else bernoulli.rvs(0.8)
# dyspnoea is the same as difficulty breathing
dyspnoea = bernoulli.rvs(0.2) if status == 0 else bernoulli.rvs(0.45)
chest_pain = bernoulli.rvs(0.2) if status == 0 else bernoulli.rvs(0.45)
# signs
# if you dont have HIV, we assume the national average of 0.05
hiv_positive = bernoulli.rvs(0.05) if status == 0 else bernoulli.rvs(0.62)
mulnutrition = bernoulli.rvs(0.3) if status == 0 else bernoulli.rvs(0.8)
# It is more likely to have TB if you are a smoker, and its more likely to be a smoker if you are male
smoking = bernoulli.rvs(0.5) if sex == 1 else bernoulli.rvs(0.15) if status == 0 else bernoulli.rvs(0.8)
family_tb = bernoulli.rvs(0.1) if status == 0 else bernoulli.rvs(0.8)
return [sex, dry_cough, productive_cough, round(cough_duration), night_sweats, fever, weight_loss, dyspnoea, chest_pain, hiv_positive, mulnutrition, smoking, family_tb, status]
print(f"Generating {N_records} synthetic patients ...")
# loop through the statuses and create new patients based on the status
patients = [generate_patient(x) for x in cases]
print("Patient genertion completed. Writing to file")
with open('synthetic_tb_patients.csv', mode='w') as tb_file:
tb_writer = csv.writer(tb_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
tb_writer.writerow(['sex', 'dry_cough', 'productive_cough', 'cough_duration', 'night_sweats', 'fever', 'weight_loss', 'dyspnoea', 'chest_pain', 'hiv_positive', 'mulnutrition', 'smoking', 'family_tb', 'status'])
for patient in patients:
tb_writer.writerow(patient)
print("Process completed") | 34.905172 | 214 | 0.718696 |
eac19db37ab97f5f04118de2fb1e073b3926b0c8 | 618 | py | Python | django_dashboard/migrations/0082_auto_20180606_2202.py | keepexploring/smartbiogas | ca663435b05666113e3c0cb55e6f087c61497208 | [
"MIT"
] | null | null | null | django_dashboard/migrations/0082_auto_20180606_2202.py | keepexploring/smartbiogas | ca663435b05666113e3c0cb55e6f087c61497208 | [
"MIT"
] | 10 | 2017-11-24T12:15:40.000Z | 2022-02-10T06:41:32.000Z | django_dashboard/migrations/0082_auto_20180606_2202.py | keepexploring/smartbiogas | ca663435b05666113e3c0cb55e6f087c61497208 | [
"MIT"
] | null | null | null | # -*- coding: utf-8 -*-
# Generated by Django 1.11.11 on 2018-06-06 22:02
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('django_dashboard', '0081_auto_20180606_2035'),
]
operations = [
migrations.AlterField(
model_name='userdetail',
name='logged_in_as',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='logged_in_as', to='django_dashboard.Company'),
),
]
| 28.090909 | 164 | 0.677994 |
0707974b749175bc09d92ba9af7c1e85f8615975 | 351 | py | Python | other/dingding/dingtalk/api/rest/OapiChatNickBatchupdateRequest.py | hth945/pytest | 83e2aada82a2c6a0fdd1721320e5bf8b8fd59abc | [
"Apache-2.0"
] | null | null | null | other/dingding/dingtalk/api/rest/OapiChatNickBatchupdateRequest.py | hth945/pytest | 83e2aada82a2c6a0fdd1721320e5bf8b8fd59abc | [
"Apache-2.0"
] | null | null | null | other/dingding/dingtalk/api/rest/OapiChatNickBatchupdateRequest.py | hth945/pytest | 83e2aada82a2c6a0fdd1721320e5bf8b8fd59abc | [
"Apache-2.0"
] | null | null | null | '''
Created by auto_sdk on 2019.08.01
'''
from dingtalk.api.base import RestApi
class OapiChatNickBatchupdateRequest(RestApi):
def __init__(self,url=None):
RestApi.__init__(self,url)
self.chatid = None
self.user_nick_model = None
def getHttpMethod(self):
return 'POST'
def getapiname(self):
return 'dingtalk.oapi.chat.nick.batchupdate'
| 21.9375 | 46 | 0.757835 |
33f4bec4f49fbd60e5aa711e2679befafe371dd4 | 2,428 | py | Python | data/cirq_new/cirq_program/startCirq_noisy715.py | UCLA-SEAL/QDiff | d968cbc47fe926b7f88b4adf10490f1edd6f8819 | [
"BSD-3-Clause"
] | null | null | null | data/cirq_new/cirq_program/startCirq_noisy715.py | UCLA-SEAL/QDiff | d968cbc47fe926b7f88b4adf10490f1edd6f8819 | [
"BSD-3-Clause"
] | null | null | null | data/cirq_new/cirq_program/startCirq_noisy715.py | UCLA-SEAL/QDiff | d968cbc47fe926b7f88b4adf10490f1edd6f8819 | [
"BSD-3-Clause"
] | null | null | null | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 5/15/20 4:49 PM
# @File : grover.py
# qubit number=4
# total number=22
import cirq
import cirq.google as cg
from typing import Optional
import sys
from math import log2
import numpy as np
#thatsNoCode
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.H.on(input_qubit[1])) # number=7
c.append(cirq.H.on(input_qubit[2])) # number=3
c.append(cirq.H.on(input_qubit[3])) # number=4
c.append(cirq.H.on(input_qubit[0])) # number=16
c.append(cirq.CZ.on(input_qubit[3],input_qubit[0])) # number=17
c.append(cirq.H.on(input_qubit[0])) # number=18
c.append(cirq.H.on(input_qubit[0])) # number=19
c.append(cirq.CZ.on(input_qubit[3],input_qubit[0])) # number=20
c.append(cirq.H.on(input_qubit[0])) # number=21
c.append(cirq.SWAP.on(input_qubit[1],input_qubit[0])) # number=8
c.append(cirq.SWAP.on(input_qubit[1],input_qubit[0])) # number=9
c.append(cirq.SWAP.on(input_qubit[1],input_qubit[0])) # number=10
c.append(cirq.SWAP.on(input_qubit[1],input_qubit[0])) # number=11
c.append(cirq.SWAP.on(input_qubit[1],input_qubit[0])) # number=12
c.append(cirq.SWAP.on(input_qubit[1],input_qubit[0])) # number=13
c.append(cirq.SWAP.on(input_qubit[3],input_qubit[0])) # number=14
c.append(cirq.SWAP.on(input_qubit[3],input_qubit[0])) # number=15
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def bitstring(bits):
return ''.join(str(int(b)) for b in bits)
if __name__ == '__main__':
qubit_count = 4
input_qubits = [cirq.GridQubit(i, 0) for i in range(qubit_count)]
circuit = make_circuit(qubit_count,input_qubits)
circuit = cg.optimized_for_sycamore(circuit, optimizer_type='sqrt_iswap')
circuit_sample_count =2820
circuit = circuit.with_noise(cirq.depolarize(p=0.01))
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=circuit_sample_count)
frequencies = result.histogram(key='result', fold_func=bitstring)
writefile = open("../data/startCirq_noisy715.csv","w+")
print(format(frequencies),file=writefile)
print("results end", file=writefile)
print(circuit.__len__(), file=writefile)
print(circuit,file=writefile)
writefile.close() | 34.197183 | 77 | 0.689044 |
2fd89d0018f27926ac295045027fdd331a6876d2 | 3,306 | py | Python | functions/code_connect.py | chvolkmann/code-connect-fish-plugin | ef6323f200edb7df4732e5412f77fdfa0056caa9 | [
"MIT"
] | null | null | null | functions/code_connect.py | chvolkmann/code-connect-fish-plugin | ef6323f200edb7df4732e5412f77fdfa0056caa9 | [
"MIT"
] | null | null | null | functions/code_connect.py | chvolkmann/code-connect-fish-plugin | ef6323f200edb7df4732e5412f77fdfa0056caa9 | [
"MIT"
] | null | null | null | #!/usr/bin/env python3
# based on https://stackoverflow.com/a/60949722
import time
import subprocess as sp
import os
from distutils.spawn import find_executable
from typing import Iterable, List, Tuple
from pathlib import Path
MAX_IDLE_TIME = 4 * 60 * 60
def fail(*msgs, retcode=1):
for msg in msgs:
print(msg)
exit(retcode)
def is_socket_open(path: Path) -> bool:
try:
# capture output to prevent printing to stdout/stderr
proc = sp.run(['socat', '-u', 'OPEN:/dev/null', f'UNIX-CONNECT:{path.resolve()}'], capture_output=True)
return (proc.returncode == 0)
except FileNotFoundError:
return False
def sort_by_access_timestamp(paths: Iterable[Path]) -> List[Tuple[float, Path]]:
paths = [(p.stat().st_atime, p) for p in paths]
paths = sorted(paths, reverse=True)
return paths
def next_open_socket(socks: Iterable[Path]) -> Path:
try:
return next((sock for sock in socks if is_socket_open(sock)))
except StopIteration:
fail(
'Could not find an open VS Code IPC socket.',
'',
'Please make sure to connect to this machine with a standard VS Code remote SSH session before using this tool.'
)
def check_for_binaries():
if find_executable('socat') is None:
fail(
'"socat" not found in $PATH, but is required for code-connect'
)
def main(shell: str = None, max_idle_time: int = MAX_IDLE_TIME):
check_for_binaries()
# Determine shell for outputting the proper format
if not shell:
shell = os.getenv('SHELL', 'bash')
shell_path = Path(shell)
if shell_path.exists():
# Just get the name of the binary
shell = shell_path.name
# Every entry in ~/.vscode-server/bin corresponds to a commit id
# Pick the most recent one
code_repos = sort_by_access_timestamp(Path.home().glob('.vscode-server/bin/*'))
if len(code_repos) == 0:
fail(
'No installation of VS Code Server detected!',
'',
'Please connect to this machine through a remote SSH session and try again.',
'Afterwards there should exist a folder under ~/.vscode-server'
)
_, code_repo = code_repos[0]
code_binary = code_repo / 'bin' / 'code'
# List all possible sockets for the current user
# Some of these are obsolete and not listening
uid = os.getuid()
socks = sort_by_access_timestamp(Path(f'/run/user/{uid}/').glob('vscode-ipc-*.sock'))
# Only consider the ones that were active N seconds ago
now = time.time()
socks = [sock for ts, sock in socks if now - ts <= max_idle_time]
# Find the first socket that is open, most recently accessed first
ipc_sock = next_open_socket(socks)
# Output a shell string to stdout
if shell == 'fish':
source_lines = [
f'# fish usage: ./code_connect.py | source',
f'export VSCODE_IPC_HOOK_CLI="{ipc_sock}"',
f'alias code="{code_binary}"'
]
else:
source_lines = [
f'# bash usage: ./code_connect.py | eval',
f'export VSCODE_IPC_HOOK_CLI="{ipc_sock}"',
f'alias code="{code_binary}"'
]
print('\n'.join(source_lines))
if __name__ == '__main__':
main() | 32.097087 | 124 | 0.631881 |
32183e5269b0afc3b06f818bc70c00a7474a98e4 | 72 | py | Python | src/test-01.py | chenghua521/test | daf6560df810c5a4129e75cfda3cd15f3259cad5 | [
"MIT"
] | null | null | null | src/test-01.py | chenghua521/test | daf6560df810c5a4129e75cfda3cd15f3259cad5 | [
"MIT"
] | null | null | null | src/test-01.py | chenghua521/test | daf6560df810c5a4129e75cfda3cd15f3259cad5 | [
"MIT"
] | null | null | null | def test():
print("hello, world!")
if __name__ == '__main__':
test() | 12 | 26 | 0.611111 |
2d40604975c5517769393832eee45c3fa26e2cb0 | 19,537 | py | Python | python/ray/tune/tune.py | mxz96102/ray | 02768ad707f615a47a4a5f28ae333c25012baaa1 | [
"Apache-2.0"
] | null | null | null | python/ray/tune/tune.py | mxz96102/ray | 02768ad707f615a47a4a5f28ae333c25012baaa1 | [
"Apache-2.0"
] | null | null | null | python/ray/tune/tune.py | mxz96102/ray | 02768ad707f615a47a4a5f28ae333c25012baaa1 | [
"Apache-2.0"
] | null | null | null | import logging
from ray.tune.error import TuneError
from ray.tune.experiment import convert_to_experiment_list, Experiment
from ray.tune.analysis import ExperimentAnalysis
from ray.tune.suggest import BasicVariantGenerator
from ray.tune.suggest.suggestion import Searcher, SearchGenerator
from ray.tune.trial import Trial
from ray.tune.trainable import Trainable
from ray.tune.ray_trial_executor import RayTrialExecutor
from ray.tune.registry import get_trainable_cls
from ray.tune.syncer import wait_for_sync
from ray.tune.trial_runner import TrialRunner
from ray.tune.progress_reporter import CLIReporter, JupyterNotebookReporter
from ray.tune.schedulers import (HyperBandScheduler, AsyncHyperBandScheduler,
FIFOScheduler, MedianStoppingRule)
from ray.tune.web_server import TuneServer
logger = logging.getLogger(__name__)
_SCHEDULERS = {
"FIFO": FIFOScheduler,
"MedianStopping": MedianStoppingRule,
"HyperBand": HyperBandScheduler,
"AsyncHyperBand": AsyncHyperBandScheduler,
}
try:
class_name = get_ipython().__class__.__name__
IS_NOTEBOOK = True if "Terminal" not in class_name else False
except NameError:
IS_NOTEBOOK = False
def _make_scheduler(args):
if args.scheduler in _SCHEDULERS:
return _SCHEDULERS[args.scheduler](**args.scheduler_config)
else:
raise TuneError("Unknown scheduler: {}, should be one of {}".format(
args.scheduler, _SCHEDULERS.keys()))
def _check_default_resources_override(run_identifier):
if not isinstance(run_identifier, str):
# If obscure dtype, assume it is overriden.
return True
trainable_cls = get_trainable_cls(run_identifier)
return hasattr(trainable_cls, "default_resource_request") and (
trainable_cls.default_resource_request.__code__ !=
Trainable.default_resource_request.__code__)
def _report_progress(runner, reporter, done=False):
"""Reports experiment progress.
Args:
runner (TrialRunner): Trial runner to report on.
reporter (ProgressReporter): Progress reporter.
done (bool): Whether this is the last progress report attempt.
"""
trials = runner.get_trials()
if reporter.should_report(trials, done=done):
sched_debug_str = runner.scheduler_alg.debug_string()
executor_debug_str = runner.trial_executor.debug_string()
reporter.report(trials, done, sched_debug_str, executor_debug_str)
def run(run_or_experiment,
name=None,
stop=None,
config=None,
resources_per_trial=None,
num_samples=1,
local_dir=None,
upload_dir=None,
trial_name_creator=None,
loggers=None,
log_to_file=False,
sync_to_cloud=None,
sync_to_driver=None,
checkpoint_freq=0,
checkpoint_at_end=False,
sync_on_checkpoint=True,
keep_checkpoints_num=None,
checkpoint_score_attr=None,
global_checkpoint_period=10,
export_formats=None,
max_failures=0,
fail_fast=False,
restore=None,
search_alg=None,
scheduler=None,
with_server=False,
server_port=TuneServer.DEFAULT_PORT,
verbose=2,
progress_reporter=None,
resume=False,
queue_trials=False,
reuse_actors=False,
trial_executor=None,
raise_on_failed_trial=True,
return_trials=False,
ray_auto_init=True):
"""Executes training.
Args:
run_or_experiment (function | class | str | :class:`Experiment`): If
function|class|str, this is the algorithm or model to train.
This may refer to the name of a built-on algorithm
(e.g. RLLib's DQN or PPO), a user-defined trainable
function or class, or the string identifier of a
trainable function or class registered in the tune registry.
If Experiment, then Tune will execute training based on
Experiment.spec. If you want to pass in a Python lambda, you
will need to first register the function:
``tune.register_trainable("lambda_id", lambda x: ...)``. You can
then use ``tune.run("lambda_id")``.
name (str): Name of experiment.
stop (dict | callable | :class:`Stopper`): Stopping criteria. If dict,
the keys may be any field in the return result of 'train()',
whichever is reached first. If function, it must take (trial_id,
result) as arguments and return a boolean (True if trial should be
stopped, False otherwise). This can also be a subclass of
``ray.tune.Stopper``, which allows users to implement
custom experiment-wide stopping (i.e., stopping an entire Tune
run based on some time constraint).
config (dict): Algorithm-specific configuration for Tune variant
generation (e.g. env, hyperparams). Defaults to empty dict.
Custom search algorithms may ignore this.
resources_per_trial (dict): Machine resources to allocate per trial,
e.g. ``{"cpu": 64, "gpu": 8}``. Note that GPUs will not be
assigned unless you specify them here. Defaults to 1 CPU and 0
GPUs in ``Trainable.default_resource_request()``.
num_samples (int): Number of times to sample from the
hyperparameter space. Defaults to 1. If `grid_search` is
provided as an argument, the grid will be repeated
`num_samples` of times.
local_dir (str): Local dir to save training results to.
Defaults to ``~/ray_results``.
upload_dir (str): Optional URI to sync training results and checkpoints
to (e.g. ``s3://bucket`` or ``gs://bucket``).
trial_name_creator (func): Optional function for generating
the trial string representation.
loggers (list): List of logger creators to be used with
each Trial. If None, defaults to ray.tune.logger.DEFAULT_LOGGERS.
See `ray/tune/logger.py`.
log_to_file (bool|str|Sequence): Log stdout and stderr to files in
Tune's trial directories. If this is `False` (default), no files
are written. If `true`, outputs are written to `trialdir/stdout`
and `trialdir/stderr`, respectively. If this is a single string,
this is interpreted as a file relative to the trialdir, to which
both streams are written. If this is a Sequence (e.g. a Tuple),
it has to have length 2 and the elements indicate the files to
which stdout and stderr are written, respectively.
sync_to_cloud (func|str): Function for syncing the local_dir to and
from upload_dir. If string, then it must be a string template that
includes `{source}` and `{target}` for the syncer to run. If not
provided, the sync command defaults to standard S3 or gsutil sync
commands. By default local_dir is synced to remote_dir every 300
seconds. To change this, set the TUNE_CLOUD_SYNC_S
environment variable in the driver machine.
sync_to_driver (func|str|bool): Function for syncing trial logdir from
remote node to local. If string, then it must be a string template
that includes `{source}` and `{target}` for the syncer to run.
If True or not provided, it defaults to using rsync. If False,
syncing to driver is disabled.
checkpoint_freq (int): How many training iterations between
checkpoints. A value of 0 (default) disables checkpointing.
This has no effect when using the Functional Training API.
checkpoint_at_end (bool): Whether to checkpoint at the end of the
experiment regardless of the checkpoint_freq. Default is False.
This has no effect when using the Functional Training API.
sync_on_checkpoint (bool): Force sync-down of trial checkpoint to
driver. If set to False, checkpoint syncing from worker to driver
is asynchronous and best-effort. This does not affect persistent
storage syncing. Defaults to True.
keep_checkpoints_num (int): Number of checkpoints to keep. A value of
`None` keeps all checkpoints. Defaults to `None`. If set, need
to provide `checkpoint_score_attr`.
checkpoint_score_attr (str): Specifies by which attribute to rank the
best checkpoint. Default is increasing order. If attribute starts
with `min-` it will rank attribute in decreasing order, i.e.
`min-validation_loss`.
global_checkpoint_period (int): Seconds between global checkpointing.
This does not affect `checkpoint_freq`, which specifies frequency
for individual trials.
export_formats (list): List of formats that exported at the end of
the experiment. Default is None.
max_failures (int): Try to recover a trial at least this many times.
Ray will recover from the latest checkpoint if present.
Setting to -1 will lead to infinite recovery retries.
Setting to 0 will disable retries. Defaults to 3.
fail_fast (bool): Whether to fail upon the first error.
restore (str): Path to checkpoint. Only makes sense to set if
running 1 trial. Defaults to None.
search_alg (Searcher): Search algorithm for optimization.
scheduler (TrialScheduler): Scheduler for executing
the experiment. Choose among FIFO (default), MedianStopping,
AsyncHyperBand, HyperBand and PopulationBasedTraining. Refer to
ray.tune.schedulers for more options.
with_server (bool): Starts a background Tune server. Needed for
using the Client API.
server_port (int): Port number for launching TuneServer.
verbose (int): 0, 1, or 2. Verbosity mode. 0 = silent,
1 = only status updates, 2 = status and trial results.
progress_reporter (ProgressReporter): Progress reporter for reporting
intermediate experiment progress. Defaults to CLIReporter if
running in command-line, or JupyterNotebookReporter if running in
a Jupyter notebook.
resume (str|bool): One of "LOCAL", "REMOTE", "PROMPT", or bool.
LOCAL/True restores the checkpoint from the local_checkpoint_dir.
REMOTE restores the checkpoint from remote_checkpoint_dir.
PROMPT provides CLI feedback. False forces a new
experiment. If resume is set but checkpoint does not exist,
ValueError will be thrown.
queue_trials (bool): Whether to queue trials when the cluster does
not currently have enough resources to launch one. This should
be set to True when running on an autoscaling cluster to enable
automatic scale-up.
reuse_actors (bool): Whether to reuse actors between different trials
when possible. This can drastically speed up experiments that start
and stop actors often (e.g., PBT in time-multiplexing mode). This
requires trials to have the same resource requirements.
trial_executor (TrialExecutor): Manage the execution of trials.
raise_on_failed_trial (bool): Raise TuneError if there exists failed
trial (of ERROR state) when the experiments complete.
ray_auto_init (bool): Automatically starts a local Ray cluster
if using a RayTrialExecutor (which is the default) and
if Ray is not initialized. Defaults to True.
Returns:
ExperimentAnalysis: Object for experiment analysis.
Raises:
TuneError: Any trials failed and `raise_on_failed_trial` is True.
Examples:
.. code-block:: python
# Run 10 trials (each trial is one instance of a Trainable). Tune runs
# in parallel and automatically determines concurrency.
tune.run(trainable, num_samples=10)
# Run 1 trial, stop when trial has reached 10 iterations
tune.run(my_trainable, stop={"training_iteration": 10})
# Run 1 trial, search over hyperparameters, stop after 10 iterations.
space = {"lr": tune.uniform(0, 1), "momentum": tune.uniform(0, 1)}
tune.run(my_trainable, config=space, stop={"training_iteration": 10})
"""
config = config or {}
trial_executor = trial_executor or RayTrialExecutor(
queue_trials=queue_trials,
reuse_actors=reuse_actors,
ray_auto_init=ray_auto_init)
if isinstance(run_or_experiment, list):
experiments = run_or_experiment
else:
experiments = [run_or_experiment]
for i, exp in enumerate(experiments):
if not isinstance(exp, Experiment):
run_identifier = Experiment.register_if_needed(exp)
experiments[i] = Experiment(
name=name,
run=run_identifier,
stop=stop,
config=config,
resources_per_trial=resources_per_trial,
num_samples=num_samples,
local_dir=local_dir,
upload_dir=upload_dir,
sync_to_driver=sync_to_driver,
trial_name_creator=trial_name_creator,
loggers=loggers,
log_to_file=log_to_file,
checkpoint_freq=checkpoint_freq,
checkpoint_at_end=checkpoint_at_end,
sync_on_checkpoint=sync_on_checkpoint,
keep_checkpoints_num=keep_checkpoints_num,
checkpoint_score_attr=checkpoint_score_attr,
export_formats=export_formats,
max_failures=max_failures,
restore=restore)
else:
logger.debug("Ignoring some parameters passed into tune.run.")
if sync_to_cloud:
for exp in experiments:
assert exp.remote_checkpoint_dir, (
"Need `upload_dir` if `sync_to_cloud` given.")
if fail_fast and max_failures != 0:
raise ValueError("max_failures must be 0 if fail_fast=True.")
if issubclass(type(search_alg), Searcher):
search_alg = SearchGenerator(search_alg)
runner = TrialRunner(
search_alg=search_alg or BasicVariantGenerator(),
scheduler=scheduler or FIFOScheduler(),
local_checkpoint_dir=experiments[0].checkpoint_dir,
remote_checkpoint_dir=experiments[0].remote_checkpoint_dir,
sync_to_cloud=sync_to_cloud,
stopper=experiments[0].stopper,
checkpoint_period=global_checkpoint_period,
resume=resume,
launch_web_server=with_server,
server_port=server_port,
verbose=bool(verbose > 1),
fail_fast=fail_fast,
trial_executor=trial_executor)
for exp in experiments:
runner.add_experiment(exp)
if progress_reporter is None:
if IS_NOTEBOOK:
progress_reporter = JupyterNotebookReporter(overwrite=verbose < 2)
else:
progress_reporter = CLIReporter()
# User Warning for GPUs
if trial_executor.has_gpus():
if isinstance(resources_per_trial,
dict) and "gpu" in resources_per_trial:
# "gpu" is manually set.
pass
elif _check_default_resources_override(experiments[0].run_identifier):
# "default_resources" is manually overriden.
pass
else:
logger.warning("Tune detects GPUs, but no trials are using GPUs. "
"To enable trials to use GPUs, set "
"tune.run(resources_per_trial={'gpu': 1}...) "
"which allows Tune to expose 1 GPU to each trial. "
"You can also override "
"`Trainable.default_resource_request` if using the "
"Trainable API.")
while not runner.is_finished():
runner.step()
if verbose:
_report_progress(runner, progress_reporter)
try:
runner.checkpoint(force=True)
except Exception:
logger.exception("Trial Runner checkpointing failed.")
if verbose:
_report_progress(runner, progress_reporter, done=True)
wait_for_sync()
runner.cleanup_trials()
incomplete_trials = []
for trial in runner.get_trials():
if trial.status != Trial.TERMINATED:
incomplete_trials += [trial]
if incomplete_trials:
if raise_on_failed_trial:
raise TuneError("Trials did not complete", incomplete_trials)
else:
logger.error("Trials did not complete: %s", incomplete_trials)
trials = runner.get_trials()
if return_trials:
return trials
return ExperimentAnalysis(runner.checkpoint_file, trials=trials)
def run_experiments(experiments,
search_alg=None,
scheduler=None,
with_server=False,
server_port=TuneServer.DEFAULT_PORT,
verbose=2,
progress_reporter=None,
resume=False,
queue_trials=False,
reuse_actors=False,
trial_executor=None,
raise_on_failed_trial=True,
concurrent=True):
"""Runs and blocks until all trials finish.
Examples:
>>> experiment_spec = Experiment("experiment", my_func)
>>> run_experiments(experiments=experiment_spec)
>>> experiment_spec = {"experiment": {"run": my_func}}
>>> run_experiments(experiments=experiment_spec)
>>> run_experiments(
>>> experiments=experiment_spec,
>>> scheduler=MedianStoppingRule(...))
>>> run_experiments(
>>> experiments=experiment_spec,
>>> search_alg=SearchAlgorithm(),
>>> scheduler=MedianStoppingRule(...))
Returns:
List of Trial objects, holding data for each executed trial.
"""
# This is important to do this here
# because it schematize the experiments
# and it conducts the implicit registration.
experiments = convert_to_experiment_list(experiments)
if concurrent:
return run(
experiments,
search_alg=search_alg,
scheduler=scheduler,
with_server=with_server,
server_port=server_port,
verbose=verbose,
progress_reporter=progress_reporter,
resume=resume,
queue_trials=queue_trials,
reuse_actors=reuse_actors,
trial_executor=trial_executor,
raise_on_failed_trial=raise_on_failed_trial,
return_trials=True)
else:
trials = []
for exp in experiments:
trials += run(
exp,
search_alg=search_alg,
scheduler=scheduler,
with_server=with_server,
server_port=server_port,
verbose=verbose,
progress_reporter=progress_reporter,
resume=resume,
queue_trials=queue_trials,
reuse_actors=reuse_actors,
trial_executor=trial_executor,
raise_on_failed_trial=raise_on_failed_trial,
return_trials=True)
return trials
| 43.31929 | 79 | 0.647285 |
d683f9d639d77f5fdc3ccb0df7aca004907537fc | 1,921 | py | Python | InstallerPlugins/_metadata.py | EnjoyLifeFund/macHighSierra-py36-pkgs | 5668b5785296b314ea1321057420bcd077dba9ea | [
"BSD-3-Clause",
"BSD-2-Clause",
"MIT"
] | 4 | 2019-03-11T18:05:49.000Z | 2021-05-22T21:09:09.000Z | InstallerPlugins/_metadata.py | EnjoyLifeFund/macHighSierra-py36-pkgs | 5668b5785296b314ea1321057420bcd077dba9ea | [
"BSD-3-Clause",
"BSD-2-Clause",
"MIT"
] | null | null | null | InstallerPlugins/_metadata.py | EnjoyLifeFund/macHighSierra-py36-pkgs | 5668b5785296b314ea1321057420bcd077dba9ea | [
"BSD-3-Clause",
"BSD-2-Clause",
"MIT"
] | 1 | 2019-03-18T18:53:36.000Z | 2019-03-18T18:53:36.000Z | # This file is generated by objective.metadata
#
# Last update: Fri Sep 21 15:13:54 2012
import objc, sys
if sys.maxsize > 2 ** 32:
def sel32or64(a, b): return b
else:
def sel32or64(a, b): return a
if sys.byteorder == 'little':
def littleOrBig(a, b): return a
else:
def littleOrBig(a, b): return b
misc = {
}
misc.update({'InstallerSection_Private': objc.createStructType('InstallerSection_Private', b'{InstallerSection_Private=}', []), 'InstallerState_Private': objc.createStructType('InstallerState_Private', b'{InstallerState_Private=}', []), 'InstallerPane_Private': objc.createStructType('InstallerPane_Private', b'{InstallerPane_Private=}', [])})
constants = '''$InstallerState_Choice_CustomLocation$InstallerState_Choice_Identifier$InstallerState_Choice_Installed$'''
enums = '''$InstallerDirectionBackward@1$InstallerDirectionForward@0$InstallerDirectionUndefined@2$'''
misc.update({})
r = objc.registerMetaDataForSelector
objc._updatingMetadata(True)
try:
r(b'InstallerPane', b'gotoNextPane', {'retval': {'type': 'Z'}})
r(b'InstallerPane', b'gotoPreviousPane', {'retval': {'type': 'Z'}})
r(b'InstallerPane', b'nextEnabled', {'retval': {'type': 'Z'}})
r(b'InstallerPane', b'previousEnabled', {'retval': {'type': 'Z'}})
r(b'InstallerPane', b'setNextEnabled:', {'arguments': {2: {'type': 'Z'}}})
r(b'InstallerPane', b'setPreviousEnabled:', {'arguments': {2: {'type': 'Z'}}})
r(b'InstallerPane', b'shouldExitPane:', {'retval': {'type': 'Z'}})
r(b'InstallerSection', b'gotoPane:', {'retval': {'type': 'Z'}})
r(b'InstallerSection', b'shouldLoad', {'retval': {'type': 'Z'}})
r(b'InstallerState', b'installStarted', {'retval': {'type': 'Z'}})
r(b'InstallerState', b'installSucceeded', {'retval': {'type': 'Z'}})
r(b'InstallerState', b'licenseAgreed', {'retval': {'type': 'Z'}})
finally:
objc._updatingMetadata(False)
expressions = {}
# END OF FILE
| 45.738095 | 343 | 0.680375 |
ad520129f5e58549dfe18f90300a7eef30a70c4b | 6,285 | py | Python | yapf/yapflib/long_lines_splitter.py | akuleshov7/huawei-yapf | 72c188257e2bafa4da9e553ba0ee9b86831c51b8 | [
"Apache-2.0"
] | 12 | 2020-04-24T18:12:08.000Z | 2021-06-09T16:53:10.000Z | yapf/yapflib/long_lines_splitter.py | akuleshov7/h-yapf | 72c188257e2bafa4da9e553ba0ee9b86831c51b8 | [
"Apache-2.0"
] | 1 | 2020-09-09T19:55:35.000Z | 2020-09-14T00:07:29.000Z | yapf/yapflib/long_lines_splitter.py | akuleshov7/h-yapf | 72c188257e2bafa4da9e553ba0ee9b86831c51b8 | [
"Apache-2.0"
] | null | null | null | # -*- coding: utf-8 -*-
"""
Function: Support for Recomendaion 1.7 of the Huawei Coding Style
Copyright Information: Huawei Technologies Co., Ltd. All Rights Reserved © 2010-2019
Change History: 2019-12-06 Created
"""
from lib2to3 import pytree
from lib2to3.pgen2 import token
from lib2to3.pygram import python_symbols as syms
from . import pytree_visitor
from . import pytree_utils
from . import style
def SplitLongLines(tree, enabled_lines):
if style.Get('FORCE_LONG_LINES_WRAPPING'):
splitter = _LongLinesSplitter(enabled_lines)
splitter.Visit(tree)
class _LongLinesSplitter(pytree_visitor.PyTreeVisitor):
""" Encolose long lines in parentheses, so that they can be correctly
wrapped at later steps with respect to COLUMN_LIMIT.
"""
def __init__(self, enabled_lines):
super().__init__()
self.enabled_lines = enabled_lines
def Visit_if_stmt(self, node):
for child in node.children:
self.Visit(child)
if self._condition_should_be_wrapped(node):
self._insert_parens_between(node, 'if', ':')
def Visit_while_stmt(self, node):
for child in node.children:
self.Visit(child)
if self._condition_should_be_wrapped(node):
self._insert_parens_between(node, 'while', ':')
def Visit_arith_expr(self, node):
def child_idx(child):
for i, ch in enumerate(child.parent.children):
if child is ch:
return i
if self._arith_expr_should_be_wrapped(node):
self_idx = child_idx(node)
self._insert_parens(node.parent, self_idx, self_idx)
def _line_should_be_wrapped(self, node):
""" Return True if a line is longer than COLUMN_LIMIT."""
if self.enabled_lines and node.get_lineno() not in self.enabled_lines:
return False
column_limit = style.Get('COLUMN_LIMIT')
return column_limit and self._get_line_length(node) > column_limit
def _condition_should_be_wrapped(self, node):
""" Return True if a condition expression is longer than
COLUMN_LIMIT and not enclosed in parentheses.
"""
def is_comment_node(node):
return (isinstance(node, pytree.Node)
and pytree_utils.IsCommentStatement(node))
def has_parens(node):
children = filter(lambda c: not is_comment_node(c), node.children)
children = list(children)
assert children[0].value in {'if', 'while'}
return (len(children) >= 2
and children[1].type == syms.atom
and children[2].type == token.COLON)
# If a condition is enclosed in parentheses then childer will look
# like following: [{token if}, {atom}, {lpar} ...]
# In this case we need not add extra parentheses.
#
return (self._line_should_be_wrapped(node)
and not has_parens(node)
)
def _arith_expr_should_be_wrapped(self, node):
""" Return True if an arithmetic expression is longer than
COLUMN_LIMIT and not enclosed in parentheses.
"""
# If an arithmetic statement is already within parentheses,
# then the sub-tree will look as follows:
# expr_stmt
# atom
# lpar
# arith_stmt
# rpar
#
# We should not add parentheses is this case.
#
return (self._line_should_be_wrapped(node)
and node.parent.type == syms.expr_stmt
)
def _get_line_length(self, node):
def traverse(node):
for child in node.children:
if isinstance(child, pytree.Leaf):
if pytree_utils.NodeName(child) == 'COMMENT':
continue
else:
yield child.column + len(child.value.rstrip())
elif node.type == syms.suite: # the beginning of code block
break
else:
yield from traverse(child)
assert isinstance(node, pytree.Node)
return max(traverse(node))
def _insert_parens_between(self, node, begin_tok, end_tok):
""" Insert parentheses between given token names."""
def iter_leaves(node):
for i, child in enumerate(node.children):
if isinstance(child, pytree.Leaf):
yield i, child
first = next(i for i, ch in iter_leaves(node) if ch.value == begin_tok)
last = next(i for i, ch in iter_leaves(node) if ch.value == end_tok)
first += 1
last -= 1
assert first >= last
self._insert_parens(node, first, last)
def _insert_parens(self, node, first_idx, last_idx):
""" Insert parentheses around children range [first_idx, last_idx]
For example, this function will change `node` as follows:
# input subtree
#
if_stmt
"if"
and_test
...
":" prefix=""
suite prefix=""
...
# output subtree
#
if_stmt
"if"
atom
"("
and_test
...
")"
":" prefix=""
suite prefix=""
...
"""
assert isinstance(node, pytree.Node)
def get_column(node):
if isinstance(node, pytree.Leaf):
return node.column
return get_column(node.children[0])
first = node.children[first_idx]
last = node.children[last_idx]
lpar = pytree.Leaf(token.LPAR,
'(', context=('', (first.get_lineno(), get_column(first) - 1)))
rpar = pytree.Leaf(token.RPAR,
')', context=('', (last.get_lineno(), get_column(last))))
new_node = pytree.Node(syms.atom, [lpar, rpar])
children = node.children[first_idx: last_idx + 1]
for child in children:
child.remove()
new_node.insert_child(1, child)
node.insert_child(first_idx, new_node)
| 31.113861 | 84 | 0.570406 |
f45e83a8e62b9031f3d9d90bec64bb35bd6999c5 | 3,044 | py | Python | office365/onenote/onenote.py | theodoriss/Office365-REST-Python-Client | 3bd7a62dadcd3f0a0aceeaff7584fff3fd44886e | [
"MIT"
] | 544 | 2016-08-04T17:10:16.000Z | 2022-03-31T07:17:20.000Z | office365/onenote/onenote.py | theodoriss/Office365-REST-Python-Client | 3bd7a62dadcd3f0a0aceeaff7584fff3fd44886e | [
"MIT"
] | 438 | 2016-10-11T12:24:22.000Z | 2022-03-31T19:30:35.000Z | office365/onenote/onenote.py | theodoriss/Office365-REST-Python-Client | 3bd7a62dadcd3f0a0aceeaff7584fff3fd44886e | [
"MIT"
] | 202 | 2016-08-22T19:29:40.000Z | 2022-03-30T20:26:15.000Z | from office365.entity import Entity
from office365.entity_collection import EntityCollection
from office365.onenote.notebooks.notebook_collection import NotebookCollection
from office365.onenote.operations.onenote_operation import OnenoteOperation
from office365.onenote.pages.page import OnenotePageCollection
from office365.onenote.resources.resource import OnenoteResource
from office365.onenote.sectiongroups.section_group import SectionGroup
from office365.onenote.sections.section import OnenoteSection
from office365.runtime.paths.resource_path import ResourcePath
class Onenote(Entity):
@property
def notebooks(self):
"""Retrieve a list of notebook objects.
:rtype: NotebookCollection
"""
return self.get_property('notebooks',
NotebookCollection(self.context, ResourcePath("notebooks", self.resource_path)))
@property
def operations(self):
"""Retrieve a list of OneNote operations.
:rtype: EntityCollection
"""
return self.get_property('operations',
EntityCollection(self.context, OnenoteOperation,
ResourcePath("operations", self.resource_path)))
@property
def pages(self):
"""Retrieve a list of page objects.
:rtype: OnenotePageCollection
"""
return self.get_property('pages',
OnenotePageCollection(self.context, ResourcePath("pages", self.resource_path)))
@property
def resources(self):
"""Retrieve a list of Resources objects from the specified notebook.
:rtype: EntityCollection
"""
return self.get_property('resources',
EntityCollection(self.context, OnenoteResource,
ResourcePath("resources", self.resource_path)))
@property
def sections(self):
"""Retrieve a list of onenoteSection objects from the specified notebook.
:rtype: EntityCollection
"""
return self.get_property('sections',
EntityCollection(self.context, OnenoteSection,
ResourcePath("sections", self.resource_path)))
@property
def section_groups(self):
"""Retrieve a list of onenoteSection objects from the specified notebook.
:rtype: EntityCollection
"""
return self.get_property('sectionGroups',
EntityCollection(self.context, SectionGroup,
ResourcePath("sectionGroups", self.resource_path)))
def get_property(self, name, default_value=None):
if default_value is None:
property_mapping = {
"sectionGroups": self.section_groups
}
default_value = property_mapping.get(name, None)
return super(Onenote, self).get_property(name, default_value)
| 38.531646 | 113 | 0.627792 |
48f161eebcebd044092bb9f935b22022aa4b7bbe | 97 | py | Python | pyvalidator/utils/merge.py | theteladras/py.validator | 624ace7973552c8ac9353f48acbf96ec0ecc24a9 | [
"MIT"
] | 15 | 2021-11-01T14:14:56.000Z | 2022-03-17T11:52:29.000Z | pyvalidator/utils/merge.py | theteladras/py.validator | 624ace7973552c8ac9353f48acbf96ec0ecc24a9 | [
"MIT"
] | 1 | 2022-03-16T13:39:16.000Z | 2022-03-17T09:16:00.000Z | pyvalidator/utils/merge.py | theteladras/py.validator | 624ace7973552c8ac9353f48acbf96ec0ecc24a9 | [
"MIT"
] | null | null | null | def merge(main_dict: dict, default_dict: dict) -> dict:
return {**default_dict, **main_dict}
| 32.333333 | 55 | 0.701031 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.